Java多线程编程（线程间通信）

最新推荐文章于 2024-01-12 18:59:05 发布
最新推荐文章于 2024-01-12 18:59:05 发布
阅读量127 收藏
点赞数
分类专栏： Java多线程 文章标签： java 多线程 并发编程 thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40473204/article/details/116944813
版权

方法wait的作用是使当前执行代码的线程进行等待，将当前线程置入预执行队列，在调用wait之前，线程必须获得该对象的对象级别锁，即只能在同步方法或者同步块中调用wait方法。

方法notify也要在同步方法或同步块中调用，

再执行notify方法后，要等到执行notify的方法的线程将程序执行完，也就是退出synchronized代码块后，当前线程才会释放锁。

package com.java.mul;

import com.java.mul.extthread.Alogin;
import com.java.mul.extthread.BLogin;

public class multest {

	public static void main(String[] args) throws InterruptedException {
		// TODO Auto-generated method stub
		Object lock = new Object();
		MyThreadA a = new MyThreadA(lock);
		a.start();
		Thread.sleep(3000);
		MyThreadB b = new MyThreadB(lock);
		b.start();

	}
}

package com.java.mul;

public class MyThreadA extends Thread{
	private Object lock;
	public MyThreadA(Object lock) {
		super();
		this.lock = lock;
	}
	
