线程之间的通信方式

最新推荐文章于 2024-03-11 17:46:53 发布
最新推荐文章于 2024-03-11 17:46:53 发布
阅读量3w 收藏 18
点赞数 24
分类专栏： 多线程并发 线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Leonardo9029/article/details/51276341
版权

前言
说到线程之间通信方式：依据我的理解 主要是有两种吧
1.是通过共享变量，线程之间通过该变量进行协作通信；
2.通过队列（本质上也是线程间共享同一块内存）来实现消费者和生产者的模式来进行通信；

1.通过线程之间共享变量的方式

  • 这个就有必要说下 wait(),notify(),以及notifyAll() 这三个方法

    • 这三个方法都是属于Object的方法；所以所有类都可以继承这三方法；
      • wait()方法使得当前线程必须要等待，等到另外一个线程调用notify()或者notifyAll()方法。
      • notify()方法会唤醒一个等待当前对象的锁的线程。而notifyAll(）顾名思义；就是唤醒所有在等待中的方法；
      • wait()和notify()方法要求在调用时线程已经获得了对象的锁，因此对这两个方法的调用需要放在synchronized方法或synchronized块中。

  • 来看下下面这个实例吧
    -通过wait() 和notifyAll() 来实现多个线程之间加减的demo

package com.zeng.awaitNotify;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
/**
 * 通过共享一个变量，wait()+notify() 来践行通信
 * wait()和notify()方法要求在调用时线程已经获得了对象的锁，因此对这两个方法的调用需要放在synchronized方法或synchronized块中。
 *  
 * 针对两个线程的时候  没有问题
 * 针对线程一多的时候， 就必须要用notifyAll()
 * @author leo-zeng
 *  */
public class NumberHolder {

    private int number;

    public synchronized void increase(){
        while(number !=0){
            try {
                //若是nuber 不为0 时 等待
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //能执行到这里，说明 已经被唤醒了,并且为0
        number ++;
        System.out.println("我要递增:"+number);
        //通知在等待的线程
        notifyAll();
    }

    public synchronized void decrease(){
        while(number ==0){
            try {
                //若是等于零的时候  等待唤醒
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        //能执行到这里，说明 已经被唤醒了,并且不为0
        number --;
        System.out.println("我要递减:"+number);
        notifyAll();
    }
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(10);

        NumberHolder holder  =new NumberHolder();

        //执行任务
        pool.execute(new IncreaseThread(holder));
        pool.execute(new DecreaseThread(holder));

        pool.execute(new IncreaseThread(holder));
        pool.execute(new DecreaseThread(holder));

        pool.shutdown();
        try {
            pool.awaitTermination(300,TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
/**
 * 累加的类
 * @author leo
 *  */
class IncreaseThread extends Thread{

    private NumberHolder numberHolder;

    public IncreaseThread(NumberHolder numberHolder) {
        this.numberHolder =numberHolder;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            //每次都有不多的延迟
            try {
                Thread.sleep((long)Math.random()*1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //执行新增操作
            numberHolder.increase();
        }
    }
}
class DecreaseThread extends Thread{

    private NumberHolder holder;

    public DecreaseThread(NumberHolder holder){
        this.holder =holder;
    }
    @Override
    public void run() {
        for (int i = 0; i <20; i++) {
            //每次都有不多的延迟
            try {
                Thread.sleep((long)Math.random()*1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //执行递减函数
            holder.decrease();
        }
    }
}

注意一点：这里用while 不用 if 是因为保证可能多线程中，杜绝可能累加/递减会进行多次的可能。

  • 使用lock.newCondition().await() 和 signal() 方法实现线程之间交互
    • 除了上述在synchronized代码块中使用 wait和 notify之外呢，其实在在java.util.concurrent包中，有两个很特殊的工具类，Condition和ReentrantLock,也可以同样实现线程间的交互协作。
      • ReentrantLock（重入锁）和Condition 我在这里不想细说，有兴趣的可以去看些jdk源码。
      • 这里要介绍一下condition中的await()和signal() 方法；
        我们这边先看demo 然后再来解释这两个的含义：
package com.zeng.awaitNotify;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 通过共享变量来实现
 * @author leo-zeng
 *
 */
public class Resource {

    private int i;

    private final ReentrantLock lock = new ReentrantLock();

    private final Condition condition =lock.newCondition();

    public void incr(){
        try {
            //上锁
            lock.lock();
            while(i!=0){
                //叫停，等待唤醒的信号
                condition.await();
            }
            //说明已经得到可以用的信号
            i++;
            System.out.println( "递增:"+i);
            //给其他添加信号
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally{
            //解锁
            lock.unlock();
        }
    }

    public void decr(){
        try {
            //上锁
            lock.lock();
            while(i==0){
                //叫停， 等待递增那边的信号
                condition.await();
            }
            //i !=0  拿到那边的信号
            i--;
            System.out.println( "递减:"+i);
            //给其他添加信号
            condition.signalAll();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally{
            //解锁
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        ExecutorService threadPool = Executors.newFixedThreadPool(10);
        Resource ss = new Resource();

        threadPool.submit(new IncrThread(ss));
        threadPool.submit(new DecrThread(ss));
        threadPool.submit(new IncrThread(ss));
        threadPool.submit(new DecrThread(ss));
        threadPool.shutdown();
        try {
            threadPool.awaitTermination(300,TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}
class IncrThread extends Thread{
    private Resource resource;

    public IncrThread(Resource resource) {
        this.resource = resource;
    }

    @Override
    public void run() {
        for (int i = 0; i <20; i++) {
            //每次停顿一秒
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            resource.incr();
        }
    }
}

class DecrThread extends Thread{
    private Resource resource;

    public DecrThread(Resource resource) {
        this.resource = resource;
    }

    @Override
    public void run() {
        for (int i = 0; i <20; i++) {
            //每次停顿一秒
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            resource.decr();
        }
    }
}

从demo中可以看到await()方法，是要先给A（累加）线程加锁，进入await之后会让线程沉睡，等待signal信号来叫醒，这是A线程解锁后会进入沉睡，运行B线程；b线程先加锁然后进行递减，当值为0值也会进行也会睡眠的，然后解锁，把锁给A。就这样来进行通信的。

2.通过队列来实现线程的通信

  • 这里用的是java.util.concurrent包中linkedBlockingQueue 来进行线程间交互；
    • java.util.concurrent.LinkedBlockingQueue 是一个基于单向链表的、范围任意的（其实是有界的）、FIFO 阻塞队列。访问与移除操作是在队头进行，添加操作是在队尾进行，并分别使用不同的锁进行保护，只有在可能涉及多个节点的操作才同时对两个锁进行加锁。
    • 这里通过共享一个队列的信息，实现生产者和消费者
package com.zeng.awaitNotify;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
/**
 * 通过linkedblockingQueue 构建线程间通信
 * @author leo-zeng
 *
 */
public class LinkedBlockingQueueTest {
    public static void main(String[] args) {
        LinkedBlockingQueue<String> queue = new LinkedBlockingQueue<String>();
        ExecutorService threadPool = Executors.newFixedThreadPool(10);
        threadPool.execute(new Producer(queue));
        threadPool.execute(new Consumer(queue));


        if(!threadPool.isShutdown()){
            threadPool.shutdown();
            try {
                threadPool.awaitTermination(300, TimeUnit.SECONDS);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }


    }
}
class Producer extends Thread{
    private LinkedBlockingQueue<String> queue;

    public Producer(LinkedBlockingQueue<String> queue) {
        this.queue =queue;
    }

    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("生产出:"+i);
            try {
                Thread.sleep(100);
                queue.put(new String("producer:"+i));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class Consumer extends Thread{
    private LinkedBlockingQueue<?> queue;

    public Consumer(LinkedBlockingQueue<String> q) {
        this.queue =q;
    }
    @Override
    public void run() {
        while(true){
            try {
                System.out.println("consumer 消费了:"+queue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

参考资料：

1.http://www.cnblogs.com/mengdd/archive/2013/02/20/2917956.html
2.http://ifeve.com/understand-condition/
3.http://ifeve.com/juc-linkedblockingqueue/

leo-zeng
关注
  • 24
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入理解JAVA多线程之线程间的通信方式
09-02
下面小编就为大家带来一篇深入理解JAVA多线程之线程间的通信方式。小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
线程间通信方式3：消息传递方式
01-18
线程间通信方式3：消息传递方式的演示。采用计算演示线程的执行，并采用用户界面线程来实时显示执行的进度，线程间的通信方式采用了3种方式相结合，对多线程间的通信有比较好的学习和研究价值。
多线程awaitTermination和shutdown的使用问题
Abners的专栏
12-18 2万+
最近做一个抓取网页的任务，由于需要抓取的数据量比较大，并且抓取的间隔比较短，每次抓取任务启动后会有多次网络请求，为了提高抓取的效率采用了多线程的方式实现：    初始时采用了上图的实现方式，其中CORE_POOL_SIZE为10，max_pool_size为16，采用此方法启动后发现程序一直处于运行状态，无法结束，通过jdk自带的工具JVM查看程序的执行状态后发现，此时所有线程都处于a
java 等待线程池结束_如何等待java线程池中所有任务完成
weixin_39943202的博客
02-16 5414
一、等待线程池所有线程完成：有时候我们需要等待java thread pool中所有任务完成后再做某些操作，如想要等待所有任务完成，仅需调用threadPool.awaitTermination()方法即可，请查看如下代码：ExecutorService threadPool = Executors.newFixedThreadPool(ConfigUtil.ACCESSDB_THREAD_POO...
线程通信的几种方式
最新发布
qq_35878964的博客
03-11 393
本文引自 https://blog.csdn.net/ChineseSoftware/article/details/118390388 ，为加深记忆，特此激励。
awaitTermination 使用注意
weixin_33743248的博客
08-31 3413
2019独角兽企业重金招聘Python工程师标准>>> ...
awaitTermination配和shutdown使用实例
Fergusonf的博客
09-21 907
awaitTermination()配和shutdown()使用实例
利用多线程线程池完成任务
yeqingyun2012的博客
04-18 219
Map aa =.....;//全局变量          //并发量设置为10，超过10要排队          ExecutorService pool = Executors.newFixedThreadPool(10);          Callable callable = new Callable() {                 public String call(
Java线程间的通信方式详解
09-02
主要为大家详细介绍了Java线程间的通信方式，以代码结合文字的方式来讨论线程间的通信，感兴趣的朋友可以参考一下
线程的几种控制方式以及线程间的几种通信方式
10-29
关于线程的几种控制方式以及线程中的几种通信方式，给初学者参考，希望能有用
线程间通信方式2：参数传递方式
01-11
线程间通信方式2：参数传递方式。通过3类线程的创建方法，演示了给线程传递方式的方式，包括;单参数、多参数和类3类。
如何优雅的使用和理解线程池
weixin_33778778的博客
07-30 335
2019独角兽企业重金招聘Python工程师标准>>> ...
【多线程】Java ThreadPoolExecutor的shutdown方法踩坑和源码阅读
dkz97的博客
07-13 1758
java,多线程,shutdown,shutdownnow
Java7 ForkJoinPool 的使用以及原理
luckykapok918的专栏
05-26 928
在JDK7中新增了ForkJoinPool。ForkJoinPool采用分治+work-stealing的思想。可以让我们很方便地将一个大任务拆散成小任务，并行地执行，提高CPU的使用率。 ForkJoinPool & ForkJoinTask 概述： ForkJoinTask：我们要使用 ForkJoin 框架，必须首先创建一个 ForkJoin 任务。它提供在任务中执行 fork() 和 join() 操作的机制，通常情况下我们不需要直接继承 ForkJoinTask 类，而只需要继承它的子
关于java线程池<三>
暴走的比特流
06-13 623
2013/06/13 这篇文章主要是翻译了一部分jdk自带线程池的API。本来是不想翻译的，结果发现上周看完以后，过了个端午，玩了三天回来发现有些细节又忘记了。。想来想去，决定还是翻译一遍，英语水平有限。。剩下的你懂的。。 我是这么计划的，从上层接口开始一层一层往下。开始工作： 先发一张这篇打算翻译的接口及类的定义的层级关系 1.java.u
线程池简单使用
qq_29653373的博客
08-26 347
一、业务场景：推送订单数据到第三方平台，失败的记录到rides中，并尝试重复推送（时间延迟递增）5次 二、简单的代码实现： package cn.morik.ufm.common.utils; import java.util.concurrent.*; import java.util.concurrent.atomic.AtomicInteger; public class MyThreadPoolExecutor implements Runnable { AtomicInteger
《操作系统》第四章习题加解析
qq_57531804的博客
03-29 5794
《操作系统》习题
操作系统—王道考研之进程管理
weixin_60257072的博客
02-03 944
程序：一组计算机能识别和执行的指令。是静态的，就是个存放在磁盘里的可执行文件，如：QQ.exe。早期的计算机只支持单道异步性会导致并发程序执行结果的不确定性进程在操作系统中的组织使各个进程能够有序的进行切换和运行图中我们可以知道什么是进程通信，以及进程通信的低级和高级方式；我们还可以知道为什么要引入进程通信方式，以及它的意义前面我们了解了引入线程的好处和引入线程的变化，以及线程的属性，那么线程如何实现呢？用户级线程(User-Level Thread，UTL)和内核级线程内核级线程又称。
threadPoolExecutor 中的 shutdown() 、 shutdownNow() 、 awaitTermination() 的用法和区别
热门推荐
Cuber_Q's blogs
10-11 4万+
最近在看并发编程，在使用到ThreadPoolExecutor时，对它的三个关闭方法（shutdown()、shutdownNow()、awaitTermination()）产生了兴趣，同时又感到迷惑。查了些资料，自己写了测试代码，总算有了个比较清晰的认识。下面一
freertos线程间通信方式
08-13
在 FreeRTOS 中，线程间通信可以通过以下几种方式实现： ...以上是 FreeRTOS 中常用的线程间通信方式，具体使用哪种方式取决于你的需求和设计。希望能对你有所帮助！如果还有其他问题，请随时提问。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值