第4章 Lock的使用

小灰灰 2022-06-16 04:25 149阅读 0赞

# 第4章 Lock的使用 #

标签： Java多线程编程

> 《[Java多线程编程核心技术][Java]》 个人笔记

--------------------

*  第4章 Lock的使用
    
     *  使用ReentrantLock类
        
         *  使用ReentrantLock实现同步测试1
         *  使用Condition实现等待通知错误用法与解决
         *  正确使用Condition实现等待通知
         *  使用多个Condition实现通知部分线程错误用法
         *  使用多个Condition实现通知部分线程正确用法
         *  实现生产者消费者模式一对一交替打印
         *  实现生产者消费者模式多对多交替打印
         *  公平锁与非公平锁
         *  方法getHoldCountgetQueueLength和getWaitQueueLength的测试
         *  方法hasQueueThreadhasQueueThreads和hasWaiters的测试
         *  方法isFairisHeldByCurrentThread和isLocked的测试
         *  方法lockInterruptiblytryLock和tryLocklong timeout TimeUnit unit的测试
         *  方法awaitUninterruptibly的使用
         *  方法awaitUntil的使用
         *  使用Condition实现顺序执行
     *  使用ReentrantReadWriteLock类
        
         *  类ReentrantReadWriteLock的使用读读共享
         *  类ReentrantReadWriteLock的使用写写互斥
         *  类ReentrantReadWriteLock的使用读写互斥
         *  类ReentrantReadWriteLock的使用写读互斥

--------------------

本章着重掌握以下2个知识点：  
1. ReentrantLock类的使用  
2. ReentrantReadWriteLock类的使用

--------------------

## 使用ReentrantLock类 ##

*  在Java多线程中，可以使用synchronized关键字来实现线程之间同步互斥，但在JDK1.5中新增加了ReentrantLock类也能达到同样的效果，并且在扩展功能上也更加强大，比如具有嗅探锁定、多路分支通知功能。

### 使用ReentrantLock实现同步：测试1 ###

public class MyService { 
        private Lock lock = new ReentrantLock();
        public void testMethod() {
            lock.lock();
            for (int i = 0; i < 5; i++) {
                System.out.println("ThreadName=" + Thread.currentThread().getName()
                        + (" " + (i + 1)));
            }
            lock.unlock();
        }
    }
    public class MyThread extends Thread { 
        private MyService service;
        public MyThread(MyService service) {
            super();
            this.service = service;
        }
        @Override
        public void run() {
            service.testMethod();
        }
    }
    public class Run { 
        public static void main(String[] args) {
            MyService service = new MyService();
    
            MyThread a1 = new MyThread(service);
            MyThread a2 = new MyThread(service);
            MyThread a3 = new MyThread(service);
            MyThread a4 = new MyThread(service);
            MyThread a5 = new MyThread(service);
    
            a1.start();
            a2.start();
            a3.start();
            a4.start();
            a5.start();
        }
    }
    //-----------主函数--------
    ThreadName=Thread-0 1
    ThreadName=Thread-0 2
    ThreadName=Thread-0 3
    ThreadName=Thread-0 4
    ThreadName=Thread-0 5
    ThreadName=Thread-1 1
    ThreadName=Thread-1 2
    ThreadName=Thread-1 3
    ThreadName=Thread-1 4
    ThreadName=Thread-1 5
    ThreadName=Thread-2 1
    ThreadName=Thread-2 2
    ThreadName=Thread-2 3
    ThreadName=Thread-2 4
    ThreadName=Thread-2 5
    ThreadName=Thread-3 1
    ThreadName=Thread-3 2
    ThreadName=Thread-3 3
    ThreadName=Thread-3 4
    ThreadName=Thread-3 5
    ThreadName=Thread-4 1
    ThreadName=Thread-4 2
    ThreadName=Thread-4 3
    ThreadName=Thread-4 4
    ThreadName=Thread-4 5

### 使用Condition实现等待/通知：错误用法与解决 ###

