线程间通信

最新推荐文章于 2024-08-22 22:18:22 发布
最新推荐文章于 2024-08-22 22:18:22 发布
阅读量254 收藏 1
点赞数

注意：

  • 必须在同步方法中使用wait和notify方法，因为执行wait和notify的前提条件是必须持有同步方法（或块）的monitor的所有权，否则将会抛出异常。
  • 同步代码的monitor必须与执行wait notify方法的对象一致，简单地说就是用哪个对象的monitor进行同步，就只能用哪个对象进行wait和notify操作。

1、单生产者单消费者模式

        顾名思义，就是一个线程消费，一个线程生产。我们先来看看等待/通知机制下的生产者消费者模式：我们假设这样一个场景，我们是卖北京烤鸭店铺，我们现在只有一条生产线也只有一条消费线，也就是说只能生产线程生产完了，再通知消费线程才能去卖，如果消费线程没烤鸭了，就必须通知生产线程去生产，此时消费线程进入等待状态。在这样的场景下，我们不仅要保证共享数据（烤鸭数量）的线程安全，而且还要保证烤鸭数量在消费之前必须有烤鸭。下面我们通过java代码来实现：

package com.zejian.test;

public class KaoYaResource {
	
	private String name;
	private int count = 1;//烤鸭的初始数量
	private boolean flag = false;//判断是否有需要线程等待的标志
	
	/**
	 * 生产烤鸭
	 */
	public synchronized void product(String name){
		if(flag){
			//此时有烤鸭，等待
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace()
;
			}
		}
		this.name=name+count;//设置烤鸭的名称
		count++;
		System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
		flag=true;//有烤鸭后改变标志
		notifyAll();//通知消费线程可以消费了
	}
	
	/**
	 * 消费烤鸭
	 */
	public synchronized void consume(){
		if(flag){//如果没有烤鸭就等待
			try{this.wait();}catch(InterruptedException e){}
		}
		System.out.println(Thread.currentThread().getName()+"...消费者........"+this.name);//消费烤鸭1
		flag = false;
		notifyAll();//通知生产者生产烤鸭
	}
}

在这个类中我们有两个synchronized的同步方法，一个是生产烤鸭的，一个是消费烤鸭的，之所以需要同步是因为我们操作了共享数据count，同时为了保证生产烤鸭后才能消费也就是生产一只烤鸭后才能消费一只烤鸭，我们使用了等待/通知机制，wait()和notify()。当第一次运行生产现场时调用生产的方法，此时有一只烤鸭，即flag=false，无需等待，因此我们设置可消费的烤鸭名称然后改变flag=true，同时通知消费线程可以消费烤鸭了，即使此时生产线程再次抢到执行权，因为flag=true，所以生产线程会进入等待阻塞状态，消费线程被唤醒后就进入消费方法，消费完成后，又改变标志flag=false，通知生产线程可以生产烤鸭了.........以此循环。

package com.zejian.test;
/**
 * @author zejian
 * @time 2016年3月12日 下午10:29:12
 * @decrition 单生产者单消费者模式
 */
public class Single_Producer_Consumer {
	
	public static void main(String[] args) 
	{
		KaoYaResource r = new KaoYaResource();
		Producer pro = new Producer(r);
		Consumer con = new Consumer(r);
		//生产者线程
		Thread t0 = new Thread(pro);
		//消费者线程
		Thread t2 = new Thread(con);
		//启动线程
		t0.start();
		t2.start();
	}
}
/**
 * @author zejian
 * @time 2016年3月12日 下午11:02:22
 * @decrition 生产者线程
 */
class Producer implements Runnable
{
	private KaoYaResource r;
	Producer(KaoYaResource r)
	{
		this.r = r;
	}
	public void run()
	{
		while(true)
		{
			r.product("北京烤鸭");
		}
	}
}
/**
 * @author zejian
 * @time 2016年3月12日 下午11:02:05
 * @decrition 消费者线程
 */
class Consumer implements Runnable
{
	private KaoYaResource r;
	Consumer(KaoYaResource r)
	{
		this.r = r;
	}
	public void run()
	{
		while(true)
		{
			r.consume();
		}
	}
}

在这个类中我们创建两个线程，一个是消费者线程，一个是生产者线程，我们分别开启这两个线程用于不断的生产消费，运行结果如下：

很显然的情况就是生产一只烤鸭然后就消费一只烤鸭。运行情况完全正常，嗯，这就是单生产者单消费者模式。上面使用的是synchronized关键字的方式实现的。

