Java中的可重入锁

本文主要是介绍Java中的可重入锁，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

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

synchronized 和   ReentrantLock 都是可重入锁。

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

可重入锁简单演示

什么是 “可重入”，可重入就是说某个线程已经获得某个锁，可以再次获取锁而不会出现死锁。

ReentrantLock 和 synchronized 不一样，需要手动释放锁，所以使用 ReentrantLock的时候一定要手动释放锁，并且加锁次数和释放次数要一样

例如

//演示可重入锁是什么意思，可重入，就是可以重复获取相同的锁，synchronized和ReentrantLock都是可重入的
//可重入降低了编程复杂性
public class WhatReentrant {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (this) {
                    System.out.println("第1次获取锁，这个锁是：" + this);
                    int index = 1;
                    while (true) {
                        synchronized (this) {
                            System.out.println("第" + (++index) + "次获取锁，这个锁是：" + this);
                        }
                        if (index == 10) {
                            break;
                        }
                    }
                }
            }
        }).start();
    }
}

//演示可重入锁是什么意思
public class WhatReentrant2 {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    lock.lock();
                    System.out.println("第1次获取锁，这个锁是：" + lock);

                    int index = 1;
                    while (true) {
                        try {
                            lock.lock();
                            System.out.println("第" + (++index) + "次获取锁，这个锁是：" + lock);
                            
                            try {
                                Thread.sleep(new Random().nextInt(200));
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                            
                            if (index == 10) {
                                break;
                            }
                        } finally {
                            lock.unlock();
                        }

                    }

                } finally {
                    lock.unlock();
                }
            }
        }).start();
    }
}

 可以发现没发生死锁，可以多次获取相同的锁

可重入锁有

• synchronized
• ReentrantLock

使用ReentrantLock的注意点

ReentrantLock 和 synchronized 不一样，需要手动释放锁，所以使用 ReentrantLock的时候一定要手动释放锁，并且加锁次数和释放次数要一样

以下代码演示，加锁和释放次数不一样导致的死锁

public class WhatReentrant3 {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    lock.lock();
                    System.out.println("第1次获取锁，这个锁是：" + lock);

                    int index = 1;
                    while (true) {
                        try {
                            lock.lock();
                            System.out.println("第" + (++index) + "次获取锁，这个锁是：" + lock);
                            
                            try {
                                Thread.sleep(new Random().nextInt(200));
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                            
                            if (index == 10) {
                                break;
                            }
                        } finally {
//                            lock.unlock();// 这里故意注释，实现加锁次数和释放次数不一样
                        }

                    }

                } finally {
                    lock.unlock();
                }
            }
        }).start();
        
        
        new Thread(new Runnable() {
            
            @Override
            public void run() {
                try {
                    lock.lock();
                    
                    for (int i = 0; i < 20; i++) {
                        System.out.println("threadName:" + Thread.currentThread().getName());
                        try {
                            Thread.sleep(new Random().nextInt(200));
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                } finally {
                    lock.unlock();
                }
            }
        }).start();
        
        
    }
}

 可以看出，由于加锁次数和释放次数不一样，第二个线程始终无法获取到锁，导致一直在等待。

稍微改一下，在外层的finally里头释放9次，让加锁和释放次数一样，就没问题了

try {
    lock.lock();
    System.out.println("第1次获取锁，这个锁是：" + lock);

    int index = 1;
    while (true) {
        try {
            lock.lock();
            System.out.println("第" + (++index) + "次获取锁，这个锁是：" + lock);
            
            ... 代码省略节省篇幅...
        } finally {
//                            lock.unlock();// 这里故意注释，实现加锁次数和释放次数不一样
        }

    }

} finally {
    lock.unlock();
    
    // 在外层的finally里头释放9次，让加锁和释放次数一样，就没问题了
    for (int i = 0; i < 9; i++) {
        lock.unlock();
        
    }
}

实现原理

　　实现原理是通过为每个锁关联一个请求计数器和一个占有它的线程。

当计数为0时，认为锁是未被占有的；线程请求一个未被占有的锁时，JVM将记录锁的占有者，并且将请求计数器置为1 。

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

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

关于父类和子类的锁的重入:子类覆写了父类的synchonized方法，然后调用父类中的方法，此时如果没有重入的锁，那么这段代码将产生死锁（很好理解吧）。

例子：

比如说A类中有个方法public synchronized methodA1(){

        methodA2();

}

而且public synchronized methodA2(){

                    //具体操作

}

也是A类中的同步方法，当当前线程调用A类的对象methodA1同步方法，如果其他线程没有获取A类的对象锁，那么当前线程就获得当前A类对象的锁，

然后执行methodA1同步方法，方法体中调用methodA2同步方法，当前线程能够再次获取A类对象的锁，而其他线程是不可以的，这就是可重入锁。

代码演示：

不可重入锁：

public class Lock{
    private boolean isLocked = false;
    public synchronized void lock() throws InterruptedException{
        while(isLocked){    
            wait();
        }
        isLocked = true;
    }
    public synchronized void unlock(){
        isLocked = false;
        notify();
    }

使用该锁：

public class Count{
    Lock lock = new Lock();
    public void print(){
        lock.lock();
        doAdd();
        lock.unlock();
    }
    public void doAdd(){
        lock.lock();
        //do something
        lock.unlock();
    }
}

当前线程执行print()方法首先获取lock，接下来执行doAdd()方法就无法执行doAdd()中的逻辑，必须先释放锁。这个例子很好的说明了不可重入锁。

可重入锁：

接下来，我们设计一种可重入锁

public class Lock{
    boolean isLocked = false;
    Thread  lockedBy = null;
    int lockedCount = 0;
    public synchronized void lock()
            throws InterruptedException{
        Thread thread = Thread.currentThread();
        while(isLocked && lockedBy != thread){//锁已经被获取了，并且不是这个线程获取的，就等待
            wait();
        }
        isLocked = true;
        lockedCount++;
        lockedBy = thread;
    }
    public synchronized void unlock(){
        if(Thread.currentThread() == this.lockedBy){
            lockedCount--;
            if(lockedCount == 0){
                isLocked = false;
                notify();
            }
        }
    }
}

所谓可重入，意味着线程可以进入它已经拥有的锁的同步代码块儿。

我们设计两个线程调用print()方法，第一个线程调用print()方法获取锁，进入lock()方法，

由于初始lockedBy是null，所以不会进入while挂起当前线程，而是是增量lockedCount并记录lockBy为第一个线程。

接着第一个线程进入doAdd()方法，由于是同一线程，所以不会进入while挂起线程，接着增量lockedCount，

当第二个线程尝试lock，由于isLocked=true,所以他不会获取该锁，直到第一个线程调用两次unlock()将lockCount递减为0，才将标记为isLocked设置为false。

　　可重入锁的概念和设计思想大体如此，Java中的可重入锁ReentrantLock设计思路也是这样。

synchronized和ReentrantLock 都是可重入锁。

ReentrantLock与synchronized比较：

1. 前者使用灵活，但是必须手动开启和释放锁
2. 前者扩展性好，有时间锁等候（tryLock( )），可中断锁等候（lockInterruptibly( )），锁投票等，适合用于高度竞争锁和多个条件变量的地方
3. 前者提供了可轮询的锁请求，可以尝试去获取锁（tryLock( )），如果失败，则会释放已经获得的锁。有完善的错误恢复机制，可以避免死锁的发生。

https://blog.csdn.net/w8y56f/article/details/89554060

https://blog.csdn.net/qq_39101581/article/details/82144499

这篇关于Java中的可重入锁的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！