AQS打断原理

痛定思痛。 2022-10-16 07:22 131阅读 0赞

# 不可打断模式 #

平时加锁使用的 `reentrantLock.lock()` 方法， 默认是不可打断模式，即便 park 状态的线程被打断了，它也不会立即响应，它仍旧在 AQS 中运行着，直到拿到锁，再自己中断自己。

private final boolean parkAndCheckInterrupt() { 
        LockSupport.park(this); // 线程停在了这里。
        // 获取当前线程是否被打断了，并且清空打断标记。
        return Thread.interrupted();
    }

假设 T1 处于 park 状态，但被 T2 拿到了 T1的线程对象，调用 `t1.interrupt()` 方法，将 t1 从打断中给唤醒了。parkAndCheckInterrupt() 返回 true。

final boolean acquireQueued(final Node node, int arg) { 
        // 拿锁失败？默认是。
        boolean failed = true;
        try { 
            boolean interrupted = false;
            for (;;) 
                // 如果获得不了锁，T1 依旧会进入 park。
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) { 
                    setHead(node);  
                    p.next = null; 
                    failed = false;
                    // T1 只有拿到锁时，才能跳出这个死循环。
                    // 返回 打断标记，true。
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&            
                    parkAndCheckInterrupt())
                    // 被打断的 T1 执行到这里。
                    interrupted = true;
                	// 死循环，回到上面去重新执行。
            }
        } finally { 
            if (failed)
                cancelAcquire(node);
        }
    }

如果 T1 被打断后，拿到了锁，它返回到哪里了呢

public final void acquire(int arg) { 
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) // acquireQueued() 返回结果true。
            // 执行这个方法。
            selfInterrupt();
    }
    
    static void selfInterrupt() { 
        // T1自己重新产生一次中断。
        Thread.currentThread().interrupt();
    }

# 可打断模式 #

调用 `reentrantLock.lockInterruptibly()` 那就是可打断的。

public void lockInterruptibly() throws InterruptedException { 
        // 调用 AQS 的 acquireInterruptibly(1) 方法。
        sync.acquireInterruptibly(1);
    }

public final void acquireInterruptibly(int arg)
        throws InterruptedException { 
        // 如果当前线程被打断了，直接抛异常。
        if (Thread.interrupted())
            throw new InterruptedException();
        // 尝试拿锁。
        if (!tryAcquire(arg))
            // 那锁失败，执行该方法。
            doAcquireInterruptibly(arg);
    }

private void doAcquireInterruptibly(int arg)
        throws InterruptedException { 
        final Node node = addWaiter(Node.EXCLUSIVE);
        boolean failed = true;
        try { 
            for (;;) { 
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) { 
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    // park 的线程被打断后，直接抛异常。
                    throw new InterruptedException();
            }
        } finally { 
            if (failed)
                cancelAcquire(node);
        }
    }

# 总结 #

*  `reentrantLock.lock()` 加锁，线程是不可被打断的，因为即便 T1被打断了，它拿不到锁，从循环里出不来，依旧又会 park。
 *  `reentrantLock.lockInterruptibly()` 加锁，线程是能可被打断的，park 的线程一旦被打断，直接抛异常。