2、多生产者多消费者模式

        分析完了单生产者单消费者模式，我们再来聊聊多生产者多消费者模式，也就是多条生产线程配合多条消费线程。既然这样的话我们先把上面的代码Single_Producer_Consumer.java类修改成新类，大部分代码不变，仅新增2条线程去跑，一条t1的生产  共享资源类KaoYaResource不作更改，代码如下
 

package com.zejian.test;
/**
 * @author zejian
 * @time 2016年3月13日 上午10:35:05
 * @decrition 多生产者多消费者模式
 */
public class Mutil_Producer_Consumer {
	
	public static void main(String[] args) 
	{
		KaoYaResource r = new KaoYaResource();
		Mutil_Producer pro = new Mutil_Producer(r);
		Mutil_Consumer con = new Mutil_Consumer(r);
		//生产者线程
		Thread t0 = new Thread(pro);
		Thread t1 = new Thread(pro);
		//消费者线程
		Thread t2 = new Thread(con);
		Thread t3 = new Thread(con);
		//启动线程
		t0.start();
		t1.start();
		t2.start();
		t3.start();
	}
}
/**
 * @author zejian
 * @time 2016年3月12日 下午11:02:22
 * @decrition 生产者线程
 */
class Mutil_Producer implements Runnable
{
	private KaoYaResource r;
	Mutil_Producer(KaoYaResource r)
	{
		this.r = r;
	}
	public void run()
	{
		while(true)
		{
			r.product("北京烤鸭");
		}
	}
}
/**
 * @author zejian
 * @time 2016年3月12日 下午11:02:05
 * @decrition 消费者线程
 */
class Mutil_Consumer implements Runnable
{
	private KaoYaResource r;
	Mutil_Consumer(KaoYaResource r)
	{
		this.r = r;
	}
	public void run()
	{
		while(true)
		{
			r.consume();
		}
	}
}

就多了两条线程，我们运行代码看看，结果如下：

      共享数据count的获取方法都进行synchronized关键字同步了呀！那怎么还会出现数据混乱的现象啊？
      分析：确实，我们对共享数据也采用了同步措施，而且也应用了等待/通知机制，但是这样的措施只在单生产者单消费者的情况下才能正确应用，但从运行结果来看，我们之前的单生产者单消费者安全处理措施就不太适合多生产者多消费者的情况了。那么问题出在哪里？可以明确的告诉大家，肯定是在资源共享类，下面我们就来分析问题是如何出现，又该如何解决？直接上图！

解决后的资源代码如下只将if改为了while：

package com.zejian.test;
/**
 * @author zejian
 * @time 2016年3月12日 下午10:44:25
 * @decrition 烤鸭资源
 */
public class KaoYaResource {
	
	private String name;
	private int count = 1;//烤鸭的初始数量
	private boolean flag = false;//判断是否有需要线程等待的标志
	/**
	 * 生产烤鸭
	 */
	public synchronized void product(String name){
		while(flag){
			//此时有烤鸭，等待
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		this.name=name+count;//设置烤鸭的名称
		count++;
		System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);
		flag=true;//有烤鸭后改变标志
		notifyAll();//通知消费线程可以消费了
	}
	
	/**
	 * 消费烤鸭
	 */
	public synchronized void consume(){
		while(!flag){//如果没有烤鸭就等待
			try{this.wait();}catch(InterruptedException e){}
		}
		System.out.println(Thread.currentThread().getName()+"...消费者........"+this.name);//消费烤鸭1
		flag = false;
		notifyAll();//通知生产者生产烤鸭
	}
}

运行代码，结果如下：

到此，多消费者多生产者模式也完成，不过上面用的是synchronied关键字实现的，而锁对象的解决方法也一样将之前单消费者单生产者的资源类中的if判断改为while判断即可代码就不贴了哈。

3.线程死锁

现在我们再来讨论一下线程死锁问题，从上面的分析，我们知道锁是个非常有用的工具，运用的场景非常多，因为它使用起来非常简单，而且易于理解。但同时它也会带来一些不必要的麻烦，那就是可能会引起死锁，一旦产生死锁，就会造成系统功能不可用。我们先通过一个例子来分析，这个例子会引起死锁，使得线程t1和线程t2互相等待对方释放锁。
 

package com.zejian.test;
/**
 * @author zejian
 * @time 2016年3月13日 下午2:45:52
 * @decrition 死锁示例
 */
