2-deadlock.js

// ============================================
// DEADLOCK - Взаимная блокировка
// ============================================

console.log('\n=== DEADLOCK - ПРОБЛЕМА ===\n');

class Mutex {
    constructor(name) {
        this.name = name;
        this.locked = false;
        this.queue = [];
    }

    async lock() {
        console.log(`[${Date.now()}] Попытка захвата ${this.name}`);
        if (!this.locked) {
            this.locked = true;
            console.log(`[${Date.now()}] ✓ Захвачен ${this.name}`);
            return;
        }
        
        console.log(`[${Date.now()}] Ожидание ${this.name}...`);
        await new Promise(resolve => this.queue.push(resolve));
        console.log(`[${Date.now()}] ✓ Захвачен ${this.name}`);
    }

    unlock() {
        console.log(`[${Date.now()}] Освобожден ${this.name}`);
        if (this.queue.length > 0) {
            const resolve = this.queue.shift();
            resolve();
        } else {
            this.locked = false;
        }
    }
}

async function demonstrateDeadlock() {
    const mutexA = new Mutex('Mutex-A');
    const mutexB = new Mutex('Mutex-B');

    async function task1() {
        console.log('\n[TASK-1] Начало');
        await mutexA.lock();
        console.log('[TASK-1] Захватил A, жду немного...');
        await new Promise(resolve => setTimeout(resolve, 100));
        
        console.log('[TASK-1] Пытаюсь захватить B...');
        await mutexB.lock();
        
        console.log('[TASK-1] Захватил оба мьютекса!');
        mutexB.unlock();
        mutexA.unlock();
        console.log('[TASK-1] Завершено\n');
    }

    async function task2() {
        console.log('\n[TASK-2] Начало');
        await mutexB.lock();
        console.log('[TASK-2] Захватил B, жду немного...');
        await new Promise(resolve => setTimeout(resolve, 100));
        
        console.log('[TASK-2] Пытаюсь захватить A...');
        await mutexA.lock();
        
        console.log('[TASK-2] Захватил оба мьютекса!');
        mutexA.unlock();
        mutexB.unlock();
        console.log('[TASK-2] Завершено\n');
    }

    console.log('Запуск двух задач...');
    console.log('Task-1: захватывает A → потом B');
    console.log('Task-2: захватывает B → потом A');
    console.log('❌ Результат: DEADLOCK!\n');

    // Это зависнет навсегда
    const timeout = new Promise(resolve => 
        setTimeout(() => {
            console.log('\n⏰ TIMEOUT: Задачи зависли в deadlock!\n');
            resolve();
        }, 3000)
    );

    await Promise.race([
        Promise.all([task1(), task2()]),
        timeout
    ]);
}

demonstrateDeadlock();

// ============================================
// РЕШЕНИЕ 1: Упорядочение захвата ресурсов
// ============================================

setTimeout(async () => {
    console.log('\n=== РЕШЕНИЕ 1: УПОРЯДОЧЕНИЕ РЕСУРСОВ ===\n');

    const mutexA = new Mutex('Mutex-A');
    const mutexB = new Mutex('Mutex-B');

    async function task1() {
        console.log('\n[TASK-1] Начало');
        // ВСЕГДА захватываем в порядке A → B
        await mutexA.lock();
        console.log('[TASK-1] Захватил A');
        await new Promise(resolve => setTimeout(resolve, 100));
        
        await mutexB.lock();
        console.log('[TASK-1] Захватил B');
        
        console.log('[TASK-1] Работаю с обоими ресурсами...');
        await new Promise(resolve => setTimeout(resolve, 50));
        
        mutexB.unlock();
        mutexA.unlock();
        console.log('[TASK-1] Завершено\n');
    }

    async function task2() {
        console.log('\n[TASK-2] Начало');
        // ТАКЖЕ захватываем в порядке A → B (не B → A!)
        await mutexA.lock();
        console.log('[TASK-2] Захватил A');
        await new Promise(resolve => setTimeout(resolve, 100));
        
        await mutexB.lock();
        console.log('[TASK-2] Захватил B');
        
        console.log('[TASK-2] Работаю с обоими ресурсами...');
        await new Promise(resolve => setTimeout(resolve, 50));
        
        mutexB.unlock();
        mutexA.unlock();
        console.log('[TASK-2] Завершено\n');
    }

    console.log('Обе задачи захватывают ресурсы в ОДИНАКОВОМ порядке: A → B');
    await Promise.all([task1(), task2()]);
    console.log('✅ РЕШЕНИЕ: Никакого deadlock!\n');

}, 4000);

// ============================================
// РЕШЕНИЕ 2: Timeout при захвате
// ============================================

