Java实现线程通信的几种方式

最新推荐文章于 2024-07-14 02:44:52 发布
最新推荐文章于 2024-07-14 02:44:52 发布
阅读量283 收藏 1
点赞数
文章标签： java
原文链接：https://my.oschina.net/u/3272058/blog/3068524
版权

本文共总结了5种方式，通过代码举例的方式进行展示。5种方式为：synchronized加wait/notify方式、ReentrantLock加Condition方式、闭锁的方式、栅栏的方式、信号量的方式。

最后还介绍了join和yield的使用。

1、synchronized加wait/notify方式

/**
 * wait和notify的使用
 * wait和notify必须应用在synchronized块或方法内
 * 下面的代码向跳交谊舞一样互相控制着对方的输出
 */
public class MutiThread_WaitNotify {
    public static void main(String[] args) {
        final Object lock = new Object();
        Thread a = new Thread(new Runnable(){
            @Override
            public void run(){
                synchronized (lock){
                    try{
                        lock.wait();
                        System.out.println("A-1");
                        lock.notify();
                        lock.wait();
                        System.out.println("A-2");
                        lock.notify();
                        lock.wait();
                        System.out.println("A-3");
                        lock.notify();
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                }
            }
        });
        Thread b = new Thread(new Runnable(){
            @Override
            public void run(){
                synchronized (lock){
                    try{
                        System.out.println("B-1");
                        lock.notify();
                        lock.wait();
                        System.out.println("B-2");
                        lock.notify();
                        lock.wait();
                        System.out.println("B-3");
                        lock.notify();
                        lock.wait();
                        System.out.println("B-4");
                    }catch(InterruptedException e){
                        e.printStackTrace();;
                    }
                }
            }
        });
        a.start();
        b.start();
    }
}

2、ReentrantLock加Condition方式

/**
 * ReentrantLock和Condition的使用
 * 在使用Conditioin的await和signal时，必须将这两个方法写在ReentrantLock的lock方法之后
 */
public class MutiThread_ReentrantLock_Condition {
    public static void main(String[] args) {
        ReentrantLock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
        int i=1;
        for(; i<=6; i++){
            final int k = i;
            Thread t1 = new Thread(new Runnable() {
                @Override
                public void run() {
                    try{
                        lock.lock();
                        System.out.println("ThreadNo:A" + k + " is locked");
                        // 通过condition.await将线程阻塞
                        condition.await();
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }finally{
                        lock.unlock();
                        System.out.println("ThreadNo:A"+k + " is unlocked");
                    }
                }
            });

            Thread t2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    if(k == 6){
                        try{
                            lock.lock();
                            System.out.println("All Threads is signaled");
                            // 通过condition.signalAll唤醒所有线程
                            condition.signalAll();
                        }catch(Exception e){
                            e.printStackTrace();
                        }finally{
                            lock.unlock();
                        }
                    }else{
                        System.out.println("threads can't signaled, wait a moment.");
                    }
                }
            });
            t1.start();
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            t2.start();
        }
    }
}

3、闭锁方式

import java.util.concurrent.CountDownLatch;
/**
 * 闭锁的使用
 * 闭锁用于等待事件，当闭锁到达结束状态（本例中是闭锁的计数器值减为0）之前，所有线程都等待，当闭锁到达结束状态时，所有线程都通过
 * 闭锁是一次性的，当闭锁到达结束状态后，将不会被重置，这个锁会永远打开并允许所有线程通过。
 * 可以将代码中的NUM变量值变为2和4，分别试试什么效果
 */
