java多线程编程核心技术——第四章总结

第一节使用ReentrantLock类

1.1使用ReentrantLock实现同步:测试1

  使用下面代码获取ReenTrantLock对象lock

private Lock lock = new ReentrantLock();

  调用lock.lock()方法可以对代码进行加锁,调用lock.unlock()方法对代码进行解锁。

  注:需要进行加锁的代码放在lock()与unlock()方法中。

1.2使用ReentrantLock实现同步:测试2

  调用了lock()方法代码的线程会持有“对象监视器”,其他线程只有等待锁被释放时再次争抢,效果跟使用synchronized关键字一样,线程间还是顺序执行的。

1.3使用Condition实现等待/同步错误用法与解决

  类ReentrantLock实现等待/同步功能,需要借助于condition对象。

  Condition类具有很好的灵活性,可以实现多路通知功能:在一个Lock对象中创建多个Condition(对象监视器)实例,线程对象可以注册在指定的Condition中,从而有选择性地进行线程通知,在调度线程上更灵活。

  在使用notify()/notifyAll()方法进行通知时,被通知的线程是由JVM随机选择的,但使用ReentrantLock结合Condition类是可以实现前面介绍过的“选择性通知”,这个功能是常用,且在Condition中是默认的。

  通过下面代码获取Condition实例

private Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition();

  然后使用condition.await()来进行等待操作。

  注:在进行await()前,必须调用lock.lock()来获取监视器对象,否则的话就会爆出异常:java.lang.IllegalMonitorStateException(无监视器异常)。

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

  Object类中的wait()方法相当于Condition类中的await()方法。

  Object类中的wait(long timeout)方法相当于Condition类中的await(long time, TimeUnit unit)方法。

  Object类中的notify()方法相当于Condition类中的single()方法。

  Object类中的notifyAll()方法相当于Condition类中的singleAll()方法。

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

  一个Condition对象可以通过singleAll()方法唤醒所有调用lock.newCondition().await()的线程。

  但是若想实现只唤醒部分线程,只能使用多个Condition对象了,这也就是Condition对象可以唤醒部分指定线程,提高程序运行效率。

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

  若想实现Condition对象唤醒部分指定线程。一定要是调用等待的Condition对象与调用唤醒的Condition保持是一个Condition对象。

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

public class Service {
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    private boolean flag = false;

    public void set() {
        try {
            lock.lock();
            while (flag == true) {
                condition.await();
            }
            System.out.println("我是set");
            flag = true;
            condition.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
          lock.unlock();
        }
    }

    public void get() {
        try {
            lock.lock();
            while (flag == false) {
                condition.await();
            }
            System.out.println("我是get");
            flag = false;
            condition.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

  一个线程调用set(),一个线程调用get()就可以实现一对一交替打印。

1.8实现生产者/消费者模式:多对多打印

  service代码还是同1.7,执行时开启多条线程即可,但是会遇到“假死”问题,可以通过将signal()改为signalAll()来解决。

1.9公平锁与非公平锁

  锁Lock分为“公平锁”与“非公平锁”。

  公平锁:标识线程获取锁的顺序是按照线程加锁的顺序来分配的,即先来先得的FIFO先进先出顺序。

  非公平锁:一种线程抢占机制,是随机获取锁的,和公平锁不一样的就是先来的不一定先得到锁,这个方法可能会导致某些线程一直拿不到锁,自然不公平。

  创建的方式就是:

private Lock lock = new ReentrantLock(Boolean flag);

  flag为true就是公平锁,flag为false就是非公平锁。

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

  1)int getHoldCount()                       查询当前线程保持此锁定的个数,也就是调用lock()方法的次数。

  2)int getQueueLength()                  返回正等待获取此锁定线程估计数。

      比如有5个线程,一个线程先执行await()方法,那么在调用getQueueLength()方法后返回值是4,说明有4个线程同时在等待lock的释放。

  3)int getWaitQueueLength(Condition condition)        返回等待与此锁定相关的给定条件Condition的线程估计数。

      比如有5个线程,每个线程都执行了同一个condition对象的await()方法,则调用getWaitQueueLength()返回的值就是5。

   注:以上都是ReentrantLock类的API

