线程间的几种通信方式

最新推荐文章于 2024-01-12 18:59:05 发布
最新推荐文章于 2024-01-12 18:59:05 发布
阅读量345 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/crystal_hhj/article/details/119357125
版权

短线程间的通信有两种模型：消息传递和内存共享，基本上的实现通信的方式都是基于这两种模型实现的

一、使用volatile关键字

基于 volatile 关键字来实现线程间相互通信是使用共享内存的思想，大致意思就是多个线程同时监听一个变量，当这个变量发生变化的时候 ，线程能够感知并执行相应的业务。这也是最简单的一种实现方式

public class TestSync {
	// 定义一个共享变量来实现通信，它需要是volatile修饰，否则线程不能及时感知
	public volatile static boolean listen=false;
	public static void main(String[] args) {
		List<Integer> tmp=new ArrayList<Integer>();
		Thread th1=new Thread(()->{
			for(int i=0;i<10;i++) {
				tmp.add(i);
				System.out.println("线程1向数组中添加一个元素，此时数组的长度为："+tmp.size());
				try {
	//线程A每次执行间隔500毫秒
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				if(i==5) {
					listen=true;
				}
			}
		});
		Thread th2=new Thread(()->{
			while(true) {
				if(listen) {
					System.out.println("线程1收到通知，开始执行");
					break;
				}
			}
		});
//须先启动线程2
		th2.start();
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
//再启动线程2
		th1.start();
	}

其执行结果为：

线程1向数组中添加一个元素，此时数组的长度为：1
线程1向数组中添加一个元素，此时数组的长度为：2
线程1向数组中添加一个元素，此时数组的长度为：3
线程1向数组中添加一个元素，此时数组的长度为：4
线程1向数组中添加一个元素，此时数组的长度为：5
线程1向数组中添加一个元素，此时数组的长度为：6
线程1向数组中添加一个元素，此时数组的长度为：7
线程1收到通知，开始执行
线程1向数组中添加一个元素，此时数组的长度为：8
线程1向数组中添加一个元素，此时数组的长度为：9
线程1向数组中添加一个元素，此时数组的长度为：10

二、使用Object类的wait() 和 notify() 方法
 众所周知，Object类提供了线程间通信的方法：wait()、notify()、notifyaAl()，它们是多线程通信的基础，而这种实现方式的思想自然是线程间通信。要注意的是wait和 notify必须配合synchronized使用，wait方法释放锁，notify方法不释放锁

public class TestSync {
	// 定义一个共享变量来实现通信，它需要是volatile修饰，否则线程不能及时感知
//	public volatile static boolean listen=false;
	public static void main(String[] args) {
		Object lock=new Object();
		List<Integer> tmp=new ArrayList<Integer>();
		Thread th1=new Thread(()->{
			synchronized (lock) {
				for(int i=0;i<10;i++) {
				tmp.add(i);
				System.out.println("线程1向数组中添加一个元素，此时数组的长度为："+tmp.size());
				try {
	//线程A每次执行间隔500毫秒
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
//				if(i==5) {
//					listen=true;
//				}
				if(i==5) {
					lock.notify();//唤醒线程2
				}
			}
		 }
			
		});
		Thread th2=new Thread(()->{
			while(true) {
//				if(listen) {
//					System.out.println("线程1收到通知，开始执行");
//					break;
//				}
				synchronized (lock) {
                    if (tmp.size() != 5) {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println("线程B收到通知，开始执行自己的业务...");
                }

			}
		});
		th2.start();
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		th1.start();
	}

}

其打印结果为：

线程1向数组中添加一个元素，此时数组的长度为：1
线程1向数组中添加一个元素，此时数组的长度为：2
线程1向数组中添加一个元素，此时数组的长度为：3
线程1向数组中添加一个元素，此时数组的长度为：4
线程1向数组中添加一个元素，此时数组的长度为：5
线程1向数组中添加一个元素，此时数组的长度为：6
线程1向数组中添加一个元素，此时数组的长度为：7
线程1向数组中添加一个元素，此时数组的长度为：8
线程1向数组中添加一个元素，此时数组的长度为：9
线程1向数组中添加一个元素，此时数组的长度为：10
线程B收到通知，开始执行自己的业务...
从这个打印结果中可以看出在线程1发出notify()唤醒线程2后，仍旧是走完了自己的线程业务，才执行线程2，这也正好说明了notify方法不释放锁，wait方法才释放锁。

三、使用JUC工具类 CountDownLatch

jdk1.5之后在java.util.concurrent包下提供了很多并发编程相关的工具类，简化了我们的并发编程代码的书写，***CountDownLatch***基于AQS框架，相当于也是维护了一个线程间共享变量state

public class TestSync {
	// 定义一个共享变量来实现通信，它需要是volatile修饰，否则线程不能及时感知
//	public volatile static boolean listen=false;
	public static void main(String[] args) {
//		Object lock=new Object();
		CountDownLatch countDownLatch = new CountDownLatch(1);
		List<Integer> tmp=new ArrayList<Integer>();
		Thread th1=new Thread(()->{
//			synchronized (lock) {
				for(int i=0;i<10;i++) {
				tmp.add(i);
				System.out.println("线程1向数组中添加一个元素，此时数组的长度为："+tmp.size());
				try {
	//线程A每次执行间隔500毫秒
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
//				if(i==5) {
//					listen=true;
//				}
//				if(i==5) {
//					lock.notify();//唤醒线程2
//				}
				if(tmp.size()==5) {
					countDownLatch.countDown();
				}
			}
//		 }
			
		});
		Thread th2=new Thread(()->{
			while(true) {
//				if(listen) {
//					System.out.println("线程1收到通知，开始执行");
//					break;
//				}
//				synchronized (lock) {
                    if (tmp.size() != 5) {
                        try {
                        	 countDownLatch.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println("线程B收到通知，开始执行自己的业务...");
                    break;
                }

//			}
		});
		th2.start();
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		th1.start();
	}

}

 其执行结果为：

线程1向数组中添加一个元素，此时数组的长度为：1
线程1向数组中添加一个元素，此时数组的长度为：2
线程1向数组中添加一个元素，此时数组的长度为：3
线程1向数组中添加一个元素，此时数组的长度为：4
线程1向数组中添加一个元素，此时数组的长度为：5
线程1向数组中添加一个元素，此时数组的长度为：6
线程B收到通知，开始执行自己的业务...
线程1向数组中添加一个元素，此时数组的长度为：7
线程1向数组中添加一个元素，此时数组的长度为：8
线程1向数组中添加一个元素，此时数组的长度为：9
线程1向数组中添加一个元素，此时数组的长度为：10
 

四、使用 ReentrantLock 结合 Condition



import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class TestSync {
	// 定义一个共享变量来实现通信，它需要是volatile修饰，否则线程不能及时感知
//	public volatile static boolean listen=false;
	public static void main(String[] args) {
//		Object lock=new Object();
//		CountDownLatch countDownLatch = new CountDownLatch(1);
		
		ReentrantLock lock = new ReentrantLock();
        Condition condition = lock.newCondition();
		List<Integer> tmp=new ArrayList<Integer>();
		Thread th1=new Thread(()->{
			lock.lock();
//			synchronized (lock) {
				for(int i=0;i<10;i++) {
				tmp.add(i);
				System.out.println("线程1向数组中添加一个元素，此时数组的长度为："+tmp.size());
				try {
	//线程A每次执行间隔500毫秒
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
//				if(i==5) {
//					listen=true;
//				}
//				if(i==5) {
//					lock.notify();//唤醒线程2
//				}
//				if(tmp.size()==5) {
//					countDownLatch.countDown();
//				}
				if(tmp.size()==5) {
					condition.signal();
				}
			}
				lock.unlock();
//		 }
			
		});
		Thread th2=new Thread(()->{
//			while(true) {
//				if(listen) {
//					System.out.println("线程1收到通知，开始执行");
//					break;
//				}
//				synchronized (lock) {
			lock.lock();
                    if (tmp.size() != 5) {
                        try {
//                        	 countDownLatch.await();
                        	condition.await();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println("线程B收到通知，开始执行自己的业务...");
//                    break;
                    lock.unlock();
//                }

//			}
		});
		th2.start();
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		th1.start();
	}

}

 其执行结果为：

线程1向数组中添加一个元素，此时数组的长度为：1
线程1向数组中添加一个元素，此时数组的长度为：2
线程1向数组中添加一个元素，此时数组的长度为：3
线程1向数组中添加一个元素，此时数组的长度为：4
线程1向数组中添加一个元素，此时数组的长度为：5
线程1向数组中添加一个元素，此时数组的长度为：6
线程1向数组中添加一个元素，此时数组的长度为：7
线程1向数组中添加一个元素，此时数组的长度为：8
线程1向数组中添加一个元素，此时数组的长度为：9
线程1向数组中添加一个元素，此时数组的长度为：10
线程B收到通知，开始执行自己的业务...

显然这种方式使用起来并不是很好，代码编写复杂，而且线程2在被1唤醒之后由于没有获取锁还是不能立即执行，也就是说，A在唤醒操作之后，并不释放锁。这种方法跟 Object 的 wait() 和 notify() 一样。

五、基本LockSupport实现线程间的阻塞和唤醒

LockSupport 是一种非常灵活的实现线程间阻塞和唤醒的工具，使用它不用关注是等待线程先进行还是唤醒线程先运行，但是得知道线程的名字。



import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.LockSupport;
import java.util.concurrent.locks.ReentrantLock;

public class TestSync {
	// 定义一个共享变量来实现通信，它需要是volatile修饰，否则线程不能及时感知
//	public volatile static boolean listen=false;
	public static void main(String[] args) {
//		Object lock=new Object();
//		CountDownLatch countDownLatch = new CountDownLatch(1);
		
//		ReentrantLock lock = new ReentrantLock();
//        Condition condition = lock.newCondition();
		List<Integer> tmp=new ArrayList<Integer>();
		Thread th2=new Thread(()->{
//			while(true) {
//				if(listen) {
//					System.out.println("线程1收到通知，开始执行");
//					break;
//				}
//				synchronized (lock) {
//			lock.lock();
                    if (tmp.size() != 5) {
                    	LockSupport.park();
//                        try {
//                        	 countDownLatch.await();
//                        	condition.await();
//                        } catch (InterruptedException e) {
//                            e.printStackTrace();
//                        }
                    }
                    System.out.println("线程B收到通知，开始执行自己的业务...");
//                    break;
//                    lock.unlock();
//                }

//			}
		});
		Thread th1=new Thread(()->{
//			lock.lock();
//			synchronized (lock) {
				for(int i=0;i<10;i++) {
				tmp.add(i);
				System.out.println("线程1向数组中添加一个元素，此时数组的长度为："+tmp.size());
				try {
	//线程A每次执行间隔500毫秒
					Thread.sleep(500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
//				if(i==5) {
//					listen=true;
//				}
//				if(i==5) {
//					lock.notify();//唤醒线程2
//				}
//				if(tmp.size()==5) {
//					countDownLatch.countDown();
//				}
//				if(tmp.size()==5) {
//					condition.signal();
//				}
				if(tmp.size()==5) {
					LockSupport.unpark(th2);
				}
			}
//				lock.unlock();
//		 }
			
		});
		
		th2.start();
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		th1.start();
	}

}

其执行结果为：

线程1向数组中添加一个元素，此时数组的长度为：1
线程1向数组中添加一个元素，此时数组的长度为：2
线程1向数组中添加一个元素，此时数组的长度为：3
线程1向数组中添加一个元素，此时数组的长度为：4
线程1向数组中添加一个元素，此时数组的长度为：5
线程1向数组中添加一个元素，此时数组的长度为：6
线程B收到通知，开始执行自己的业务...
线程1向数组中添加一个元素，此时数组的长度为：7
线程1向数组中添加一个元素，此时数组的长度为：8
线程1向数组中添加一个元素，此时数组的长度为：9
线程1向数组中添加一个元素，此时数组的长度为：10 

crystal_hhj
关注
线程间的通信
cbNotes的专栏：不积硅步，无以至千里;不积小流，无以成江海!
01-18 5万+
线程间的通信 1．线程之间的通信简介 一般而言,在一个应用程序中（即进程），一个线程往往不是孤立存在的，常常需要和其它线程通信，以执行特定的任务。如主线程和次线程，次线程与次线程，工作线程和用户界面线程等。这样,线程与线程间必定有一个信息传递的渠道。这种线程间的通信不但是难以避免的，而且在多线程编程中也是复杂和频繁的。线程间的通信涉及到4个问题： （1） 线程间如何传递信息 （2）  线程
【多线程间几种通信方式】
hanlin_zhao的博客
07-09 1719
java线程通信
看了这篇文章，就别担心线程间的通信了！
Simon郎的博客
05-07 3074
线程间的通信 1、为什么需要线程通信 线程是操作系统调度的最小单位，有自己的栈空间，可以按照既定的代码逐步的执行，但是如果每个线程间都孤立的运行，那就会造资源浪费。所以在现实中，我们需要这些线程间可以按照指定的规则共同完成一件任务，所以这些线程之间就需要互相协调，这个过程被称为线程的通信。 线程的通信可以被定义为： 线程通信就是当多个线程共同操作共享的资源时，互相告知自己的状态以避免资源争夺。 ...
线程间通信方式
swj2009的专栏
11-16 6445
<br />  线程间通信方式 收藏 <br />线程间通信可以通过下列三种方法： <br />1）使用全局变量实现线程间通信 <br />2）使用消息实现线程间通信 <br />3）使用CEvent类实现线程间通信  <br />使用全局变量实现线程间通信： <br />    定义一个全局变量，不同的线程间可以通过修改全局变量的值来进行通信。例如：定义一个控制线程的全局变量 <br />    volatile int  threadController; <br />当 threadControlle
线程之间是如何通信的？
最新发布
NZC2237的博客
01-12 3338
CountDownLatch`和`CyclicBarrier`是Java中的两个同步工具，它们可以用于线程之间的协调。在Java中，通过`Object`类的`wait()`和`notify()`方法，以及`notifyAll()`方法，可以实现线程之间的等待和唤醒操作。Java中的`ReentrantLock`和`Condition`接口提供了条件变量的实现。在Java中，`PipedInputStream`和`PipedOutputStream`提供了管道的实现。
线程之间通信的方法
if_i_were_a的博客
03-28 1908
线程之间通信的方法有四种: 1. 共享内存的方法 该方法有两种实现形式: synchronized和volatile 使用synchronized，多线程环境下会造成阻塞，如果有多个线程同时要对内存中的一个数据进行操作，那么他们都把内存中的值读到自己的工作内存中。使用synchronized修饰的haul同一时间只能有一个线程进行操作，对数据更新完之后重新刷新会主存，自动释放锁，然后下一个...
线程的几种控制方式以及线程间的几种通信方式
10-29
二、线程间的通信方式 1. **信号量（Semaphore）**：信号量用于限制同时访问特定资源的线程数量，Java和Python都有相应的实现。 2. **条件变量（Condition）**：条件变量允许线程在满足特定条件时进入等待状态，当...
Java线程间的通信方式详解
09-02
本文将详细介绍两种常见的Java线程通信方式：同步和while轮询。 1. 同步（Synchronized） 同步是Java中控制线程并发的一种手段，它通过`synchronized`关键字实现。在Java中，同步主要有两种形式：同步方法（通过在...
进程和线程的几种通信方式
weixin_40701758的博客
04-12 7121
进程之间通信的几种方式和线程之间的通信方式，以及Java中创建多线程的几种方式
python 线程通信的几种方式_Python 线程、线程通信、多线程
weixin_34193979的博客
02-09 1585
这是一篇学习Python 线程相关的内容，记录一下以备复习和开发使用，技术有限，如有问题欢迎指出，多谢。一.GIL 全局解释器锁(cpython)1.为什么会有这个锁：为了线程安全，减少python使用者的上手难度GIL 使得同一个时刻只有一个线程在一个cpu上执行字节码，无法隐射到多个cpu，多核上执行。2.特殊情况下会释放GIL：达到特定字节码行数、到底特定数目时间片、IO操作(主动)二：并发...
线程之间的通信方式
weixin_41979002的博客
08-02 6641
前言 我只是个搬运工，尊重原作者的劳动成果，本文来源下列文章链接： https://zhuanlan.zhihu.com/p/129374075 https://blog.csdn.net/jisuanji12306/article/details/86363390 线程之间为什么要通信？ 通信的目的是为了更好的协作，线程无论是交替式执行，还是接力式执行，都需要进行通信告知。首先，要短信线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。我们来基本一道面试常见的题目来分析： 题目
线程间通信的几种方式
热门推荐
pengzhisen123的博客
03-06 4万+
线程间的通信方式①同步这里讲的同步是指多个线程通过synchronized关键字这种方式来实现线程间的通信。参考示例：public class MyObject { synchronized public void methodA() { //do something.... } synchronized public void methodB() { ...
线程之间的几种通信方式
qq_44688861的博客
03-02 1万+
一、线程之间的几种通信方式 1、管道，是一种半双工方式，数据单方向流动，而且只能在有亲缘关系的线程之间使用。他是基于内核的，可以把它当作是内核缓冲区，在内核和用户空间交换数据需要进行四次的数据拷贝，因为他是把用户空间的数据拷贝到内核，然后从内核拷贝到内存，然后从内存再拷贝到内核，最后拷贝到用户空间，至于为什么要拷贝到内核，是因为数据最重都是在内存中执行的。接收的时候要按照次序，按照先进先出的原则，在管道中的数据只能被读取1次，读出之后缓冲区就不存在了。它只能承载没有格式的字节流 。 2、命名管道，和管道差不
线程间的通信方法
《好好先生》专栏
08-22 1万+
线程间的通信方法 1. 线程通信简介 一般而言，在一个应用程序（即进程）中，一个线程往往不是孤立存在的，常常需要和其它线程通信，以执行特定的任务。如主线程和次线程，次线程与次线程，工作线程和用户界面线程等。这样，线程与线程间必定有一个信息传递的渠道。这种线程间的通信不但是难以避免的，而且在多线程编程中也是复杂和频繁的。线程间的通信涉及到4个问题： 线程间如何传递信息； 线程之间如何同步，以...
线程间实现通信的几种方式
weixin_54046648的博客
12-04 3847
线程间通信的模型有两种：共享内存和消息传递，下面介绍的都是围绕这两个来实现有两个线程A和B，B线程向一个集合里面依次添加元素“abc”字符串，一共添加10次，当添加到第五次的时候，希望线程A能够收到线程B的通知，然后B线程执行相关的业务操作Object类提供了线程间通信的方法：wait()、notify()、notifyAll()，它们是多线程通信的基础，而这种实现方式的思想自然是线程间通信。 线程A要等待某个条件满足时(list.size()==5)，才执行操作。线程B则向list中添加元素，改变list
线程间的通讯
weixin_45926121的博客
07-01 1906
线程是操作系统调度的最小单位，有自己的栈空间，可以按照既定的代码逐步的执行，但是如果每个线程间都孤立的运行，那就会造资源浪费。所以在现实中，我们需要这些线程间可以按照指定的规则共同完成一件任务，所以这些线程之间就需要互相协调，这个过程被称为线程的通信。线程间的通讯定义：多个线程在操作同一份数据时，互相告知自己的状态，避免对同一共享变量的争夺。 线程通讯的方式主要可以分为三种方式，共享内存、消息传递和管道流。线程同步是线程之间按照⼀定的顺序执⾏，可以使⽤锁来实现达到线程同步，也就是在需要同步的代码块里加上关键
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值