【Java锁】Lock接口的使用

阳光穿透心脏的1/2处 2023-02-28 04:14 13阅读 0赞

##### 前言 #####

java中同步锁包括synchronized与Lock，前面已经讲过关于synchronized的使用和基本原理，**synchronized**是java内置关键字，在jvm层面，**Lock**是个java类，其实指的是 JDK 中的同步锁。为什么Java中除了内置的锁，还要使用 java类 来声明一个同步锁呢？这主要是**synchronized有缺点**，为了弥补缺点，所以引出了JDK中的同步锁。

##### synchronized有什么缺点？ #####

> 如果一个代码块被synchronized修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只会有两种情况：  
> 1）获取锁的线程执行完了该代码块，然后线程释放对锁的占有；  
> 2）线程执行发生异常，此时JVM会让线程自动释放锁。  
> \-------> 如果这个获取锁的线程由于要等待IO或者其他原因（比如调用sleep方法）被阻塞了，但是又没有释放锁，其他线程便只能干巴巴地等待，这非常影响程序执行效率。  
> 因此就需要有一种机制可以不让等待的线程一直无期限地等待下去（比如只  
> 等待一定的时间或者能够响应中断），通过Lock就可以办到。

> 另外，我们知道，当有多个线程读写文件时，读操作和写操作会发生冲突现象，写操作和写操作会发生冲突现象，但是读操作和读操作不会发生冲突现象。  
> 但是如果使用synchronized关键字修饰的方法或者代码块，  
> 如果多个线程都只是进行读操作，所以当一个线程在进行读操作时，其他线程只能等待无法进行读操作。  
> 因此就需要一种机制来使得多个线程都只是进行读操作时，线程之间不会发生冲突，通过Lock就可以办到

> synchronized不知道是否获得锁，但是Lock接口可以知道线程有没有成功获取到锁

> 总之：Lock比synchronized多了很多功能  
> 1）Lock不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性。Lock是一个类，通过这个类可以实现同步访问；  
> 2）Lock和synchronized有一点非常大的不同，采用synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；而Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。

##### jdk中常用同步锁介绍 #####

Lock和ReadWriteLock是是 java.util.concurrent.locks包中的两大锁的根接口（jdk 1.5后新增的），Lock代表实现类是ReentrantLock（可重入锁），ReadWriteLock（读写锁）的代表实现类是ReentrantReadWriteLock。一般Lock接口用的较多。Lock.lock()和unlock()底层是通过 volatile 类型的 state 来控制开和关的。

##### Lock锁的使用 #####

**1 先来看Lock的源码**

package java.util.concurrent.locks;
    
    import java.util.concurrent.TimeUnit;
    
    public interface Lock { 
        void lock();//获得锁
        //获得中断锁 
        void lockInterruptibly() throws InterruptedException;
        //尝试获得锁，布尔类型，true的时候即为获得锁，false时没有获得锁，不执行同步代码，执行其他部分代码
        boolean tryLock();
     //尝试在限定的时间内获得锁，布尔类型，true的时候即为在限制时间内获得锁，false时没有获得锁，不执行同步代码，
     //执行其他部分代码，var1为所等待的具体时间，TimeUnit var3 为一个常量，用来确定时间的单位 纳秒/微妙/毫秒/秒/分/时/天等
        boolean tryLock(long var1, TimeUnit var3) throws InterruptedException;
        //释放锁，一般放在finally中
        void unlock();
    //Condition与重入锁是通过lock.newCondition()方法产生一个与当前重入锁绑定的Condtion实例
        Condition newCondition();
    }

**2 直接调用 lock() 方法**

可以看到程序里，有显式的开锁和关锁，执行的结果和synchronized修饰是一样的  
![在这里插入图片描述][20200719215640864.png]  
**3 调用 tryLock()**

Lock lock=new ReentrantLock();
    public void printStr4(){ 
            System.out.println("printStr4 ... ");
            lock.lock();//开锁
            printInfo("printStr4",1000);
            lock.unlock();//关锁
        }
    public void printStr5(){ 
            System.out.println("printStr5 ... ");
            //如果获得锁，为true，则执行
            if(lock.tryLock()){ 
                try { 
                    printInfo("printStr5",1000);
                } catch (Exception e) { 
                    e.printStackTrace();
                }finally{ 
                    System.out.println("unlock close...");
                    lock.unlock();//最后释放锁
                }
            }else{ 
                //如果没有获得锁，则执行else语句
                System.out.println("unlock gotten...");
            }
        }
         public static void main(String[] args){ 
        	 Account ac=new Account("2",1000.);
        	 new Thread(ac::printStr4).start();
            new Thread(ac::printStr5).start();
        	 
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NzUwNDYx_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NzUwNDYx_size_16_color_FFFFFF_t_70 1]  
**4 调用tryLock(long var1, TimeUnit var3)**

