第4章 Lock的使用

标签： Java多线程编程

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

---

---

本章着重掌握以下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 1ThreadName=Thread-0 2ThreadName=Thread-0 3ThreadName=Thread-0 4ThreadName=Thread-0 5ThreadName=Thread-1 1ThreadName=Thread-1 2ThreadName=Thread-1 3ThreadName=Thread-1 4ThreadName=Thread-1 5ThreadName=Thread-2 1ThreadName=Thread-2 2ThreadName=Thread-2 3ThreadName=Thread-2 4ThreadName=Thread-2 5ThreadName=Thread-3 1ThreadName=Thread-3 2ThreadName=Thread-3 3ThreadName=Thread-3 4ThreadName=Thread-3 5ThreadName=Thread-4 1ThreadName=Thread-4 2ThreadName=Thread-4 3ThreadName=Thread-4 4ThreadName=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=Abegin awaitB时间为1493952464357 ThreadName=BsignalAll_A时间为1493952470356 ThreadName=mainend 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的使用：写读互斥