java-可重入锁和不可重入锁

可重入锁（递归锁）

指的是以线程为单位，当一个线程获取对象锁之后，这个线程可以再次获取本对象上的锁，而其他的线程是不可以的。

synchronized 和 ReentrantLock 都是可重入锁。

可重入锁的意义之一在于防止死锁。

实现原理实现是通过为每个锁关联一个请求计数器和一个占有它的线程。当计数为0时，认为锁是未被占有的；线程请求一个未被占有的锁时，JVM将记录锁的占有者，并且将请求计数器置为1 。

如果同一个线程再次请求这个锁，计数器将递增；

每次占用线程退出同步块，计数器值将递减。直到计数器为0,锁被释放。

不可重入锁

所谓不可重入锁，即若当前线程执行某个方法已经获取了该锁，
那么在方法中尝试再次获取锁时，就会获取不到被阻塞。（同一把锁）

实现

package com.zm.demo6;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

public class MyLockTest {

    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    // 加锁
    public void myLock() {
        // 获取当前线程的引用，既代码段正在被哪一个线程调用
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName() + "==> mylock");
        // 自旋锁 CAS实现
        while (!atomicReference.compareAndSet(null, thread)) {

        }
    }

    // 解锁
    public void myUnLock() {
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName() + "==> myUnlock");
        atomicReference.compareAndSet(thread, null);
    }

    public static void main(String[] args) throws InterruptedException {
        // 底层使用的自旋锁CAS
        MyLockTest lock = new MyLockTest();
        new Thread(() -> {
            lock.myLock();
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.myUnLock();
            }
        }, "T1").start();
        TimeUnit.SECONDS.sleep(1);
        new Thread(() -> {
            lock.myLock();
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.myUnLock();
            }
        }, "T2").start();
    }

}

验证


    public static void main(String[] args) throws InterruptedException {
        MyLockTest myLockTest = new MyLockTest();
        b(0,myLockTest);
    }

/**
     * 同一把锁
     * @param i
     * @param lock
     */
    private static void b(int i,MyLockTest lock){
        lock.myLock();
        try {
            i++;
            System.out.println(i);
            if (i == 10) {
                return;
            }
            b(i,lock);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.myUnLock();
        }
    }

无法打印1-10

可重入锁

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;

public class MyLockTest {

    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    private volatile int count = 0;

    // 加锁
    public void myLock() {
        // 获取当前线程的引用，既代码段正在被哪一个线程调用
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName() + "==> mylock" + count);
        if(atomicReference.get()==thread){
            count++;
            return;
        }
        // 自旋锁 CAS实现
        while (!atomicReference.compareAndSet(null, thread)) {
        }
    }

    // 解锁
    public void myUnLock() {
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName() + "==> myUnlock" + count);
        if(count > 0){
            count--;
        }else {
            atomicReference.compareAndSet(thread, null);
            System.out.println(1111);
        }
    }

}

    public static void main(String[] args) throws InterruptedException {
        MyLockTest myLockTest = new MyLockTest();
        b(0,myLockTest);
        //a();

    }

这是一个带volatile前缀的int值,是一个类似计数器的东西。
可以用来表示该锁被线程重入的次数。
当count为0表示该锁不被任何线程持有;当count为1表示线程恰好持有该锁1次(未重入);
当count大于1则表示锁被线程重入count次。
因为这是一个会被并发访问的量,为了防止出现可见性问题要用volatile进行修饰。