setTimeout(async () => {
    console.log('\n=== РЕШЕНИЕ 2: TIMEOUT ===\n');

    class MutexWithTimeout {
        constructor(name) {
            this.name = name;
            this.locked = false;
            this.queue = [];
        }

        async lock(timeoutMs = 1000) {
            console.log(`[${Date.now()}] Попытка захвата ${this.name}`);
            
            if (!this.locked) {
                this.locked = true;
                console.log(`[${Date.now()}] ✓ Захвачен ${this.name}`);
                return true;
            }
            
            console.log(`[${Date.now()}] Ожидание ${this.name} (timeout: ${timeoutMs}ms)...`);
            
            const lockPromise = new Promise(resolve => this.queue.push(resolve));
            const timeoutPromise = new Promise(resolve => 
                setTimeout(() => resolve('timeout'), timeoutMs)
            );
            
            const result = await Promise.race([lockPromise, timeoutPromise]);
            
            if (result === 'timeout') {
                // Удаляем себя из очереди
                const index = this.queue.indexOf(lockPromise);
                if (index > -1) this.queue.splice(index, 1);
                console.log(`[${Date.now()}] ⏰ Timeout на ${this.name}`);
                return false;
            }
            
            console.log(`[${Date.now()}] ✓ Захвачен ${this.name}`);
            return true;
        }

        unlock() {
            console.log(`[${Date.now()}] Освобожден ${this.name}`);
            if (this.queue.length > 0) {
                const resolve = this.queue.shift();
                resolve('acquired');
            } else {
                this.locked = false;
            }
        }
    }

    const mutexA = new MutexWithTimeout('Mutex-A');
    const mutexB = new MutexWithTimeout('Mutex-B');

    async function taskWithRetry(id, first, second) {
        console.log(`\n[TASK-${id}] Начало`);
        
        let attempts = 0;
        const maxAttempts = 5;
        
        while (attempts < maxAttempts) {
            attempts++;
            console.log(`[TASK-${id}] Попытка ${attempts}`);
            
            const gotFirst = await first.lock(500);
            if (!gotFirst) {
                console.log(`[TASK-${id}] Не удалось захватить первый мьютекс, повтор...`);
                await new Promise(resolve => setTimeout(resolve, Math.random() * 100));
                continue;
            }
            
            const gotSecond = await second.lock(500);
            if (!gotSecond) {
                console.log(`[TASK-${id}] Не удалось захватить второй мьютекс, откатываюсь...`);
                first.unlock();
                await new Promise(resolve => setTimeout(resolve, Math.random() * 100));
                continue;
            }
            
            // Успешно захватили оба
            console.log(`[TASK-${id}] ✅ Захватил оба мьютекса, работаю...`);
            await new Promise(resolve => setTimeout(resolve, 100));
            
            second.unlock();
            first.unlock();
            console.log(`[TASK-${id}] Завершено\n`);
            return;
        }
        
        console.log(`[TASK-${id}] ❌ Не удалось захватить ресурсы за ${maxAttempts} попыток\n`);
    }

    await Promise.all([
        taskWithRetry(1, mutexA, mutexB),
        taskWithRetry(2, mutexB, mutexA)
    ]);
    
    console.log('✅ РЕШЕНИЕ: Timeout + retry предотвращают бесконечный deadlock!\n');

}, 8000);

// ============================================
// РЕШЕНИЕ 3: Try-lock (неблокирующий захват)
// ============================================

setTimeout(async () => {
    console.log('\n=== РЕШЕНИЕ 3: TRY-LOCK (неблокирующий) ===\n');

    class TryLockMutex {
        constructor(name) {
            this.name = name;
            this.locked = false;
        }

        tryLock() {
            if (!this.locked) {
                this.locked = true;
                console.log(`[${Date.now()}] ✓ Захвачен ${this.name}`);
                return true;
            }
            console.log(`[${Date.now()}] ✗ ${this.name} занят`);
            return false;
        }

        unlock() {
            console.log(`[${Date.now()}] Освобожден ${this.name}`);
            this.locked = false;
        }
    }

    const mutexA = new TryLockMutex('Mutex-A');
    const mutexB = new TryLockMutex('Mutex-B');

    async function taskWithTryLock(id, first, second) {
        console.log(`\n[TASK-${id}] Начало`);
        
        for (let attempt = 0; attempt < 10; attempt++) {
            if (!first.tryLock()) {
                await new Promise(resolve => setTimeout(resolve, 50 + Math.random() * 50));
                continue;
            }
            
            if (!second.tryLock()) {
                console.log(`[TASK-${id}] Не удалось захватить второй, откатываюсь...`);
                first.unlock();
                await new Promise(resolve => setTimeout(resolve, 50 + Math.random() * 50));
                continue;
            }
            
            // Успех
            console.log(`[TASK-${id}] ✅ Работаю с обоими ресурсами...`);
            await new Promise(resolve => setTimeout(resolve, 100));
            
            second.unlock();
            first.unlock();
            console.log(`[TASK-${id}] Завершено\n`);
            return;
        }
        
        console.log(`[TASK-${id}] ❌ Не удалось\n`);
    }

    await Promise.all([
        taskWithTryLock(1, mutexA, mutexB),
        taskWithTryLock(2, mutexB, mutexA)
    ]);
    
    console.log('✅ РЕШЕНИЕ: Try-lock позволяет избежать блокировки!\n');

}, 12000);