1.11方法hasQueuedThread()、hasQueuedThreads()、hasWaiters()的测试

 1)boolean hasQueuedThread(Thread thread)          查询指定的线程是否正在等待获取此锁定。  

2)boolean hasQueuedThreads()                  查询是否有线程正在等待获取此锁定。

  3)boolean hasWaiters(Condition condition)             查询是否有线程正在等待与此锁定有关的condition条件。

  注:以上都是ReentrantLock类的API

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

  1)boolean isFair()            判断是不是公平锁

  2)boolean isHeldByCurrentThread()    查询当前线程是否保持此锁定

  3)boolean isLocked()            查询此锁定是否由任意线程保持

  注:以上都是ReentrantLock类的API

1.13方法lockInterruptibly()、tryLock()和tryLock(Long timeout, TimeUnit unit)的测试

  1)void lockInterruptibly()              如果当前线程未被中断(不处于中断状态),则获得锁定,如果已经被检测中断(处于中断状态)则出现异常。

            爆出java.lang.InterruptedException异常。

  2)boolean tryLcok()                仅在调用时锁定未被另一个线程保持的情况下,才获得该锁定。

  3)boolean tryLock(long timeout, TimeUnit unit)    如果锁定在给定等待时间内没有被另一个线程保持,且当前线程未被中断,则获得该锁定。

  注:以上都是ReentrantLock类的API

1.14方法awaitUninterruptibly()的使用

  此方法为condition的方法await()的替代。可以避免在挂起的时候遇到打断状态(interrupt)而爆出异常。

1.15方法awaitUntil()的使用

  在指定时间后唤醒自己。参数为long

  在线程等待期间也可以被其他线程唤醒。

  此方法是condition的API

1.16使用Condition实现顺序执行

  就是利用多个Condition实现顺序执行。

public class Main {
    volatile private static int flag = 1;

    private static ReentrantLock lock = new ReentrantLock();
    final private static Condition c1 = lock.newCondition();
    final private static Condition c2 = lock.newCondition();
    final private static Condition c3 = lock.newCondition();

    public static void main(String[] args) throws Exception{
        Thread threadA = new Thread() {
            @Override
            public void run() {
                try {
                    lock.lock();
                    while (flag != 1) {
                        c1.await();
                    }
                    for (int i = 0; i < 3; i++) {
                        System.out.println("ThreadA" + (i + 1));
                    }
                    flag = 2;
                    c2.signalAll();
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    lock.unlock();
                }
            }
        };
        Thread threadB = new Thread() {
            @Override
            public void run() {
                try {
                    lock.lock();
                    while (flag != 2) {
                        c2.await();
                    }
                    for (int i = 0; i < 3; i++) {
                        System.out.println("ThreadB" + (i + 1));
                    }
                    flag = 3;
                    c3.signalAll();
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    lock.unlock();
                }
            }
        };
        Thread threadC = new Thread() {
            @Override
            public void run() {
                try {
                    lock.lock();
                    while (flag != 3) {
                        c3.await();
                    }
                    for (int i = 0; i < 3; i++) {
                        System.out.println("ThreadC" + (i + 1));
                    }
                    flag = 1;
                    c1.signalAll();
                }catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    lock.unlock();
                }
            }
        };

        Thread[] a = new Thread[5];
        Thread[] b = new Thread[5];
        Thread[] c = new Thread[5];
        for (int i = 0; i < 5; i++) {
            a[i] = new Thread(threadA);
            b[i] = new Thread(threadB);
            c[i] = new Thread(threadC);
            a[i].start();
            b[i].start();
            c[i].start();
        }
    }
}

