可重入锁／不可重入锁

原创转载请注明出处：https://www.cnblogs.com/agilestyle/p/11395621.html

可重入锁

可重入锁指的是可重复可递归调用的锁，在外层使用锁之后，在内层仍然可以使用，并且不发生死锁（前提是同一个对象或者类）

Note：

ReentrantLock和synchronized都是可重入锁

public class TestLock {  
    public synchronized void test1() throws InterruptedException {  
        Thread.sleep(1000);  
        System.out.println("test1 invoked...");  
        test2();  
    }  
  
    public synchronized void test2() throws InterruptedException {  
        Thread.sleep(1000);  
        System.out.println("test2 invoked...");  
    }  
  
    public static void main(String[] args) throws InterruptedException {  
        TestLock testLock = new TestLock();  
        testLock.test1();  
    }  
}

上面的代码就是一个可重入锁的一个特点，如果不是可重入锁的话，test2可能不会被当前线程执行，可能造成死锁。 

不可重入锁

不可重入锁，与可重入锁相反，不可递归调用，递归调用就会发生死锁。

使用自旋锁来模拟一个不可重入锁

import java.util.concurrent.atomic.AtomicReference;  
  
public class UnreentrantLockTest {  
    private static UnreentrantLock lock = new UnreentrantLock();  
  
    public static void main(String[] args) {  
        lock.lock();  
  
        test();  
  
        lock.unlock();  
    }  
  
    private static void test() {  
        lock.lock();  
  
        System.out.println("test invoked...");  
  
        lock.unlock();  
    }  
  
    private static class UnreentrantLock {  
        private AtomicReference<Thread> owner = new AtomicReference<>();  
  
        public void lock() {  
            Thread currentThread = Thread.currentThread();  
  
            for (; ; ) {  
                System.out.println(owner);  
                if (owner.compareAndSet(null, currentThread)) {  
                    System.out.println(currentThread + " locked...");  
                    return;  
                }  
            }  
        }  
  
        public void unlock() {  
            Thread currentThread = Thread.currentThread();  
  
            owner.compareAndSet(currentThread, null);  
  
            System.out.println(currentThread + " unlock...");  
        }  
    }  
}  

Note:

使用原子引用来存放线程，同一个线程两次调用lock()方法，如果不执行unlock()释放锁的话，第二次调用自旋的时候就会产生死锁，这个锁是不可重入的

修改上述代码，将它改造成可重入锁，在执行每次操作之前，判断当前锁持有者是否是当前对象，采用state计数

import java.util.concurrent.atomic.AtomicReference;  
  
public class ReentrantLockTest {  
    private static ReentrantLock lock = new ReentrantLock();  
  
    public static void main(String[] args) {  
        lock.lock();  
  
        test();  
  
        lock.unlock();  
    }  
  
    private static void test() {  
        lock.lock();  
  
        System.out.println("test invoked...");  
  
        test1();  
  
        lock.unlock();  
    }  
  
    private static void test1() {  
        lock.lock();  
  
        System.out.println("test2 invoked...");  
  
        lock.unlock();  
    }  
  
    private static class ReentrantLock {  
        private AtomicReference<Thread> owner = new AtomicReference<>();  
        private int state = 0;  
  
        public void lock() {  
            Thread currentThread = Thread.currentThread();  
  
            if (currentThread == owner.get()) {  
                state++;  
                return;  
            }  
  
            for (; ; ) {  
                System.out.println(owner);  
                if (!owner.compareAndSet(null, currentThread)) {  
                    return;  
                }  
            }  
        }  
  
        public void unlock() {  
            Thread currentThread = Thread.currentThread();  
  
            if (currentThread == owner.get()) {  
                if (state != 0) {  
                    state--;  
                } else {  
                    owner.compareAndSet(currentThread, null);  
                }  
            }  
        }  
    }  
}