	@Override
	public void run() {
		
		try {
			synchronized(lock) {
				System.out.println("start " + System.currentTimeMillis());
				lock.wait();
				System.out.println("finish " + System.currentTimeMillis());
			}

			
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

package com.java.mul;

public class MyThreadB extends Thread{
	private Object lock;
	public MyThreadB(Object lock) {
		super();
		this.lock = lock;
	}
	
	@Override
	public void run() {
		
			synchronized(lock) {
				System.out.println("start notify " + System.currentTimeMillis());
				lock.notify();
				System.out.println("finish notify" + System.currentTimeMillis());
			}

	}
}


package com.java.mul;

import com.java.mul.extthread.Alogin;
import com.java.mul.extthread.BLogin;

public class multest {

	public static void main(String[] args) throws InterruptedException {
		// TODO Auto-generated method stub
		Object lock = new Object();
		MyThreadA a = new MyThreadA(lock);
		a.start();
		Thread.sleep(50);
		MyThreadB b = new MyThreadB(lock);
		b.start();

	}
}

package com.java.mul;

public class MyThreadA extends Thread{
	private Object lock;
	public MyThreadA(Object lock) {
		super();
		this.lock = lock;
	}
	
	@Override
	public void run() {
		
		try {
			synchronized(lock) {
				if(MyList.size() != 5) {
					System.out.println("start " + System.currentTimeMillis());
					lock.wait();
					System.out.println("finish " + System.currentTimeMillis());
				}
				
			}

			
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

package com.java.mul;

public class MyThreadB extends Thread{
	private Object lock;
	public MyThreadB(Object lock) {
		super();
		this.lock = lock;
	}
	
	@Override
	public void run() {
				try {
					synchronized(lock) {
						for(int i = 0;i<10;i++) {
							MyList.add();
							if(MyList.size() == 5) {
								lock.notify();
								System.out.println("send notyfy ");
							}
							System.out.println("add  " + (i + 1)+"elements");
						}
					Thread.sleep(1000);
					}
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			

	}
}

package com.java.mul;

import java.util.ArrayList;
import java.util.List;

public class MyList {
	private static List list = new ArrayList();
	public static void add() {
		list.add("sss");
	}
	public static int size() {
		return list.size();
	}
}

生产者消费者

package com.java.mul;

public class P {
	private String lock;
	public P(String lock) {
		super();
		this.lock = lock;
	}
	public void setValue() {
		try {
			synchronized(lock) {
				if(!ValueObject.value.equals("")) {
					lock.wait();
				}
				String value = System.currentTimeMillis() + "_" + System.nanoTime();
				System.out.println("set is " + value);
				ValueObject.value = value;
				lock.notify();
			}
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

package com.java.mul;

public class C {
	private String lock;
	public C(String lock) {
		super();
		this.lock = lock;
	}
	public void getValue() {
		try {
			synchronized(lock) {
				if(ValueObject.value.equals("")) {
					lock.wait();
				}

				System.out.println("get is " + ValueObject.value);
				ValueObject.value = "";
				lock.notify();
			}
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

package com.java.mul;

public class ValueObject {
	public static String value = "";

}

package com.java.mul;

public class ThreadP extends Thread{
	private P p;
	public ThreadP(P p) {
		super();
		this.p = p;
	}
	
	@Override
	public void run() {
		while(true) {
			p.setValue();
		}
	}
}

package com.java.mul;

public class ThreadC  extends Thread{
	private C c;
	public ThreadC(C c) {
		super();
		this.c = c;
	}
	
	@Override
	public void run() {
		while(true) {
			c.getValue();
		}
	}
}

package com.java.mul;

public class Run {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		String lock = new String("");
		P p = new P(lock);
		C c = new C(lock);
		ThreadP pThread = new ThreadP(p);
		ThreadC cThread = new ThreadC(c);
		pThread.start();
		cThread.start();
	}

}

当有多个生产者和消费者，生产者的notify有可能唤醒生产者，这样积少成多，容易造成假死。

一生产一消费

package com.java.mul;

import java.util.ArrayList;
import java.util.List;

public class MyStack {
	private List list = new ArrayList();
	synchronized public void push() {
		try {
			if(list.size() == 1) {
				this.wait();
			}
			list.add("anyString=" + Math.random());
			this.notify();
			System.out.println("push=" + list.size());
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
	synchronized public String pop() {
		String returnValue = "";
		try {
			if(list.size()==0) {
				System.out.println("pop:"+ Thread.currentThread().getName() + " wait");
				this.wait();
			}
			returnValue = "" + list.get(0);
			list.remove(0);
			this.notify();
			System.out.println("pop="+list.size());
			
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return returnValue;
	}
}

package com.java.mul;

public class ThreadC  extends Thread{
	private C c;
	public ThreadC(C c) {
		super();
		this.c = c;
	}
	
	@Override
	public void run() {
		while(true) {
			c.popService();
		}
	}
}

package com.java.mul;

public class ThreadP extends Thread{
	private P p;
	public ThreadP(P p) {
		super();
		this.p = p;
	}
	
	@Override
	public void run() {
		while(true) {
			p.pushService();
		}
	}
}

package com.java.mul;

public class P {
	private MyStack myStack;
	public P(MyStack myStack) {
		super();
		this.myStack = myStack;
	}
	public void pushService() {
		myStack.push();
	}


}

package com.java.mul;

public class C {
	private MyStack myStack;
	public C(MyStack myStack) {
		super();
		this.myStack = myStack;
	}

	public void popService() {
		System.out.println("pop=" + myStack.pop());
	}

}

package com.java.mul;

public class Run {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		MyStack myStack = new MyStack();
		P p = new P(myStack);
		C c = new C(myStack);
		ThreadP pThread = new ThreadP(p);
		ThreadC cThread = new ThreadC(c);
		pThread.start();
		cThread.start();
	}

}

一生产多消费（要把if换成while，来防止一个pop被唤醒，但是listsize为0，但是这时候也可能会发生假死）

package com.java.mul;

public class Run {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		MyStack myStack = new MyStack();
		P p = new P(myStack);
		C c1 = new C(myStack);
		C c2 = new C(myStack);
		C c3 = new C(myStack);
		C c4 = new C(myStack);
		ThreadP pThread = new ThreadP(p);
		pThread.start();
		ThreadC cThread1 = new ThreadC(c1);
		ThreadC cThread2 = new ThreadC(c2);
		ThreadC cThread3 = new ThreadC(c3);
		ThreadC cThread4 = new ThreadC(c4);
		
		cThread1.start();
		cThread2.start();
		cThread3.start();
		cThread4.start();
	}

}

package com.java.mul;

import java.util.ArrayList;
import java.util.List;

public class MyStack {
	private List list = new ArrayList();
	synchronized public void push() {
		try {
			while(list.size() == 1) {
				this.wait();
			}
			list.add("anyString=" + Math.random());
			this.notify();
			System.out.println("push=" + list.size());
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
	synchronized public String pop() {
		String returnValue = "";
		try {
			while(list.size()==0) {
				System.out.println("pop:"+ Thread.currentThread().getName() + " wait");
				this.wait();
			}
			returnValue = "" + list.get(0);
			list.remove(0);
			this.notify();
			System.out.println("pop="+list.size());
			
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return returnValue;
	}
}

通过管道进行线程间通信：字节流

java的JDK中提供了4个类来使线程间可以进行通信：

PipedInputStreeam和PipedOutputStreeam

PipedReader和PipedWriter

 

 

实战：等待/通知之交叉备份

package com.java.mul;

public class DBTools {
	volatile private boolean prevIsA = false;
	synchronized public void backupA(){
		try {
			while(prevIsA == true) {
				wait();
			}
			for(int i=0;i<5;i++) {
				System.out.println("-----");
			}
			prevIsA = true;
			notifyAll();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	synchronized public void backupB(){
		try {
			while(prevIsA == false) {
				wait();
			}
			for(int i=0;i<5;i++) {
				System.out.println("22222");
			}
			prevIsA = false;
			notifyAll();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

package com.java.mul;

public class BackupA extends Thread{
	private DBTools dbtools;
	public BackupA(DBTools dbtools) {
		super();
		this.dbtools = dbtools;
	}
	
	@Override
	public void run() {
		dbtools.backupA();
	}
}

package com.java.mul;

public class BackupB extends Thread{
	private DBTools dbtools;
	public BackupB(DBTools dbtools) {
		super();
		this.dbtools = dbtools;
		
	}
	
	@Override
	public void run() {
		dbtools.backupB();
	}
}

package com.java.mul;

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

public class Run {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		DBTools dbtools = new DBTools();
		for(int i = 0;i<20;i++) {
			BackupB output = new BackupB(dbtools);
			output.start();
			BackupA input = new BackupA(dbtools);
			input.start();
		}
			
	}
}

 

方法join的使用（等待线程对象销毁）

join在内部使用wait方法进行等待，synchronized关键字使用的是“对象监视器”原理作为同步。

方法join后的代码可能异步提前运行，造成多种结果的组合。

 

类ThreadLocal的使用（使每一个线程都有一个自己的共享变量的值，也就是变量在不同线程的隔离性）

package com.java.mul;

import java.io.IOException;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;

public class Run {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try {
			MyThreadA a = new MyThreadA();
			MyThreadB b = new MyThreadB();
			a.start();
			b.start();
			for(int i = 0;i<100;i++) {
				Tools.t1.set("Main" + (1 + i));
				System.out.println("Main get Value=" + Tools.t1.get());
				Thread.sleep(200);
			}
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
			
	}
}

package com.java.mul;

public class Tools {
	public static ThreadLocal t1 = new ThreadLocal();
}

package com.java.mul;

public class MyThreadA extends Thread{

	@Override
	public void run() {
		
		try {
			for(int i = 0;i<100;i++) {
				Tools.t1.set("ThreadA" + (1 + i));
				System.out.println("ThreadA get Value=" + Tools.t1.get());
				Thread.sleep(200);
			}

			
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

package com.java.mul;

public class MyThreadB extends Thread{

	
	@Override
	public void run() {
				try {

						for(int i = 0;i<100;i++) {
							Tools.t1.set("ThreadB" + (1 + i));
							System.out.println("ThreadB get Value=" + Tools.t1.get());
							Thread.sleep(200);
						}
					
					
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			

	}
}

InheritableThreadLocal（使用这个类，可以使子线程继承父线程的值）

 

 

 

 

 

 

BinaryJack
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程编程线程间通信详解.docx
07-02
但在多线程编程中，这种方式无疑是非常低效的。如果一个线程持续进行无意义的判断而不释放CPU，这就会造成资源的浪费；而如果定时去判断，不满足保护条件就释放CPU，又会造成频繁的上下文切换。总之，不推荐在多线程...
线程通信的四种方式
热门推荐
weixin_43786099的博客
11-10 2万+
多个线程在并发执行的时候，他们在CPU中是随机切换执行的，这个时候我们想多个线程一起来完成一件任务，这个时候我们就需要线程之间的通信了，多个线程一起来完成一个任务，线程通信一般有4种方式： 通过 volatile 关键字 通过 Object类的 wait/notify 方法 通过 condition 的 await/signal 方法 通过 join 的方式 现在有一个问题，两个线程分别打印字符串，但是当线程A每输出两次的时候，线程B就输出一次，如此反复10次。 通过 volatile 关键字 通过
线程间的通讯
weixin_46060794的博客
08-08 2744
一.为什么需要线程通讯 线程是操作系统调度的最小单位，有自己的栈空间，可以按照既定的代码逐步的执行，但是如果每个线程间都孤立的运行，那就会造资源浪费。所以在现实中，我们需要这些线程间可以按照指定的规则共同完成一件任务，所以这些线程之间就需要互相协调，这个过程被称为线程的通信。 线程间的通讯定义：多个线程在操作同一份数据时，互相告知自己的状态，避免对同一共享变量的争夺。 二.线程间的通讯方式 线程通讯的方式主要可以分为三种方式，共享内存、消息传递和管道流。 1.共享内存 （1）...
线程间通讯（几种常见的通讯机制，以及实例）
bigger_belief的博客
07-18 4915
介绍线程间通讯的几种方式，以及一些实例
线程之间的通信方式
weixin_41979002的博客
08-02 6461
前言 我只是个搬运工，尊重原作者的劳动成果，本文来源下列文章链接： https://zhuanlan.zhihu.com/p/129374075 https://blog.csdn.net/jisuanji12306/article/details/86363390 线程之间为什么要通信？ 通信的目的是为了更好的协作，线程无论是交替式执行，还是接力式执行，都需要进行通信告知。首先，要短信线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。我们来基本一道面试常见的题目来分析： 题目
java多线程编程学习(线程间通信)
08-29
Java 多线程编程学习（线程间通信） Java 多线程编程是指在 Java 中使用多个线程来执行不同的任务，以提高程序的执行效率和响应速度。线程间通信是多线程编程中非常重要的一个部分，通过线程间通信，多个线程可以...
java多线程编程之管道通信详解
08-29
主要为大家详细介绍了java多线程编程之线程间的通信，探讨使用管道进行通信，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
深入理解JAVA多线程之线程间的通信方式
09-02
在Java多线程编程中，线程间的通信是至关重要的，因为它确保了多个并发执行的任务能够协调工作，避免数据不一致性和死锁等问题。本文将深入探讨两种主要的线程间通信方式：同步机制和基于轮询的方式。 1. 同步机制...
java多线程编程之java线程简介
09-04
Java多线程编程是开发高并发、高性能应用的关键技术之一。Java线程是程序执行的最小单位，它在Java中是通过`Thread`类或实现`Runnable`接口来创建和管理的。线程允许程序在同一进程中并发执行多个任务，提高了程序的...
线程间通信的几种实现方式
木牛的博客
02-24 8147
线程间通信的几种实现方式 首先，要短信线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。我们来基本一道面试常见的题目来分析： 题目：有两个线程A、B，A线程向一个集合里面依次添加元素"abc"字符串，一共添加十次，当添加到第五次的时候，希望B线程能够收到A线程的通知，然后B线程执行相关的业务操作。 方式一：使用volatile关键字 基于volatile关键字来实现线程间相互通信是使用共享内存的思想，大致意思就是多个线程同时监听一个变量，当这个变量发生变...
线程之间的通信
qq_45644339的博客
11-28 1692
参考此博客 一、为什么要线程通信？ 1. 多个线程并发执行时, 在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行, 那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数据。 2.当然如果我们没有使用线程通信来使用多线程共同操作同一份数据的话，虽然可以实现，但是在很大程度会造成多线程之间对同一共享变量的争夺，那样的话势必为造成很多错误和损失！ 3.所以，我们才引出了线程之间的通信，多线程之间的通信能够避免对同一共享变量的争夺。 二
线程是如何通讯的？
m0_71777195的博客
05-27 1608
线程通讯指的是多个线程之间通过共享内存或消息传递等方式来协调和同步它们的执行。在多线程编程中，通常会出现多个线程需要共同完成某个任务的情况，这时就需要线程之间进行通讯，以保证任务能够顺利地执行。线程通讯的实现方式主要有以下两种：共享内存：多个线程可以访问同一个共享内存区域，通过读取和写入内存中的数据来进行通讯和同步。消息传递：多个线程之间通过消息队列、管道、信号量等机制来传递信息和同步状态。
线程之间是如何通信的？
最新发布
NZC2237的博客
01-12 2315
CountDownLatch`和`CyclicBarrier`是Java中的两个同步工具，它们可以用于线程之间的协调。在Java中，通过`Object`类的`wait()`和`notify()`方法，以及`notifyAll()`方法，可以实现线程之间的等待和唤醒操作。Java中的`ReentrantLock`和`Condition`接口提供了条件变量的实现。在Java中，`PipedInputStream`和`PipedOutputStream`提供了管道的实现。
线程间通信
weixin_53812805的博客
05-02 4105
目录 一、线程理论基础 1、什么是线程 2、为什么有了进程，还要引入线程呢？ （使用多线程到底有哪些好处？） 3、线程的缺点 二、多线程间通信 1、多线程通信的注意事项 2、创建线程的步骤 3、终止线程的方式 4、线程 API 使用 （1）pthread_create() 函数 （创建线程） （2）pthread_exit()函数 （结束线程） （3）pthread_join()函数 （等待线程结束） 三、线程同步 1、互斥量 （1）互斥量注意事项 （2）互斥锁创建步..
线程之间的几种通信方式
qq_44688861的博客
03-02 1万+
一、线程之间的几种通信方式 1、管道，是一种半双工方式，数据单方向流动，而且只能在有亲缘关系的线程之间使用。他是基于内核的，可以把它当作是内核缓冲区，在内核和用户空间交换数据需要进行四次的数据拷贝，因为他是把用户空间的数据拷贝到内核，然后从内核拷贝到内存，然后从内存再拷贝到内核，最后拷贝到用户空间，至于为什么要拷贝到内核，是因为数据最重都是在内存中执行的。接收的时候要按照次序，按照先进先出的原则，在管道中的数据只能被读取1次，读出之后缓冲区就不存在了。它只能承载没有格式的字节流 。 2、命名管道，和管道差不
十一、线程与线程间通信
Ningmengyouzhi的博客
03-03 887
Thread、Runnable接口、Callable接口、join方法、sleep方法、interrupt方法、yield方法、同步与死锁、synchronized与Lock、单例模式懒汉饿汉、线程间的通信（生产者与消费者）、线程池
JAVA多线程基础篇-线程通信(wait/notify)
qq_33479841的博客
07-10 1858
在JAVA多线程中，线程通信是重要概念之一。线程通信能够使系统之间的交互性更强大，在大大提高CPU利用率的同时还会使程序员对各线程在任务处理过程中进行有效把控。本文将针对使用wait/notify进行线程之间通信进行分析，详述其实现过程、原理以及相关注意事项。.........
Java多线程编程深入详解.docx
10-24
Java多线程编程深入详解

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值