*  Condition类是JDK5中才出现的技术，使用它有更好的灵活性，比如可以实现多路通知功能，也就是在一个Lock对象里可以创建多个Condition（即对象监视器）实例，线程对象可以注册在指定的Condition中，从而可以有选择性地进行线程通知，在调度线程上更加灵活。
 *  调用Condition对象的await()方法之前必须先调用lock.lock()获得同步监视器
 *  调用Condition对象的await()，是执行当前任务的线程进入等待WAITING状态

### 正确使用Condition实现等待/通知 ###

*  Object类中的wait()方法相当于Condition类中的await()方法
 *  Object类中的wait(long timeout)方法相当于Condition类中的await(long time, TimeUnit unit)方法
 *  Object类中的notify()方法相当于Condition类中的signal()方法
 *  Object类中的notifyAll()相当于Condition类中的signalAll()方法

### 使用多个Condition实现通知部分线程：错误用法 ###

*  如果想单独唤醒部分线程，就有必要使用多个Condition对象了，也就是Condition对象可以唤醒部分指定线程，有助于提升程序运行效率。可以先对线程进行分组，然后唤醒指定组中的线程

### 使用多个Condition实现通知部分线程：正确用法 ###

public class MyService { 
        private Lock lock = new ReentrantLock();
        public Condition conditionA = lock.newCondition();  
        public Condition conditionB = lock.newCondition();
    