public class DeadLockDemo {
	
	private static String A="A";
	private static String B="B";
			
	public static void main(String[] args) {
		DeadLockDemo deadLock=new DeadLockDemo();
		while(true){
			deadLock.deadLock();
		}
	}
	
	private void deadLock(){
		Thread t1=new Thread(new Runnable(){
			@SuppressWarnings("static-access")
			@Override
			public void run() {
				synchronized (A) {
					try {
						Thread.currentThread().sleep(2000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				synchronized(B){
					System.out.println("1");
				}
			}
		});
		
		Thread t2 =new Thread(new Runnable() {	
			@Override
			public void run() {
				synchronized (B) {
					synchronized (A) {
						System.out.println("2");
					}
				}
			}
		});
		
		//启动线程
		t1.start();
		t2.start();
	}	
}

同步嵌套是产生死锁的常见情景，从上面的代码中我们可以看出，当t1线程拿到锁A后，睡眠2秒，此时线程t2刚好拿到了B锁，接着要获取A锁，但是此时A锁正好被t1线程持有，因此只能等待t1线程释放锁A，但遗憾的是在t1线程内又要求获取到B锁，而B锁此时又被t2线程持有，到此结果就是t1线程拿到了锁A同时在等待t2线程释放锁B，而t2线程获取到了锁B也同时在等待t1线程释放锁A，彼此等待也就造成了线程死锁问题。虽然我们现实中一般不会向上面那么写出那样的代码，但是有些更为复杂的场景中，我们可能会遇到这样的问题，比如t1拿了锁之后，因为一些异常情况没有释放锁（死循环），也可能t1拿到一个数据库锁，释放锁的时候抛出了异常，没有释放等等，所以我们应该在写代码的时候多考虑死锁的情况，这样才能有效预防死锁程序的出现。下面我们介绍一下避免死锁的几个常见方法：

  • 1.避免一个线程同时获取多个锁。
  • 2.避免在一个资源内占用多个 资源，尽量保证每个锁只占用一个资源。
  • 3.尝试使用定时锁，使用tryLock(timeout)来代替使用内部锁机制。
  • 4.对于数据库锁，加锁和解锁必须在一个数据库连接里，否则会出现解锁失败的情况。
  • 5.避免同步嵌套的发生
     

转载：

https://blog.csdn.net/javazejian/article/details/50878665

天青色的烟雨.
关注
MFC线程间通信
04-05
然而，当一个应用程序中有多个线程运行时，它们可能需要共享数据或协调工作，这就涉及到线程间通信（Inter-Thread Communication，简称ITC）。MFC（Microsoft Foundation Classes）库，作为Windows平台上C++开发的...
线程通信的四种方式
热门推荐
weixin_43786099的博客
11-10 2万+
多个线程在并发执行的时候，他们在CPU中是随机切换执行的，这个时候我们想多个线程一起来完成一件任务，这个时候我们就需要线程之间的通信了，多个线程一起来完成一个任务，线程通信一般有4种方式： 通过 volatile 关键字 通过 Object类的 wait/notify 方法 通过 condition 的 await/signal 方法 通过 join 的方式 现在有一个问题，两个线程分别打印字符串，但是当线程A每输出两次的时候，线程B就输出一次，如此反复10次。 通过 volatile 关键字 通过
线程间的通讯
weixin_46060794的博客
08-08 2889
一.为什么需要线程通讯 线程是操作系统调度的最小单位，有自己的栈空间，可以按照既定的代码逐步的执行，但是如果每个线程间都孤立的运行，那就会造资源浪费。所以在现实中，我们需要这些线程间可以按照指定的规则共同完成一件任务，所以这些线程之间就需要互相协调，这个过程被称为线程的通信。 线程间的通讯定义：多个线程在操作同一份数据时，互相告知自己的状态，避免对同一共享变量的争夺。 二.线程间的通讯方式 线程通讯的方式主要可以分为三种方式，共享内存、消息传递和管道流。 1.共享内存 （1）...
线程间的通信
最新发布
m0_68082638的博客
08-22 1155
当多个线程共同操作共享资源时,线程间通过某种方式互相告知自己的状态,以免无效的资源争夺.
线程间通讯（几种常见的通讯机制，以及实例）
bigger_belief的博客
07-18 8493
介绍线程间通讯的几种方式，以及一些实例
线程之间的通信方式
weixin_41979002的博客
08-02 6666
前言 我只是个搬运工，尊重原作者的劳动成果，本文来源下列文章链接： https://zhuanlan.zhihu.com/p/129374075 https://blog.csdn.net/jisuanji12306/article/details/86363390 线程之间为什么要通信？ 通信的目的是为了更好的协作，线程无论是交替式执行，还是接力式执行，都需要进行通信告知。首先，要短信线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。我们来基本一道面试常见的题目来分析： 题目
Linux下多线程间通信
09-14
在Linux环境下，多线程间通信是实现并发执行任务并协调数据访问的关键技术。线程间的通信主要通过共享内存和同步机制来实现，因为线程天然具有共享数据结构的能力，这意味着全局变量可以在多个线程之间共享。然而，...
Python如何实现线程间通信
01-19
你的程序中有多个线程，你需要在这些线程之间安全地交换信息或数据 解决方案 从一个线程向另一个线程发送数据最安全的方式可能就是使用 queue 库中的队列了。创建一个被多个线程共享的 Queue 对象，这些线程通过使用...
1.10 第三章进程线程间通信
01-10
1.10 第三章进程线程间通信
java多线程编程学习(线程间通信)
08-29
Java 多线程编程学习（线程间通信） Java 多线程编程是指在 Java 中使用多个线程来执行不同的任务，以提高程序的执行效率和响应速度。线程间通信是多线程编程中非常重要的一个部分，通过线程间通信，多个线程可以...
线程之间是如何通信的？
NZC2237的博客
01-12 3490
CountDownLatch`和`CyclicBarrier`是Java中的两个同步工具，它们可以用于线程之间的协调。在Java中，通过`Object`类的`wait()`和`notify()`方法，以及`notifyAll()`方法，可以实现线程之间的等待和唤醒操作。Java中的`ReentrantLock`和`Condition`接口提供了条件变量的实现。在Java中，`PipedInputStream`和`PipedOutputStream`提供了管道的实现。
线程间通信的几种实现方式
木牛的博客
02-24 8243
线程间通信的几种实现方式 首先，要短信线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。我们来基本一道面试常见的题目来分析： 题目：有两个线程A、B，A线程向一个集合里面依次添加元素"abc"字符串，一共添加十次，当添加到第五次的时候，希望B线程能够收到A线程的通知，然后B线程执行相关的业务操作。 方式一：使用volatile关键字 基于volatile关键字来实现线程间相互通信是使用共享内存的思想，大致意思就是多个线程同时监听一个变量，当这个变量发生变...
线程之间的通信
qq_45644339的博客
11-28 1724
参考此博客 一、为什么要线程通信？ 1. 多个线程并发执行时, 在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行, 那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数据。 2.当然如果我们没有使用线程通信来使用多线程共同操作同一份数据的话，虽然可以实现，但是在很大程度会造成多线程之间对同一共享变量的争夺，那样的话势必为造成很多错误和损失！ 3.所以，我们才引出了线程之间的通信，多线程之间的通信能够避免对同一共享变量的争夺。 二
线程是如何通讯的？
m0_71777195的博客
05-27 1669
线程通讯指的是多个线程之间通过共享内存或消息传递等方式来协调和同步它们的执行。在多线程编程中，通常会出现多个线程需要共同完成某个任务的情况，这时就需要线程之间进行通讯，以保证任务能够顺利地执行。线程通讯的实现方式主要有以下两种：共享内存：多个线程可以访问同一个共享内存区域，通过读取和写入内存中的数据来进行通讯和同步。消息传递：多个线程之间通过消息队列、管道、信号量等机制来传递信息和同步状态。
Java线程之间通信方式
赵广陆
09-09 2215
目录 1 线程之间的通信方式主要有以下几种 2 共享变量 3 锁机制 4 条件变量 5 信号量 6 管道 6 join方法的实现原理 7 join方法实现顺序性原理 1 线程之间的通信方式主要有以下几种 在实际开发时，一个进程中往往有很多个线程，大多数线程之间往往不是绝对独立的，比如说我们需要将A和B 两个线程的执行结果收集在一起然后显示在界面上，又或者比较典型的消费者-生产者模式，在这些场景下，线程间通信成了我们必须使用的手段，那么线程之间怎么通信呢？
Android Handler与线程间通信ITC深度解析
"深入理解Android Handler机制以及线程间通信ITC" Android Handler机制是Android系统中用于处理线程间通信的重要工具，尤其是对于UI线程和其他工作线程之间的协调。在Android应用开发中，由于主线程（UI线程）不...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值