ReentrantLock中中断锁和非中断锁源码分析

最近读了Java并发编程的艺术记录一下

https://www.cnblogs.com/daydaynobug/p/6752837.html
关于AQS的讲解

尝试获取一个内部锁的操作（进入一个 synchronized 块）是不能被中断的

public class WriterReader {
    private Object lock;

    public WriterReader() {
        lock = this;
    }

    public void write() {
        synchronized (lock) {
            long startTime = System.currentTimeMillis();
            System.out.println("开始往这个buff写入数据…");
            for (; ; )// 模拟要处理很长时间
            {
                if (System.currentTimeMillis()
                        - startTime > Integer.MAX_VALUE) {
                    System.out.println("终于写完了");
                    break;
                }
                if (Thread.currentThread().isInterrupted()) {
                    System.out.println("被中断");
                    System.out.println(Thread.interrupted());
                    System.out.println(Thread.interrupted());
                    System.out.println(Thread.interrupted());
                    break;
                }
                System.out.println("写.........");
            }
        }
    }

    public void read() {
        synchronized (lock) {
            System.out.println("从这个buff读数据");
            if (Thread.currentThread().isInterrupted()) {
                for (int i = 0; i < 10; i++) {
                    System.out.println("read被中断");
                }
            }
        }
    }
}

public class InterruptDemo {
    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();
        WriterReader writerReader = new WriterReader();
        Thread writer = new Thread(new Runnable() {
            @Override
            public void run() {
                writerReader.write();
            }
        });
        writer.start();

        Thread reader = new Thread(new Runnable() {
            @Override
            public void run() {
                writerReader.read();
            }
        });
        reader.start();


        Thread.sleep(100);
        //这里中断写线程可以被立即响应，writer正在运行
		//writer.interrupt();
		//但是处于阻塞态的线程不可以立即响应，可以看到在writer运行结束后reader的中断情况才改变
        reader.interrupt();
        Thread.sleep(10000);
        System.out.println("reader.isInterrupted():" + reader.isInterrupted());
        writer.interrupt();
    }
}

当把reader中断后发现没有起作用，只有writer被中断结束后，reader才会响应它自己的中断

ReentrantLock的中断操作lockInterruptibly()

下面是lockInterruptibly()的代码

public void lockInterruptibly() throws InterruptedException {
        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())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

可以看到的是如果监测到中断就直接throw new InterruptedException();抛出来了，所以可以响应中断

下面是lock()的代码

有两个实现类实现了lock()方法，NonfairSync非公平锁和FairSync公平锁

NonfairSync

	final void lock() {
	    if (compareAndSetState(0, 1))
	        setExclusiveOwnerThread(Thread.currentThread());
	    else
	        acquire(1);
	}

FairSync

	final void lock() {
	    acquire(1);
	}

非公平锁就是不等排在前面的，在lock时直接尝试去获取state来抢占运行时间，不行的化就排队。然后他们都通过acquire(1);获取同步状态

	//AQS的acquire方法
	public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

父类AQS通过调用子类的tryAcquire(arg)来尝试获取同步状态
ReentrantLock的非公平锁实现为

	protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }

	final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (compareAndSet
State(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

可以看到nonfairTryAcquire方法在得知c==0的情况下没有考虑自己排在哪就直接去尝试得到运行资源了compareAndSetState(0, acquires)
ReentrantLock的公平锁实现为

	protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }

公平锁先看自己前面有没有排队的人在尝试调用compareAndSetState(0, acquires)获取资源

	public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

前面扯远了，下面如果没有得到同步状态，那么就要acquireQueued了

final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

可以看到这里和lockInterruptibly()处理中断的不一样了interrupted = true;只是把中断状态记录了下来等得到同步状态后再处理