        public void awaitA() {
            try {
                lock.lock();
                System.out.println("begin awaitA时间为 " + System.currentTimeMillis()
                        + " ThreadName=" + Thread.currentThread().getName());
                conditionA.await();         //conditionA等待
                System.out.println(" end awaitA时间为 " + System.currentTimeMillis()
                        + " ThreadName=" + Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
        public void awaitB() {
            try {
                lock.lock();
                System.out.println("begin awaitB时间为" + System.currentTimeMillis()
                        + " ThreadName=" + Thread.currentThread().getName());
                conditionB.await();         //conditionB等待
                System.out.println(" end awaitB时间为" + System.currentTimeMillis()
                        + " ThreadName=" + Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
        public void signalAll_A() {
            try {
                lock.lock();
                System.out.println(" signalAll_A时间为" + System.currentTimeMillis()
                        + " ThreadName=" + Thread.currentThread().getName());
                conditionA.signalAll();         //conditionA唤醒
            } finally {
                lock.unlock();
            }
        }
        public void signalAll_B() {
            try {
                lock.lock();
                System.out.println(" signalAll_B时间为" + System.currentTimeMillis()
                        + " ThreadName=" + Thread.currentThread().getName());
                conditionB.signalAll();     //conditionB唤醒
            } finally {
                lock.unlock();
            }
        }
    }
    //------------两个线程类----------
    public class ThreadA extends Thread { 
        private MyService service;
    
        public ThreadA(MyService service) {
            super();
            this.service = service;
        }
        @Override
        public void run() {
            service.awaitA();
        }
    }
    public class ThreadB extends Thread { 
        private MyService service;
    
        public ThreadB(MyService service) {
            super();
            this.service = service;
        }
        @Override
        public void run() {
            service.awaitB();
        }
    }
    //--------------主函数-----------
        public static void main(String[] args) throws InterruptedException {
            MyService service = new MyService();
            ThreadA a = new ThreadA(service);
            a.setName("A");
            a.start();
            ThreadB b = new ThreadB(service);
            b.setName("B");
            b.start();
            Thread.sleep(6000);
            service.signalAll_A();  //唤醒conditionA
        }
    }
    //--------------运行结果------------
    begin awaitA时间为 1493952464356 ThreadName=A
    begin awaitB时间为1493952464357 ThreadName=B
    signalAll_A时间为1493952470356 ThreadName=main
    end awaitA时间为 1493952470356 ThreadName=A

### 实现生产者/消费者模式：一对一交替打印 ###

### 实现生产者/消费者模式：多对多交替打印 ###

public class MyService { 
    
        private ReentrantLock lock = new ReentrantLock();
        private Condition condition = lock.newCondition();
        private boolean hasValue = false;
        //--------生产者--------------
        public void set() {
            try {
                lock.lock();
                while (hasValue == true) {
                    System.out.println("有可能**连续");
                    condition.await();
                }
                System.out.println("打印**");
                hasValue = true;
                condition.signalAll();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
        //---------消费者-------------
        public void get() {
            try {
                lock.lock();
                while (hasValue == false) {
                    System.out.println("有可能--连续");
                    condition.await();
                }
                System.out.println("打印--");
                hasValue = false;
                condition.signalAll();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
    //-------------两个线程类----------
    public class MyThreadA extends Thread { 
        private MyService myService;
        public MyThreadA(MyService myService) {
            super();
            this.myService = myService;
        }
        @Override
        public void run() {
            for (int i = 0; i < Integer.MAX_VALUE; i++) {
                myService.set();
            }
        }
    }
    public class MyThreadB extends Thread { 
        private MyService myService;
        public MyThreadB(MyService myService) {
            super();
            this.myService = myService;
        }
        @Override
        public void run() {
            for (int i = 0; i < Integer.MAX_VALUE; i++) {
                myService.get();
            }
        }
    }
    //---------主函数--------------
    public class Run { 
        public static void main(String[] args) throws InterruptedException {
            MyService service = new MyService();
            MyThreadA[] threadA = new MyThreadA[10];
            MyThreadB[] threadB = new MyThreadB[10];
            for (int i = 0; i < 10; i++) {
                threadA[i] = new MyThreadA(service);
                threadB[i] = new MyThreadB(service);
                threadA[i].start();
                threadB[i].start();
            }
        }
    }
    //---------运行结果----------
    打印**
    有可能**连续
    打印--
    有可能--连续
    有可能--连续
    有可能--连续
    有可能--连续
    有可能--连续
    有可能--连续
    打印**
    有可能**连续
    有可能**连续
    有可能**连续
    有可能**连续
    有可能**连续
    打印--
    有可能--连续
    有可能--连续
    打印**
    有可能**连续
    …………

### 公平锁与非公平锁 ###

*  锁Lock分为“公平锁”和“非公平锁”
 *  公平锁：线程获取锁的顺序是按照线程加锁的顺序来分配的，即先来先得的FIFO先进先出顺序
 *  非公平锁：是一种获取锁的抢占机制，是随机获得锁的，这个方式可能造成某些线程一直获取不到锁，结果就是不公平了

public class Service {
        private ReentrantLock lock;
        public Service(boolean isFair) {
            super();
            lock = new ReentrantLock(isFair);   //设置是否为公平锁
        }
        public void serviceMethod() {
            try {
                lock.lock();
                System.out.println("ThreadName=" + Thread.currentThread().getName()
                        + "获得锁定");
            } finally {
                lock.unlock();
            }
        }
    }

*  公平锁的特点：获取锁的顺序**基本上**呈有序的状态（但是貌似我看不出有序）
 *  非公平锁是乱序的

### 方法getHoldCount()、getQueueLength()和getWaitQueueLength()的测试 ###

*  getHoldCount()查询当前线程保持此锁定的个数，也就是调用lock()方法的次数
 *  getQueueLength()返回正等待获取此锁定的线程估计数
 *  getWaitQueueLength()返回与此锁定相关的给定条件Condition的线程估计数

### 方法hasQueueThread()、hasQueueThreads()和hasWaiters()的测试 ###

*  hasQueueThread()查询指定的线程是否正在等待获取此锁定
 *  hasQueueThreads()查询是否有线程正在等待获取此锁定
 *  hasWaiters()查询是否有线程正在等待与此锁定有关的condition条件

### 方法isFair()、isHeldByCurrentThread()和isLocked()的测试 ###

*  isFair()判断是不是公平锁，**默认情况下ReentrantLock类使用的是非公平锁**
 *  isHeldByCurrentThread()方法查询当前线程是否保持此锁定
 *  isLocked()查询此锁定是否由任意线程保持

### 方法lockInterruptibly(),tryLock()和tryLock(long timeout, TimeUnit unit)的测试 ###

*  lockInterruptibly()的作用是：如果当前线程未被中断，则获取锁定，如果已经被中断则出现异常
 *  tryLock()的作用是：仅在调用时锁定未被另一个线程保持的情况下，才获取该锁定
 *  tryLock(long timeout, TimeUnit unit)的作用是：如果锁定在给定等待时间内没有被另一个线程保持，且当前线程未被中断，则获取该锁定

### 方法awaitUninterruptibly()的使用 ###

### 方法awaitUntil()的使用 ###

### 使用Condition实现顺序执行 ###

## 使用ReentrantReadWriteLock类 ##

*  类ReentrantLock具有完全互斥排他的效果，即同一时间只有一个线程在执行ReentrantLock.lock()方法后面的任务。这样做虽然保证了实例变量的线程安全性，但效率却是非常低下的。
 *  所以在JDK中提供了一种读写锁ReentrantReadWriteLock类，使用它可以加速运行效率，在某些不需要操作实例变量的方法中，完全可以使用读写锁ReentrantReadWriteLock来提升该方法的代码运行速度。
 *  读写锁表示也有两个锁，一个读操作相关的锁，也称共享锁；另一个是写操作相关的锁，也叫排他锁。
 *  也就是多个读锁之间不互斥，读锁与写锁互斥，写锁与写锁互斥。
 *  在没有线程Thread进行写入操作时，进行读取操作的多个线程都可以获取读锁，而进行写入操作的线程只有在获取写锁之后才能进行写入操作。即多个线程可以同时进行读取操作，但同一时刻只允许一个线程进行写操作

### 类ReentrantReadWriteLock的使用：读读共享 ###

public class Service { 
        private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();//读写锁
        public void read() {
            try {
                try {
                    lock.readLock().lock();     //获取读锁
                    System.out.println("获得读锁" + Thread.currentThread().getName()
                            + " " + System.currentTimeMillis());
                    Thread.sleep(10000);
                } finally {
                    lock.readLock().unlock();   
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public class ThreadA extends Thread { 
        private Service service;
        public ThreadA(Service service) {
            super();
            this.service = service;
        }
        @Override
        public void run() {
            service.read();     //读
        }
    }
    public class ThreadB extends Thread { 
        private Service service;
        public ThreadB(Service service) {
            super();
            this.service = service;
        }
        @Override
        public void run() {
            service.read(); //读
        }
    }
    public class Run { 
        public static void main(String[] args) {
            Service service = new Service();
            ThreadA a = new ThreadA(service);
            a.setName("A");
            ThreadB b = new ThreadB(service);
            b.setName("B");
            a.start();
            b.start();
        }
    }

### 类ReentrantReadWriteLock的使用：写写互斥 ###

public class Service {
        private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
        public void write() {
            try {
                try {
                    lock.writeLock().lock();        //写锁
                    System.out.println("获得写锁" + Thread.currentThread().getName()
                            + " " + System.currentTimeMillis());
                    Thread.sleep(10000);
                } finally {
                    lock.writeLock().unlock();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

### 类ReentrantReadWriteLock的使用：读写互斥 ###

public class Service {
        private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
        public void read() {
            try {
                try {
                    lock.readLock().lock();
                    System.out.println("获得读锁" + Thread.currentThread().getName()
                            + " " + System.currentTimeMillis());
                    Thread.sleep(10000);
                } finally {
                    lock.readLock().unlock();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        public void write() {
            try {
                try {
                    lock.writeLock().lock();
                    System.out.println("获得写锁" + Thread.currentThread().getName()
                            + " " + System.currentTimeMillis());
                    Thread.sleep(10000);
                } finally {
                    lock.writeLock().unlock();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

### 类ReentrantReadWriteLock的使用：写读互斥 ###

[Java]: http://product.dangdang.com/23711315.html