public class MutiThread_CountDownLatch {
    public static void main(String[] args) {
        // 定义闭锁，并设置闭锁的计数器值为3
        CountDownLatch lock = new CountDownLatch(3);
        // 循环定义3个线程
        int NUM = 3;
        for(int i=1; i<=NUM; i++){
            final int k = i;
            Thread a = new Thread(new Runnable(){
                @Override
                public void run(){
                    try{
                        Thread.sleep(k * 1000);
                        System.out.println("ThreadNo:A"+k);
                        // 每个线程在休眠指定时间后将闭锁的计数器值减1，当闭锁的计数器值减到0时，闭所将被打开，从而使第二个循环中的所有线程才能通过
                        lock.countDown();
                        // 打印闭锁计数器的值
                        System.out.println("ThreadNo:A"+k+"; getCount:"+lock.getCount());
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                }
            });
            a.start();
        }
        // 循环定义2个线程
        for(int i=1; i<=2; i++){
            final int k = i;
            Thread b = new Thread(new Runnable(){
                @Override
                public void run(){
                    try{
                        System.out.println("ThreadNo:B"+k+" is waiting...");
                        // 当闭锁的计数器值不为0时，线程将在此处被中断
                        lock.await();
                        // 当闭锁的计数器值等于0时，闭锁将被打开，所有等待的线程都将被唤醒
                        System.out.println("ThreadNo:B"+k+" is notify");
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                }
            });
            b.start();
        }
    }
}

4、栅栏的方式

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

/**
 * 栅栏的使用
 * 栅栏用于等待线程，所有线程必须同时到达栅栏，才能继续执行
 * 栅栏不是一次性的，可以被重置。
 * 可以将代码中的NUM变量值变为5和7，分别试试什么效果
 */
public class MutiThread_CyclicBarrier {
    public static void main(String[] args) {
        // 定义栅栏，并设置栅栏需要等待的线程数为6
        CyclicBarrier barrier = new CyclicBarrier(6);
        int NUM = 100;
        for(int i=1; i<=NUM; i++){
            final int k = i;
            Thread t = new Thread(new Runnable() {
                @Override
                public void run() {
                    try{
                        Thread.sleep(k * 1000);
                        System.out.println("ThreadNo:"+k+" is waiting, getNumberWaiting:" + barrier.getNumberWaiting());
                        // 栅栏设置的等待线程数为6，当线程数不够6个时,所有线程将在此等待
                        barrier.await();
                        // 当线程数达到6个时，栅栏将被打开，所有线程都将被唤醒
                        System.out.println("ThreadNo:"+k+" is notify");
                        // 栅栏被重置，以便下次继续使用
                        barrier.reset();
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }
            });
            t.start();
        }
    }
}

5、信号量的方式

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Semaphore;

/**
 * 信号量的使用
 * 信号量用于控制同时访问某个资源的线程数量，信号量还可以用于实现某个资源池。
 * 信号量管理者一组虚拟的许可，线程在执行操作时首先要获得许可，如果信号量的许可数量为0，那么accquire将阻塞直到有许可为止
 * 信号量不是一次性的，当信号链的许可用完之后，可以通过release释放许可
 */
public class MutiThread_Semaphore {
    public static void main(String[] args) {
        // 定义信号量，并设置信号量的允许发放的最大许可数量为6
        final Semaphore semaphore = new Semaphore(6);
        // 定义集合，当信号量未发放的许可数量大于0则允许线程向集合内添加元素
        final List<String> set = new ArrayList<>();
        int i = 1;
        while(true){
            final int k = i++;
            Thread t = new Thread(new Runnable() {
                @Override
                public void run() {
                    boolean res = false;
                    try{
                        System.out.println("ThreadNo:A"+k+", availablePermits:"+semaphore.availablePermits());
                        // 当信号量允许发放的许可数量大于0，则会向集合内添加元素，否则将被中断于此
                        semaphore.acquire();
                        res = set.add("1");
                        System.out.println("ThreadNo:A"+k+" add item success");
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }finally{
                        if(!res){
                            semaphore.release();
                        }
                    }
                }
            });
            Thread t2 = new Thread(new Runnable() {
                @Override
                public void run() {
                    if(semaphore.availablePermits() == 0){
                        // 如果信号量允许发放的许可数量等于0，则释放制定数量的许可
                        semaphore.release(3); //释放3个许可
                        System.out.println("ThreadNo:B"+k+" releasePermitNum:"+semaphore.availablePermits());
                    }
                }
            });
            t.start();
            t2.start();
            System.out.println("the num of set:"+set.size());
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

A、join的使用

/**
 * join的使用
 * 实现当调用join的线程执行完毕后，其他线程才能执行
 */
public class MutiThread_Join {
    public static void main(String[] args) {
        Thread a = new Thread(new Runnable(){
            @Override
            public void run(){
                printNumber("A");
            }
        });
        Thread b = new Thread(new Runnable(){
            @Override
            public void run(){
                printNumber("B");
            }
        });
        try{
            a.start();
            // a线程执行完毕后，b线程才能执行
            a.join();
            b.start();
        }catch(InterruptedException e){
            e.printStackTrace();;
        }
    }
    public static void printNumber(String s){
        System.out.println(s+" print:"+s);
    }
}

B、yield的使用

/**
 * yield，当一个线程中调用了这个方法后，这个线程就会把自己的CPU执行时间让给自己或其它线程，
 * 注意是让给自己或其它线程，并不是单纯让给其他线程。yield执行后，能让当前线程由运行状态
 * 进入到就绪状态，将自己的CPU时间片让出来，让出来之后有可能是其它线程执行，也有可能是该线程
 * 继续执行。优先级高的线程并不一定是首先执行，而是首先执行的概率会高一些。优先级在大量线程
 * 执行的时候才能体现的出来。
 */
public class MutiThread_yield {
    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<10;i++){
                    System.out.println("ThreadNo:A"+i);
                    Thread.yield();
                }
            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<10;i++){
                    System.out.println("ThreadNo:B"+i);
                    Thread.yield();
                }
            }
        });
        t1.setPriority(Thread.MIN_PRIORITY);
        t2.setPriority(Thread.MAX_PRIORITY);
        t1.start();
        t2.start();
    }
}