Lock lock=new ReentrantLock();
    public void printStr4(){ 
            System.out.println("printStr4 ... ");
            lock.lock();//开锁
            printInfo("printStr4",1000);
            lock.unlock();//关锁
        }
    public void printStr6(){ 
            System.out.println("printStr6 ... ");
            //如果获得锁，则执行
            try { 
                if(lock.tryLock(1000,TimeUnit.MILLISECONDS)){ 
                    printInfo("printStr6",1000);
                    lock.unlock();//最后释放锁
                }else{ 
                    //如果没有获得锁，则执行else语句
                    System.out.println("unlock gotten...");
                }
                } catch (Exception e) { 
                    e.printStackTrace();
                }finally{ 
                    System.out.println("unlock close...");
                }
            }
              public static void main(String[] args){ 
        	 Account ac=new Account("2",1000.);
        	 new Thread(ac::printStr4).start();
            new Thread(ac::printStr6).start();
        	 
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NzUwNDYx_size_16_color_FFFFFF_t_70 2]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NzUwNDYx_size_16_color_FFFFFF_t_70 3]

##### 6 lockInterruptibly #####

> lockInterruptibly()方法能够中断等待获取锁的线程。当两个线程同时通过lock.lockInterruptibly()获取某个锁时，假若此时线程A获取到了锁，而线程B只有等待，那么对线程B调用threadB.interrupt()方法能够中断线程B的等待过程。  
> 线程在sleep或wait,join， 此时如果别的进程调用此进程的 interrupt（）方法，此线程会被唤醒并被要求处理InterruptedException；  
> 【注意】线程在运行中， 则不会收到提醒。但是 此线程的 “打扰标志”会被设置， 可以通过isInterrupted()查看并 作出处理。

比较和lock()的用法

