Java 层面的锁

约定不等于承诺〃 2022-06-07 08:07 125阅读 0赞

# Java 层面的锁 #

*  Java 层面的锁
    
     *  重入锁 ReentrantLock
     *  读写锁 ReentrantReadWriteLock
     *  锁的等待和通知

> 在 Java 的多线程中，我们知道可以使用 synchronized 关键字来实现线程间的同步互斥工作， 其实还有一个更优秀的机制去实现 同步互斥的 工作，那就是 Lock 对象。

## 重入锁 (ReentrantLock) ##

基本使用：
    
    Lock lock = new ReentrantLock();
    
    // 加锁
    lock.lock();
    // 解锁
    lock.unlock();
    
    更多：公平锁和非公平锁
    Lock lock = new ReentrantLock(boolean isFair);
    
    可以传入是否公平的参数，默认是非公平锁，
    非公平锁是无序的效率高，
    公平锁是有序的，先请求，先获取锁。但效率相对较低

## 读写锁 (ReentrantReadWriteLock) ##

> ReentrantReadWriteLock, 其核心就是实现读写分离的锁，在高并发下， 尤其是读多写少下，性能高于重入锁。
> 
> 口诀：读读共享，写写互斥，读写互斥。

package org.mulity.demo;
    
    
    import java.util.concurrent.locks.*;
    
    /** * ReentrantReadWriteLock 使用示例 * * Created by jun on 2017/10/15. */
    public class UseReentrantReadWriteLock { 
    
        private ReentrantReadWriteLock rwlock = new ReentrantReadWriteLock();
        private ReentrantReadWriteLock.ReadLock readLock = rwlock.readLock();
        private ReentrantReadWriteLock.WriteLock writeLock = rwlock.writeLock();
    
        public void read() {
            try {
                readLock.lock();
                System.out.println("当前线程：" + Thread.currentThread().getName() + "进入");
                Thread.sleep(3000);
                System.out.println("当前线程：" + Thread.currentThread().getName() + "退出");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                readLock.unlock();
            }
        }
    
       public void write() {
           try {
               writeLock.lock();
               System.out.println("当前线程：" + Thread.currentThread().getName() + "进入");
               Thread.sleep(3000);
               System.out.println("当前线程：" + Thread.currentThread().getName() + "退出");
           } catch (InterruptedException e) {
               e.printStackTrace();
           } finally {
               writeLock.unlock();
           }
        }
    
        public static void main(String[] args) throws Exception {
            final UseReentrantReadWriteLock urrw = new UseReentrantReadWriteLock();
    
            Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    urrw.read();
                }
            }, "t1");
    
            Thread t2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    urrw.read();
                }
            }, "t2");
    
            Thread t3 = new Thread(new Runnable() {
                @Override
                public void run() {
                    urrw.write();
                }
            }, "t3");
    
            t1.start();
            t2.start();
    
            // t1.start();
            // t3.start();
        }
    }

## 锁的等待和通知 ##

> 我们在使用 synchronized的时候，如果需要多线程间进行协作，则需要 Object 的 wait 和 notify， notifyAll 方法进行配合工作，那么同样， 我们在使用 Lock的时候，可以使用一个新的的 等待/通知 的类， 他就是Condition, 这个 Condition 是针对一把锁的，也就是说，只有在锁的基础上才会有***Condition***

基本使用：
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
    // 相当于 Object 的 wait();
    condition.await();
    // 相当于 Object 的 notify();
    condition.signal();
    
    // 一个 lock 可以创建多个 Condition