转载于:https://my.oschina.net/u/3272058/blog/3068524

chengqiang1980
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java实现线程通信的几种方式
congge
05-30 5万+
前言 在多线程的世界里，线程与线程之间的交互无处不在，只不过在平时的开发过程中，大多数情况下，我们都在单线程的模式下进行编码，即使有，也直接借助框架自身的机制实现了，其实线程之间的通信在JDK中是一个比较深的问题，比如大家熟知的消息中间件的实现，从某种角度上讲，就借助了多线程通信的思想，下面总结了JDK中常用的几种实现线程通信的方式，提供参考 1、synchronized实现方式 可能很多小伙伴们会有疑问，synchronized是对共享资源加锁使用的，怎么和线程通信扯在一起呢？这里纠正一个小小的偏见，也是
Java实现线程间的通信的五种方式
Meiko记录
07-06 3026
如何使两个线程按顺序执行？ 假设有两个线程：线程A和线程B。两个线程都可以依次打印三个数字（1-3）。让我们看一下代码： private static void demo1() { Thread A = new Thread(new Runnable() { @Override public void run() { printNumber("A"); } }); Thread B = new Thre..
Java线程间的通信方式详解
09-02
主要为大家详细介绍了Java线程间的通信方式，以代码结合文字的方式来讨论线程间的通信，感兴趣的朋友可以参考一下
java线程通信的几种方式_Java实现线程通信的几种方式
weixin_31653131的博客
02-12 338
本文共总结了5种方式，通过代码举例的方式进行展示。5种方式为：synchronized加wait/notify方式、ReentrantLock加Condition方式、闭锁的方式、栅栏的方式、信号量的方式。最后还介绍了join和yield的使用。1、synchronized加wait/notify方式/*** wait和notify的使用* wait和notify必须应用在synchronized...
Java中的线程通信详解
最新发布
weixin_42303107的博客
07-14 252
Java中的线程通信详解 大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！ 在多线程编程中，线程之间的通信是一个重要且复杂的主题。为了确保多线程程序的正确性和效率，线程需要能够互相通信并协调工作。Java 提供了多种方式来实现线程间的通信，如 wait()、notify()、notifyAll...
Java线程通信的几种方式
Admans的专栏
06-29 4532
有两个线程，A 线程向一个集合里面依次添加元素“abc”字符串，一共添加十次，当添加到第五次的时候，希望 B 线程能够收到 A 线程的通知，然后 B 线程执行相关的业务操作。线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。基于 volatile 关键字来实现线程间相互通信是使用共享内存的思想。大致意思就是多个线程同时监听一个变量，当这个变量发生变化的时候 ，线程能够感知并执行相应的业务。这也是最简单的一种实现方式 Object 类提供了线程间通信的方法：wait()、no
java线程间通讯的几种方式
成都彭于晏
02-04 6014
并发编程中，我们可能会遇到这样一个场景 A、B两个线程并行，但是我希望保证B线程在A线程执行完了后再执行 这个时候就需要线程间进行通讯 A执行完了后对B说一声，喂B，我执行完了 来康康用Java怎么实现 1、基于synchronized 2、基于reentrantLock 3、基于volatile 4、基于countDownLatch 我目前就知道这四种 1、synchronized+wait() 和 notify() wait() 和 notify()都是Object类的通讯方法，注意一点，wai
【Java进阶】Java线程间通讯的几种方式
热门推荐
不积跬步无以至千里，不积小流无以成江海。一个喜欢学习分享的程序员
11-06 2万+
一、使用同一个共享变量控制 Synchronized、wait、notifyLock、Condition利用volatile利用AtomicInteger二、PipedInputStream、PipedOutputStream 三、利用BlockingQueue
java 多线程的几种实现方法总结
08-29
Java 多线程的几种实现方法总结 Java 多线程是指在同一个程序中可以有多条执行线索同时执行，每个线程上都关联有要执行的代码，即可以有多段程序代码同时运行。为了帮助大家更好地理解和掌握 Java 多线程的知识，...
深入理解java线程通信
08-25
Java 线程通信有多种实现方式，以下是一些常见的实现方式： 1. 等待通知机制：通过调用 wait() 和 notify() 方法来实现线程通信。 2. 使用阻塞队列：使用阻塞队列可以使得线程之间能够相互通信。 3. 使用 volatile ...
Java.线程通信方式介绍
star_611的博客
01-03 346
Java.线程通信方式介绍
Java多线程之间几种通信方式
qq_321944105的博客
07-30 768
前言 本篇文章主要介绍Java基础多线程之间通信的一些玩法，并结合一些面试题来实践的 1.基于synchronized和java类锁的wait()和notify() 这是一道面试题，让字母和数字交叉打印（第一种） /** * @author wanghp * @version 1.0 * @date 2020/6/25 23:03 * Thread.sleep与Object.wait区别 * Thread.sleep需要指定休眠时间，时间一到可继续运行；和锁机制无关，没有加锁也不用释放锁 *
Java线程之间通信方式
赵广陆
09-09 2128
目录 1 线程之间的通信方式主要有以下几种 2 共享变量 3 锁机制 4 条件变量 5 信号量 6 管道 6 join方法的实现原理 7 join方法实现顺序性原理 1 线程之间的通信方式主要有以下几种 在实际开发时，一个进程中往往有很多个线程，大多数线程之间往往不是绝对独立的，比如说我们需要将A和B 两个线程的执行结果收集在一起然后显示在界面上，又或者比较典型的消费者-生产者模式，在这些场景下，线程间通信成了我们必须使用的手段，那么线程之间怎么通信呢？
【Java多线程】你知道实现Java线程间通信有多少种方法吗？
aaa_hao的博客
03-24 4244
文章目录1. 锁与同步2. 等待/通知机制3. 信号量4. 管道5. 其它通信相关5.1 join() 方法5.2 sleep() 方法sleep() 与 wait() 的区别5.3 ThreadLocal 类5.4 InheritableThreadLocal 合理地使用 Java 多线程可以更好地利用服务器资源。一般来讲，线程内部有自己私有的线程上下文，互不干扰。但是当我们需要多个线程之间相互协作的时候，就需要掌握 Java 线程的通信方式。下文将介绍 Java 线程之间的几种通信机制和原理。 1. 锁
Java中的线程通信的几种方式
u013749113的博客
05-17 1569
Java中提供了多种方式来实现线程间通信，其中最常见的方式包括synchronized关键字、wait()和notify()方法、CountDownLatch类、Semaphore类和BlockingQueue类。这些方式都可以用来实现线程之间的互斥、同步、数据共享和通信。选择哪种方式取决于具体的应用场景和需求。在使用这些方式时，需要注意线程安全和死锁等问题，以确保程序的正确性和健壮性。
Java线程之间如何通信的，有哪些方式？
Ascend1977的博客
05-29 5983
尽可能避免共享变量，因为共享变量容易引起线程安全问题。对共享变量的访问需要加锁，以保证同步访问。避免死锁问题的发生。使用锁时需要特别注意加锁和释放锁的顺序。使用条件变量时，应该确保线程在调用 await() 方法之前已经获取了锁。否则，在等待条件成立的过程中，其他线程可能会修改共享资源，导致程序出现错误。 在使用信号量时，需要正确设置信号量的个数和调用 acquire() 和 release() 方法的顺序，否则可能会出现线程阻塞或信号量无法释放的情况。管道的使用需要注意线程之间的数据传输方式，以及缓冲区的
Java线程间的通信方式
Wdradon的博客
06-27 5353
**定义：**当多个线程共同操作共享的资源时，线程间通过某种方式互相告知自己的状态，以避免无效的资源争夺。通信的方式：**线程同步：**即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作， 其他线程才能对该内存地址进行操作。同步的话，仅仅传递的是控制信息，就是我什么时候运行结束，你什么时候可以来。对于线程间通信来说，线程间同步可以归纳为线程间通信的一个子集，对于线程通信指的是两个线程之间可以交换一些实时的数据信息，而线程同步只交换一些控制信息。在java中有几个关于
Java多线程之间的通信方式
weixin_49698553的博客
07-06 3300
在Java中线程通信主要有以下三种方式：如果线程之间采用synchronized来保证线程安全，则可以利用wait()、notify()、notifyAll()来实现线程通信。这三个方法都不是Thread类中所声明的方法，而是Object类中声明的方法。原因是每个对象都拥有锁，所以让当前线程等待某个对象的锁，当然应该通过这个对象来操作。并且因为当前线程可能会等待多个线程的锁，如果通过线程来操作，就非常复杂了。另外，这三个方法都是本地方法，并且被final修饰，无法被重写。wait()方法可以让当前线程释放对
Java实现线程通信：生产者消费者问题源码解析
该程序利用了线程通信的概念，主要依赖于`wait()`和`notify()`方法来同步线程操作。" 在这个Java程序中，生产者-消费者问题是通过多线程来解决的，涉及到以下几个关键知识点： 1. **线程同步**：在`Clerk`类中，`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值