@Test
     public void printStr9(){ 
            //获得锁，未释放
            lock.lock();
            System.out.println("str9 start..");
            try { 
                Thread.sleep(1000);
                System.out.println("str9 exe..");
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            Thread th1=new Thread(new Runnable(){ 
    
                @Override
                public void run() { 
                    lock.lock();//无法获得锁，阻塞
                    System.out.println("inner str9 ...");
                }
            });
            th1.start();//阻塞
            try { 
                th1.sleep(1000);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            th1.interrupt();//对lock 没有用处
            try { 
                Thread.sleep(1000);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
        }

阻塞，一直等待锁，但是 interrupt 中断没有用处，即使在线程阻塞状态，仍未起到中断程序的作用。  
![在这里插入图片描述][20200720205209832.png]

两个锁都是lockInterruptibly() 则没有获得锁会进行 interrupt （中断程序执行）

@Test
     public void printStr9(){ 
            //获得锁，未释放
            try { 
                lock.lockInterruptibly();
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            System.out.println("str9 start..");
            try { 
                Thread.sleep(1000);
                System.out.println("str9 exe..");
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            Thread th1=new Thread(new Runnable(){ 
    
                @Override
                public void run() { 
                    try { 
                        lock.lockInterruptibly();//无法获得锁，阻塞
                    } catch (Exception e) { 
                        e.printStackTrace();
                    }
                    System.out.println("inner str9 ...");
                }
            });
            th1.start();//阻塞
            System.out.println("inner str9 start..."+th1.isInterrupted());
            try { 
                th1.sleep(1000);
                System.out.println("inner str9 sleep 1000...");
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            th1.interrupt();//对lock 没有用处
            try { 
                Thread.sleep(1000);
                System.out.println("inner str9 interrupt sleep 1000..."+th1.isInterrupted());
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NzUwNDYx_size_16_color_FFFFFF_t_70 4]  
lockInterruptibly()在前，lock()在后，则lock()线程未获得锁，仍然阻塞，等待锁，且没有被 interrupt干扰

@Test
    public void printStr9(){ 
            //获得锁，未释放
            try { 
                lock.lockInterruptibly();
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            System.out.println("str9 start..");
            try { 
                Thread.sleep(1000);
                System.out.println("str9 exe..");
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            Thread th1=new Thread(new Runnable(){ 
    
                @Override
                public void run() { 
                    try { 
                        lock.lock();//无法获得锁，阻塞
                    } catch (Exception e) { 
                        e.printStackTrace();
                    }
                    System.out.println("inner str9 ...");
                }
            });
            th1.start();//阻塞
            System.out.println("inner str9 start...");
            try { 
                th1.sleep(1000);
                System.out.println("inner str9 sleep 1000...");
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            th1.interrupt();//对lock 没有用处
            try { 
                Thread.sleep(1000);
                System.out.println("inner str9 interrupt sleep 1000..."+th1.isInterrupted());
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
        }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NzUwNDYx_size_16_color_FFFFFF_t_70 5]  
【以上是Lock接口中定义的几个锁，以上方法的调用，其实少不了Lock接口的实现类------->ReentrantLock，意思是“可重入锁”,是唯一实现了Lock接口的类，并且ReentrantLock提供了更多的方法】  
下面开始介绍ReentrantLock，  
首先看以下程序的输出结果：

List arrayList=new ArrayList<Integer>();
        public void insert(Thread thread) { 
            Lock lock = new ReentrantLock();    //注意这个地方
            lock.lock();
            try { 
                System.out.println(thread.getName()+"得到了锁");
                for(int i=0;i<5;i++) { 
                    arrayList.add(i);
                }
            } catch (Exception e) { 
                // TODO: handle exception
            }finally { 
                System.out.println(thread.getName()+"释放了锁");
                lock.unlock();
            }
        }
        
        public static void main(String[] args){ 
        	Account ac=new Account();
        	 new Thread(new Runnable(){ 
                @Override
                public void run() { 
                    ac.insert(Thread.currentThread());
                }
            }).start();
            new Thread(new Runnable(){ 
                @Override
                public void run() { 
                    ac.insert(Thread.currentThread());
                }
            }).start();
        }

可以看到，线程是同时拿到了锁，为什么呢？主要是 【Lock lock = new ReentrantLock(); //注意这个地方】这个lock成了局部变量，每个方法都保存一个副本，因此每次调用insert 方法，每次的锁都不一样，但是将Lock lock = new ReentrantLock(); 变为全局变量，则可消除此问题。  
![在这里插入图片描述][20200720211959732.png]

###### ReadWriteLock（读写锁）和Lock一样也是一个接口，该接口只定义了两个方法（一个读锁，一个写锁）这也说明，读写线程是分开的： ######

package java.util.concurrent.locks;
    
    public interface ReadWriteLock { 
        Lock readLock();
    
        Lock writeLock();
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NzUwNDYx_size_16_color_FFFFFF_t_70 6]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NzUwNDYx_size_16_color_FFFFFF_t_70 7]  
可以看到读写锁其实还是 Lock 锁接口的实现。

**读锁例子**

可以看出多个线程可以同时获得读锁，互不影响，可同时进行读操作  
![在这里插入图片描述][2020072021554855.png]  
以上如果使用 synchronized 关键字

public synchronized void Read(Thread thread){ 
            //rwl.readLock().lock();
            long start=System.currentTimeMillis();
            while(System.currentTimeMillis()-start<=2){ 
                System.out.println(thread.getName()+"======正在读=====");
            }
            System.out.println(thread.getName()+"======都结束了=====");
            //rwl.readLock().unlock();
    
        }

则两个读线程是先后进行执行的，不能多个线程一起读  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NzUwNDYx_size_16_color_FFFFFF_t_70 8]  
这样说明读锁，大大提升了读操作的效率。  
不过要注意的是，如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。  
如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，则申请的线程会一直等待释放写锁。

public  void Read(Thread thread){ 
            rwl.readLock().lock();
            long start=System.currentTimeMillis();
            while(System.currentTimeMillis()-start<=2){ 
                System.out.println(thread.getName()+"======正在读=====");
            }
            System.out.println(thread.getName()+"======都结束了=====");
            rwl.readLock().unlock();
    
        }
        public  void Write(Thread thread){ 
            rwl.writeLock().lock();
            long start=System.currentTimeMillis();
            while(System.currentTimeMillis()-start<=2){ 
                System.out.println(thread.getName()+"======正在写=====");
            }
            System.out.println(thread.getName()+"======写结束了=====");
            rwl.writeLock().unlock();
        }

读锁占用的时候，写锁不能进行，反之一样，都是写锁的情况下，谁先拿到锁，谁先执行  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NzUwNDYx_size_16_color_FFFFFF_t_70 9]

###### 锁的条件：Condition ######

> 在Lock接口的源码中有 newCondition 的方法，这个方法主要是声明使用锁的条件，其实是通过一系列的线程通信来实现控制锁。  
> 1 Lock 和 Condition 实现的管程，线程等待和通知需要调用 await()、signal()、signalAll()，它们的语义和 wait()、notify()、notifyAll() 是相同的。但是不一样的是，Lock&Condition 实现的管程里只能使用前面的 await()、signal()、signalAll()，而后面的 wait()、notify()、notifyAll() 只有在 synchronized 实现的管程里才能使用。  
> 2 如果一不小心在 Lock&Condition 实现的管程里调用了 wait()、notify()、notifyAll()，那程序可就彻底玩儿完了

import java.util.concurrent.locks.Condition;
    import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class ConditionTest { 
        public static void main(String[] args){ 
            TestShare ts=new TestShare();
            new Thread(()->{ 
                for(int i=0;i<5;i++){ 
                    ts.print5();
                }
            },"A").start();
            new Thread(()->{ 
                for(int i=0;i<5;i++){ 
                    ts.print10();
                }
            },"B").start();
            new Thread(()->{ 
                for(int i=0;i<5;i++){ 
                    ts.print15();
                }
            },"C").start();
        }
    }
    class TestShare{ 
        //
        private int num=1;//线程执行信号 共享资源
        private Lock lock=new ReentrantLock();
        private Condition c1=lock.newCondition();
        private Condition c2=lock.newCondition();
        private Condition c3=lock.newCondition();
    
        public void print5(){ 
            lock.lock();
            //System.out.println("==========>"+num);
            try { 
                while(num!=1) { 
                    c1.await();
                }
                for(int i=0;i<5;i++){ 
                    System.out.println(Thread.currentThread().getName()+"===>"+i);
                }
                num=2;
                c2.signal();
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }finally{ 
                lock.unlock();
            }
        }
    
        public void print10(){ 
            lock.lock();
            try { 
                while(num!=2) { 
                    c2.await();
                }
                for(int i=0;i<5;i++){ 
                    System.out.println(Thread.currentThread().getName()+"===>"+i);
                }
                num=3;
                c3.signal();
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }finally{ 
                lock.unlock();
            }
        }
    
        public void print15(){ 
            lock.lock();
            try { 
                while(num!=3) { 
                    c3.await();
                }
                for(int i=0;i<5;i++){ 
                    System.out.println(Thread.currentThread().getName()+"===>"+i);
                }
                num=1;
                c1.signal();
               // System.out.println("====>"+Thread.currentThread().isAlive());
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }finally{ 
                lock.unlock();
                //System.out.println("====>"+Thread.currentThread().isAlive());
            }
        }
    
    }

[20200719215640864.png]: /images/20230209/e43ecf59c51c4fad8da6b936f54da23b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NzUwNDYx_size_16_color_FFFFFF_t_70]: /images/20230209/0ef80460f5374be09c4227ad8057e9b7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NzUwNDYx_size_16_color_FFFFFF_t_70 1]: /images/20230209/4e3a4bf2e83c484ea653f415e1d8d750.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NzUwNDYx_size_16_color_FFFFFF_t_70 2]: /images/20230209/1433f21dd23d4a6295b5ea7d76cfbd4e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NzUwNDYx_size_16_color_FFFFFF_t_70 3]: /images/20230209/876e199df5e34f5e9b31bf57c60a820f.png
[20200720205209832.png]: https://img-blog.csdnimg.cn/20200720205209832.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NzUwNDYx_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200720205636412.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NzUwNDYx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NzUwNDYx_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200720210002913.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NzUwNDYx,size_16,color_FFFFFF,t_70
[20200720211959732.png]: https://img-blog.csdnimg.cn/20200720211959732.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NzUwNDYx_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200720215114220.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NzUwNDYx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NzUwNDYx_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20200720215050659.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NzUwNDYx,size_16,color_FFFFFF,t_70
[2020072021554855.png]: https://img-blog.csdnimg.cn/2020072021554855.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NzUwNDYx_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20200720215717114.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NzUwNDYx,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NzUwNDYx_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20200720220623672.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI5NzUwNDYx,size_16,color_FFFFFF,t_70