第二节使用ReentrantReadWriteLock类

  实际上ReentrantLock虽然能够保证实例变量的线程安全性,但是效率比较低。

  为了在一些不需要操作实例变量的方法中,使用一些效率较高的锁来实现提升运行效率,即使用ReentrantReadWriteLock读写锁。

  读写锁表示有两个锁,一个是读操作相关的锁,也成为共享锁;

            另一个是写操作相关的锁,也叫排他锁。

            也就是说读锁之间不互斥,读锁与写锁互斥,写锁与写锁互斥。在没有线程进行写操作时,多个进行读操作的线程都可以获取读锁,而进行写入操作的Thread只有在获取写锁后才能进

            行写入操作。

  注:多个线程可以同时进行读操作,但同一时刻只允许一个Thread进行写入操作。  

2.1读读共享

  可以通过如下代码获取读写锁

private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

  lock.readLock().lock()

  就可以获得读锁,并进行加锁。

  lock.readLock().unlock()

  释放读锁。

  注:读锁是共享锁。

2.2写写互斥

  lock.writeLock().lock()

  就可以获得写锁,并进行加锁。

  lock.writeLock().unlock()

  释放写锁。

  注:写锁是互斥锁。

2.3读写互斥

2.4写读互斥

  读锁与写锁是互斥的,也就是说不管是读锁先加锁还是写锁先加锁,只要两者相遇都是互斥的,必须等待其中一个释放线程后才能够再获得锁。

  “读写”、“写读”、“写写”都是互斥的(因为写锁时互斥锁,所以只要出现写锁,就一定是互斥的)

  “读读”是共享的,非互斥的。

本章总结:

  本章用Lock来替换掉了synchronized关键字。

  Lock很重要,重要到什么程度?很多并发包的源码都是通过Lock实现的。学好了Lock,有助于你理解你进一步进阶去看一些并发的源码。

本文内容是书中内容兼具自己的个人看法所成。可能在个人看法上会有诸多问题(毕竟知识量有限,导致认知也有限),如果读者觉得有问题请大胆提出,我们可以相互交流、相互学习,欢迎你们的到来,心成意足,等待您的评价。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏青玉伏案

iOS逆向工程之Hopper中的ARM指令

虽然前段时间ARM被日本软银收购了,但是科技是无国界的,所以呢ARM相关知识该学的学。现在看ARM指令集还是倍感亲切的,毕竟大学里开了ARM这门课,并且做了不少...

2607
来自专栏Java架构沉思录

Java中如何提升锁性能

比如100个人去银行办理业务,要填一百张表,但是只有一支笔,那么很显然,每个人用笔的时间越短,效率也就越高。看代码:

672
来自专栏一个番茄说

让你在WebView中用JS调Native Object

之所做这个东西,源于之前项目中需要把一些页面用webView来呈现,但是web中需要调用native的方法,比如获取本地存的某些数据、调用摄像头等等,这里也就是...

953
来自专栏chenssy

这些Spring中的设计模式,你都知道吗?

设计模式作为工作学习中的枕边书,却时常处于勤说不用的尴尬境地,也不是我们时常忘记,只是一直没有记忆。

691
来自专栏ppjun专栏

Retrofit 使用笔记

在使用retrofit之前,你需要导入retrofit gsonconverter这些库。详情可以查看相关资料。https://github.com/squar...

1242
来自专栏Java 技术分享

WEB 小案例 -- 网上书城(二)

3157
来自专栏函数式编程语言及工具

泛函编程(37)-泛函Stream IO:通用的IO处理过程-Free Process

  在上两篇讨论中我们介绍了IO Process:Process[I,O],它的工作原理、函数组合等。很容易想象,一个完整的IO程序是由 数据源+处理过程+数据...

2185
来自专栏程序生活

Python爬虫系列(二)Quotes to Scrape(谚语网站的爬取实战)

接下来自己会写一些关于爬虫 实战的内容,把所学的知识加以运用。这篇文章是关于一个英文谚语网站的谚语爬取,并输出结果。 这个网站大致有10页谚语,所以是一个...

43310
来自专栏hotqin888的专栏

bootstrap treeview 增删改的正确姿势

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/hotqin888/article/det...

2243
来自专栏Java面试通关手册

Java多线程学习(六)Lock锁的使用

我自己总结的Java学习的系统知识点以及面试问题,目前已经开源,会一直完善下去,欢迎建议和指导欢迎Star: https://github.com/Snailc...

3438

扫码关注云+社区