多线程之间的5中通信方式

最新推荐文章于 2022-07-19 21:36:45 发布
最新推荐文章于 2022-07-19 21:36:45 发布
阅读量339 收藏
点赞数
分类专栏： java 文章标签： 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/family_kj/article/details/125425472
版权 
public class ThreadCommunicationExample {
    private static volatile boolean FLAG = false;
    private static Object object = new Object();
    private static List list = new ArrayList();
    private static CountDownLatch countDownLatch = new CountDownLatch(1);
    private static ReentrantLock lock = new ReentrantLock();
    private static Condition condition = lock.newCondition();

    public static void main(String[] args) {
//        byVolatile();
//        byWaitNotify();
//        byCountDownLatch();
//        byReentrantLockAndCondition();
//        byLockSupport();
    }

    private static void byLockSupport() {
        /**基于 LockSupport 实现线程间的阻塞和唤醒
         LockSupport 是一种非常灵活的实现线程间阻塞和唤醒的工具，使用它不用关注是等待线程先进行还是唤醒线程先运行，但是得知道线程的名字
         */
        Thread threadA = new Thread(() -> {
            lock.lock();
            try {
                for (int i = 0; i < 10; i++) {
                    if (i == 5) {
                        System.out.println("ThreadA 调用 LockSupport.park()开始阻塞当前线程线程");
                        LockSupport.park();
                    }
                    list.add(i);
                    System.out.println("ThreadA---> list.size() = " + list.size());
                }
            } finally {
                lock.unlock();
            }

        });
        Thread threadB = new Thread(() -> {
            if (list.size() == 5) {
                System.out.println("ThreadB 调用 LockSupport.unpark(threadA)开始释放线程threadA");
                LockSupport.unpark(threadA);

            }
            if (list.size() != 1) {
                System.out.println("ThreadB---> list.size() = " + list.size());
                System.out.println("ThreadB 调用 LockSupport.park()开始阻塞当前线程线程");
                LockSupport.park();
            }
            try {
                Thread.currentThread().sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程B 处于业务处理结束......list.size() = " + list.size());
        });
        Thread threadC = new Thread(() -> {
            if (list.size() != 1) {
                System.out.println("ThreadC 调用 LockSupport.unpark(threadB)开始释放线程threadB");
                LockSupport.unpark(threadB);
                try {
                    Thread.currentThread().sleep(6000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程C 处于业务处理结束......list.size() = " + list.size());
            }
        });

        threadA.start();
        try {
            Thread.currentThread().sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        threadB.start();
        try {
            Thread.currentThread().sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        threadC.start();
    }

    private static void byReentrantLockAndCondition() {
        /**使用 ReentrantLock 结合 Condition
         * 这种方式使用起来并不是很好，代码编写复杂，而且线程 B 在被 A 唤醒之后由于没有获取锁还是不能立即执行，
         * 也就是说，A 在唤醒操作之后，并不释放锁。这种方法跟 Object 的 wait()/notify() 一样
         */
        Thread threadA = new Thread(() -> {
            lock.lock();
            try {
                for (int i = 0; i < 10; i++) {
                    if (i == 5) {
//                        System.out.println("ThreadA 调用 singal ，唤醒condition等待队列中随机一个线程");
//                        condition.signal();
                        System.out.println("ThreadA 调用 signalAll ，唤醒condition等待队列中所有线程");
                        condition.signalAll();
                        try {
                            Thread.currentThread().sleep(2000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    list.add(i);
                    System.out.println("ThreadA---> list.size() = " + list.size());
                }
            } finally {
                lock.unlock();
            }

        });
        Thread threadB = new Thread(() -> {
            lock.lock();
            try {
                if (list.size() != 5) {
                    try {
                        System.out.println("线程B 处于开始等待......");
                        condition.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程B 处于开始处理业务......list.size() = " + list.size());
//                    System.out.println("ThreadB 调用 singal ，唤醒condition等待队列中随机一个线程");
//                    condition.signal();
                    try {
                        Thread.currentThread().sleep(4000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程B 处于业务处理结束......list.size() = " + list.size());
                }
            } finally {
                lock.unlock();
            }
        });
        Thread threadC = new Thread(() -> {
            lock.lock();
            try {
                if (list.size() != 5) {
                    try {
                        System.out.println("线程C 处于开始等待......");
                        condition.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程C 处于开始处理业务......list.size() = " + list.size());
//                    System.out.println("ThreadC 调用 singal ，唤醒condition等待队列中随机一个线程");
//                    condition.signal();
                    try {
                        Thread.currentThread().sleep(4000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程C 处于业务处理结束......list.size() = " + list.size());
                }
            } finally {
                lock.unlock();
            }
        });

        threadB.start();
        threadC.start();
        try {
            Thread.currentThread().sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        threadA.start();
    }

    private static void byCountDownLatch() {
        /**
         jdk1.5 之后在java.util.concurrent包下提供了很多并发编程相关的工具类，简化了并发编程代码的书写，CountDownLatch 基于 AQS 框架，
         相当于也是维护了一个线程间共享变量 state。
         */
        Thread threadA = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                if (i == 5) {
                    System.out.println(Thread.currentThread().getName() + " i:" + i + "线程A执行休眠1秒");
                    try {
                        Thread.currentThread().sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    countDownLatch.countDown();
                    System.out.println(Thread.currentThread().getName() + " i:" + i + "线程A执行countDown");
                } else {
                    System.out.println(Thread.currentThread().getName() + " i:" + i);
                }
            }
        });
        Thread threadB = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                if (i == 5) {
                    try {
                        countDownLatch.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + " i:" + i + "线程B执行await");
                } else {
                    System.out.println(Thread.currentThread().getName() + " i:" + i);
                }
            }
        });
        threadB.start();
        try {
            Thread.currentThread().sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        threadA.start();
    }

    private static void byWaitNotify() {
        /**使用 Object 类的 wait()/notify()
         Object 类提供了线程间通信的方法：wait()、notify()、notifyAll()，它们是多线程通信的基础，而这种实现方式的思想自然是线程间通信。
         注意：wait/notify 必须配合 synchronized 使用，wait 方法释放锁，notify 方法不释放锁。wait 是指在一个已经进入了同步锁的线程内，
         让自己暂时让出同步锁，以便其他正在等待此锁的线程可以得到同步锁并运行，只有其他线程调用了notify()，notify并不释放锁，
         只是告诉调用过wait()的线程可以去参与获得锁的竞争了，但不是马上得到锁，因为锁还在别人手里，别人还没释放，
         调用 wait() 的一个或多个线程就会解除 wait 状态，重新参与竞争对象锁，程序如果可以再次得到锁，就可以继续向下运行。
         */
        /**notify()和notifyAll()都是用来用来唤醒调用wait(）方法进入等待锁资源队列的线程，区别在于：
         notify()
         唤醒正在等待此对象监视器的单个线程。 如果有多个线程在等待，则选择其中一个随机唤醒（由调度器决定），唤醒的线程享有公平竞争资源的权利
         notifyAll()
         唤醒正在等待此对象监视器的所有线程，唤醒的所有线程公平竞争资源
         */

        //由输出结果，在线程 A 发出 notify() 唤醒通知之后，依然是走完了自己线程的业务之后，线程 B 才开始执行，正好说明 notify() 不释放锁，而 wait() 释放锁。
        Thread threadA = new Thread(() -> {
            synchronized (object) {
                for (int i = 0; i < 10; i++) {
                    if (i != 5) {
                        list.add(i);
                        System.out.println(Thread.currentThread().getName() + ": list.size = " + list.size());
                    } else {
//                        object.notify();
//                        System.out.println(Thread.currentThread().getName() + "调用notify随机唤醒一个阻塞线程");
                        object.notifyAll();
                        System.out.println(Thread.currentThread().getName() + "调用notify唤醒所有阻塞线程");
                    }
                }
            }
        });
        Thread threadB = new Thread(() -> {
            synchronized (object) {
                while (true) {
                    if (list.size() == 5) {
                        System.out.println(Thread.currentThread().getName() + ": list.size = " + list.size() + "B线程开始处理业务......");
                    } else {
                        try {
                            System.out.println(Thread.currentThread().getName() + " 准备阻塞当前线程B");
                            object.wait();
                            System.out.println(Thread.currentThread().getName() + " 阻塞当前线程B 结束");
                            System.out.println(Thread.currentThread().getName() + ": list.size = " + list.size() + " B线程开始处理业务......");
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        });

        Thread threadC = new Thread(() -> {
            synchronized (object) {
                while (true) {
                    if (list.size() == 5) {
                        System.out.println(Thread.currentThread().getName() + ": list.size = " + list.size() + "C线程开始处理业务......");
                    } else {
                        try {
                            System.out.println(Thread.currentThread().getName() + " 准备阻塞当前线程C");
                            object.wait();
                            System.out.println(Thread.currentThread().getName() + " 阻塞当前线程C 结束");
                            System.out.println(Thread.currentThread().getName() + ": list.size = " + list.size() + " C线程开始处理业务......");
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        });
        //先让B线程拿到锁，业务逻辑中wait阻塞等待住，然后释放锁； 这个时候A线程获取到锁，业务逻辑中触发B线程的唤醒，但是B需要去获取锁，由于
        //A线程调用notify是不会释放锁的，所以只有A的加锁代码运行结束才会释放锁。这个时候只有B竞争到锁了，才会触发wait后面的业务
        threadB.start();
        try {
            Thread.currentThread().sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        threadC.start();
        try {
            Thread.currentThread().sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        threadA.start();
    }

    private static void byVolatile() {
        /**基于 volatile 关键字来实现线程间相互通信是使用共享内存的思想。大致意思就是多个线程同时监听一个变量，
         当这个变量发生变化的时候 ，线程能够感知并执行相应的业务。这也是最简单的一种实现方式.*/
        Thread threadA = new Thread(() -> {
            Stream.iterate(0, n -> n + 1).limit(10).forEach(n -> {
                if (n == 8) {
                    FLAG = true;
                    System.out.println(Thread.currentThread().getName() + ": " + n + "---> FLAG = " + FLAG);
                    return;
                }
                System.out.println(Thread.currentThread().getName() + ": " + n + "---> FLAG = " + FLAG);
                try {
                    Thread.currentThread().sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        });
        Thread threadB = new Thread(new Runnable() {
            @Override
            public void run() {
                while (!FLAG) {
                    System.out.println("B线程等待中......");
                    try {
                        Thread.currentThread().sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread().getName() + ": #### B线程开始执行业务 ### FLAG = " + FLAG);
            }
        });

        threadB.start();
        threadA.start();
    }

Lucky-boy-kj
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程之间如何进行通信 ？
学无止境
09-13 1317
实现多线程之间通信的方式有多种，以下是一些常见的方式：共享变量：多个线程共享一个变量，通过互斥锁（如关键字）来保护对该变量的访问，确保线程之间的安全通信。wait()和notify()：通过Object类的wait()方法使线程等待，然后使用notify()或方法来通知等待的线程继续执行。与块一起使用。是一个线程安全的队列，用于在线程之间传递数据。生产者线程可以将数据放入队列，消费者线程可以从队列中取出数据，阻塞队列会处理线程之间的同步和通信。用于等待一组线程执行完毕。
Java多线程：线程间通信方式
最新发布
流楚丶格念的博客
11-08 2012
这三个方法都是Condition接口中的方法，该接口是在Java 1.5中出现的，它用来替代传统的wait+notify实现线程间的协作，它的使用依赖于 Lock。反之，当一个线程被wait后，就会进入阻塞队列，等待被唤醒。案例步骤：通信是在不同线程间的通信，一个线程处于wait状态阻塞等待被唤醒，另一个线程通过notify或者notifyAll唤醒，当前的唤醒操作必须是作用与同一个对象，注意在进行唤醒和阻塞时必须要加锁的，加锁需要使用synchronized关键字。程序没有结束，他会一直读取阻塞队列。
多线程之间实现通讯
清欢
04-20 1869
多线程之间实现通讯 多线程之间如何通讯 wait、notify、notifyAll()方法 lock 停止线程 守护线程 Join方法 优先级 Yield 3.2 多线程之间如何实现通讯 3.2.1 什么是多线程之间通讯？ 多线程之间通讯，其实就是多个线程在操作同一个资源，但是操作的动作不同。 画图演示 3.2.2 多线程之间通讯需求 需求:第一个线程写入(input)用户，另一个线程取读取(ou...
看了这篇文章，就别担心线程间的通信了！
Simon郎的博客
05-07 3051
线程间的通信 1、为什么需要线程通信 线程是操作系统调度的最小单位，有自己的栈空间，可以按照既定的代码逐步的执行，但是如果每个线程间都孤立的运行，那就会造资源浪费。所以在现实中，我们需要这些线程间可以按照指定的规则共同完成一件任务，所以这些线程之间就需要互相协调，这个过程被称为线程的通信。 线程的通信可以被定义为： 线程通信就是当多个线程共同操作共享的资源时，互相告知自己的状态以避免资源争夺。 ...
多线程间的通信方式
qq_41482600的博客
06-23 282
多线程通信
4年工作经验，多线程间的5种通信方式都说不出来，你敢信？
Java知音
06-23 933
点击关注公众号，实用技术文章及时了解问题有两个线程，A 线程向一个集合里面依次添加元素“abc”字符串，一共添加十次，当添加到第五次的时候，希望 B 线程能够收到 A 线程的通知，然后 B 线程执行相关的业务操作。线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。一、使用 volatile 关键字基于 volatile 关键字来实现线程间相互...
多线程之间通讯5.rar
08-23
本资源包“多线程之间通讯5.rar”显然关注的是如何在多线程环境下实现线程间的通信。 线程之间的通信（IPC, Inter-Process Communication）是为了协调不同线程间的工作，确保数据的一致性和正确性。以下是一些主要...
浅析Java中如何实现线程之间通信
08-30
Java中的线程间通信是多线程编程中的关键概念，它允许不同线程间共享数据、协调执行顺序，以实现复杂任务的同步。...在实际开发中，需要根据具体场景选择最适合的线程通信方式，确保程序的正确性和性能。
Qt多线程通讯
02-27
Qt库提供了一种高效且方便的方式来处理多线程通信，使得开发者可以充分利用现代多核处理器的优势，提高程序的响应性和性能。本DEMO主要展示了如何在Qt中利用信号槽机制实现主线程与子线程之间的通信。 首先，我们要...
操作系统中多线程之间通信
12-21
操作系统中的多线程通信是并发编程中的核心概念，它允许不同的执行线程在共享资源时进行协调和数据交换。在本文中，我们将深入探讨多线程通信的重要性、常见方法以及如何解决经典的问题——读者写者问题。 首先，多...
多线程之间的通信
石头也有呆毛~~
11-10 562
我们通过一个简单的例子来看下多线程的通信 我们有这样一个需求： 1.建立一个公共资源Resource 2.建立两个线程一个线程负责增加资源，一个线程负责取资源 class Resource{ String name; String sex;} //输入 class Input implements Runnable{ Resource r; //一构造
多线程之间通信的5种方式
热门推荐
wyong890517的博客
01-05 1万+
首先，我们知道线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的; 以客户卖包子为例,当店家在包子加工到第4步时就可以卖给客户为例说明,A,B两个线程,示例如下: 方式一：使用Object类的wait() 和 notify() 方法 众所周知，Object类提供了线程间通信的方法：wait()、notify()、notifyaAl()，它们是多线程通信的基础，而这...
多线程间的通信
heyzyyyyyy的博客
09-07 652
1、多线程中最常见的应用案例，生产者消费者问题 生产和消费同时执行，需要多线程。但是执行的任务不相同，处理的资源相同：线程的通信。 1、描述资源 2、描述生产者，因为具备着自己的任务。 3、描述消费者，因为具备着自己的任务。 问题1、运行第一次结果：数据错误，已经被生产很早期的商品，才被消费到。 出现线程安全问题，加入同步解决。使用的是同步函数。 问题已解决：不会再消费到之前很早期的...
多线程之间通信
guihaiyuan123的博客
04-16 387
什么是多线程之间通讯？ 多线程之间通讯，其实就是多个线程在操作同一个资源，但是操作的动作不同。 画图演示 方法一：synchronized和wait配套使用 Object类的方法部分截图： 其中我们要用到的是wait()、notify()、notifyAll()是三个方法，可以用来控制线...
多线程之间的通信方式
weixin_44092924的博客
12-13 536
1.同步 2.wait/notify 3.管道通信
【多线程】线程间的通信
qq_48848473的博客
07-19 449
一，等待/通知机制 二，通过管道实现线程间的通信
多线程之间的通讯
JavaAlliance
10-11 548
多线程之间如何实现通讯 1.什么是多线程之间通讯？ 多线程之间通讯，其实就是多个线程在操作同一个资源，但是操作的动作不同。 画图演示 2.多线程之间通讯需求 需求:第一个线程写入(input)用户，另一个线程取读取(out)用户.实现读一个，写一个操作。 代码实现基本实现 共享资源源实体类 class Res { public String userSex; public String us...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值