Java多线程 — — lock、await 、signal 组合 替换 sync、wait、notifyAll，实现精准唤醒线程

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Java多线程 — — lock、await 、signal 组合 替换 sync、wait、notifyAll，实现精准唤醒线程，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含2463字，纯文字阅读大概需要4分钟。

内容图文

接上篇博客我们使用老旧的多线程API实现了线程间通信，

但是为了让线程运行的更有效率，

本篇我们采用 lock、await 、signal 新特性，

进行再次酿造，

旧瓶子，装点新酒。

需求：

很简单，要求顺次打印1次A，2次B，3次C，循环来10遍。

废话不多说，直接上源码：

package ldk.test;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @Author: ldk
 * @Date: 2020/12/18 16:03
 * @Describe:
 */
public class ThreadTest1 {


    public static void main(String[] args) {
        Data data = new Data();
        //生产者线程A
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.print1();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "A").start();

        //生产者线程B
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.print2();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "B").start();

        //消费者线程C
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.print3();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "C").start();


    }


    //数据类
    static class Data {
        //表示数据个数
        private int number = 1;

        private Lock lock = new ReentrantLock();
        private Condition condition1 = lock.newCondition();
        private Condition condition2 = lock.newCondition();
        private Condition condition3 = lock.newCondition();

        public void print1() throws InterruptedException {
            lock.lock();
            try {
                while (number != 1) {
                    condition1.await();
                }
                System.out.println(Thread.currentThread().getName());
                number = 2;
                condition2.signal();
            } finally {
                lock.unlock();
            }

        }

        public void print2() throws InterruptedException {
            lock.lock();
            try {
                while (number != 2) {
                    condition2.await();
                }
                for (int i = 0; i < 2; i++) {
                    System.out.println(Thread.currentThread().getName());
                }
                number = 3;
                condition3.signal();
            } finally {
                lock.unlock();
            }

        }

        public void print3() throws InterruptedException {
            lock.lock();
            try {
                while (number != 3) {
                    condition3.await();
                }
                for (int i = 0; i < 3; i++) {
                    System.out.println(Thread.currentThread().getName());
                }
                number = 1;
                condition1.signal();
            } finally {
                lock.unlock();
            }

        }
    }
}

执行结果：

 简单分析：

需求很明了，
按顺序走10遍，
我们主要优化的是精准唤醒，
每次执行完须定向地执行下个目标，
lock和unlock想必大家很熟悉，就是上锁，解锁操作，

主要是condition控制了线程的精准调度

流程简单分析：

1、值初始化为1，很自然进入print1，打印1次

2、值变成2，唤醒condition2，执行打印2次，唤醒condition3（即使开始是condition3抢到，现在值为2，condition3线程只能等待，最终还是有condition2执行）

3、此时值为3，且condition3唤醒，打印3次，值设置为1，唤醒condition1，

4、...周而复始，打印10遍为止。

内容总结

以上是互联网集市为您收集整理的Java多线程 — — lock、await 、signal 组合 替换 sync、wait、notifyAll，实现精准唤醒线程全部内容，希望文章能够帮你解决Java多线程 — — lock、await 、signal 组合 替换 sync、wait、notifyAll，实现精准唤醒线程所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端