多线程学习笔记(六)--重入锁

秒速五厘米 2022-05-25 09:50 196阅读 0赞

强烈推荐一个大神的人工智能的教程：[http://www.captainbed.net/zhanghan][http_www.captainbed.net_zhanghan]

# <table>   <tbody>    <tr>     <td><font>重入锁</font></td>    </tr>   </tbody>  </table> #

重入锁可以完全替代synchronized关键字,jdk5的早期版本中,重入锁的性能远远好于synchronized,在jdk6之后,jdk在synchronized上做了大量的优化,使得两者的性能差距并不大。

## <table>   <tbody>    <tr>     <td><font>·重入锁简单使用</font></td>    </tr>   </tbody>  </table> ##

method1拿到锁之后执行业务代码,method2需要等待method1释放锁资源,从而保证了安全性

public class UseReentrantLock {
        private Lock lock = new ReentrantLock();
    
        public void method1(){
            try {
                lock.lock();
                System.out.println("当前线程:" + Thread.currentThread().getName() + "进入method1...");
                Thread.sleep(1000);
                System.out.println("当前线程:" + Thread.currentThread().getName() + "退出method1...");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }
    
        public void method2(){
            try {
                lock.lock();
                System.out.println("当前线程:" + Thread.currentThread().getName() + "进入method2..");
                Thread.sleep(2000);
                System.out.println("当前线程:" + Thread.currentThread().getName() + "退出method2..");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }
    
        public static void main(String[] args) {
            final UseReentrantLock ur = new UseReentrantLock();
            Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    ur.method1();
                    ur.method2();
                }
            },"t1");
    
            t1.start();
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

执行的结果如下:

当前线程:t1进入method1...
    当前线程:t1退出method1...
    当前线程:t1进入method2..
    当前线程:t1退出method2..

## <table>   <tbody>    <tr>     <td><font>·中断响应</font></td>    </tr>   </tbody>  </table> ##

使用synchronized,对于一个线程在等待锁,要么就获得了锁,可以执行业务代码,要么就没获得到锁,从而必须等待。 使用重入锁,线程可以被中断,也就是在等待锁的过程中,程序可以根据需要取消对锁的请求 将上述方法改造,线程t1和线程t2会产生死锁,这时我们将t2中断,从而t1线程会正常执行:

public class UseReentrantLock {
        public static ReentrantLock lock1 = new ReentrantLock();
        public static ReentrantLock lock2 = new ReentrantLock();
    
        public void method1(){
            try {
                lock1.lockInterruptibly();
                System.out.println("当前线程:" + Thread.currentThread().getName() + "进入method1...");
                Thread.sleep(1000);
                lock2.lockInterruptibly();
                System.out.println("当前线程:" + Thread.currentThread().getName() + "退出method1...");
    
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                if(lock1.isHeldByCurrentThread()){
                    lock1.unlock();
                }
                if(lock2.isHeldByCurrentThread()){
                    lock2.unlock();
                }
    
            }
        }
    
        public void method2(){
            try {
                lock2.lockInterruptibly();
                System.out.println("当前线程:" + Thread.currentThread().getName() + "进入method2..");
                Thread.sleep(2000);
                lock1.lockInterruptibly();
                System.out.println("当前线程:" + Thread.currentThread().getName() + "退出method2..");
    
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                if(lock1.isHeldByCurrentThread()){
                    lock1.unlock();
                }
                if(lock2.isHeldByCurrentThread()){
                    lock2.unlock();
                }
            }
        }
    
        public static void main(String[] args) {
            final UseReentrantLock ur = new UseReentrantLock();
            Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    ur.method1();
                }
            },"t1");
    
            Thread t2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    ur.method2();
                }
            },"t2");
    
            t1.start();
            t2.start();
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            t2.interrupt();
        }
    }

## <table>   <tbody>    <tr>     <td><font>·锁申请等待限时</font></td>    </tr>   </tbody>  </table> ##

要避免死锁,另一种方法就是限时等待,在一定时间内还没有拿到锁,那就自动放弃,可以使用tryLock()进行限时等待:

public class TimeLock implements Runnable{
        public static ReentrantLock lock = new ReentrantLock();
    
        @Override
        public void run() {
            try {
                if(lock.tryLock(5, TimeUnit.SECONDS)){
                System.out.println(Thread.currentThread().getName() + ": get lock success");
                    Thread.sleep(6000);
                }else{
                  System.out.println(Thread.currentThread().getName() + ": get lock failed");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }finally {
                if (lock.isHeldByCurrentThread()) {
                    lock.unlock();
                }
            }
    
        }
    
        public static void main(String[] args) {
            TimeLock t1 = new TimeLock();
            Thread t = new Thread(t1);
            Thread t2 = new Thread(t1);
            t.start();
            t2.start();
        }
    }

执行结果:

Thread-0: get lock success
    Thread-1: get lock failed

线程t1获得锁成功后,线程会睡眠6s,线程t2再去获得锁时,在5s内t1线程 还未释放,所以t2线程获取锁失败。

## <table>   <tbody>    <tr>     <td><font>·公平锁</font></td>    </tr>   </tbody>  </table> ##

一般锁的申请都是非公平的,当锁可用时,多个线程同时去争抢这个锁资源,那么哪个线程可以获得到锁是不确定的

public class FairLock implements Runnable{
        public static ReentrantLock fairLock = new ReentrantLock(true);
    
        @Override
        public void run() {
            while (true){
                try {
                    fairLock.lock();
                    System.out.println(Thread.currentThread().getName() + " 获得锁");
                } finally {
                    fairLock.unlock();
                }
            }
        }
    
        public static void main(String[] args) {
            FairLock r1 = new FairLock();
            Thread t1 = new Thread(r1,"t1");
            Thread t2 = new Thread(r1,"t2");
            t1.start();
            t2.start();
    
        }
    }

当参数为true时,是公平锁,当参数为false时,是非公平锁,执行结果如下:

t1 获得锁
    t2 获得锁
    t1 获得锁
    t2 获得锁
    t1 获得锁
    t2 获得锁
    ...

# <table>   <tbody>    <tr>     <td><font>实现原理</font></td>    </tr>   </tbody>  </table> #

重入锁是对一个线程来讲的,一个线程获取了锁之后,可以循环递归的获取同一个锁(计数+1),当释放一次锁时,即将计数-1,当减为0,会立即释放锁,其他线程才能获取 参考链接如下:https://blog.csdn.net/yanyan19880509/article/details/52345422

[http_www.captainbed.net_zhanghan]: http://www.captainbed.net/zhanghan