Java多线程学习（五）线程间通信知识点补充

最新推荐文章于 2022-08-24 15:47:44 发布
最新推荐文章于 2022-08-24 15:47:44 发布
阅读量127 收藏
点赞数
文章标签： java 面试
原文链接：https://juejin.im/post/5ab88d2cf265da238f128933
版权

系列文章传送门:

Java多线程学习（一）Java多线程入门

Java多线程学习（二）synchronized关键字（1）

Java多线程学习（二）synchronized关键字（2）

Java多线程学习（三）volatile关键字

Java多线程学习（四）等待/通知（wait/notify）机制

Java多线程学习（五）线程间通信知识点补充

系列文章将被优先更新于微信公众号“Java面试通关手册”，欢迎广大Java程序员和爱好技术的人员关注。

本节思维导图：

思维导图源文件+思维导图软件关注微信公众号：“Java面试通关手册” 回复关键字：“Java多线程” 免费领取。

我们通过之前几章的学习已经知道在线程间通信用到的synchronized关键字、volatile关键字以及等待/通知（wait/notify）机制。今天我们就来讲一下线程间通信的其他知识点：管道输入/输出流、Thread.join()的使用、ThreadLocal的使用。

一 管道输入/输出流

管道输入/输出流和普通文件的输入/输出流或者网络输入、输出流不同之处在于管道输入/输出流主要用于线程之间的数据传输，而且传输的媒介为内存。

管道输入/输出流主要包括下列两类的实现：

面向字节： PipedOutputStream、 PipedInputStream

面向字符: PipedWriter、 PipedReader

1.1 第一个管道输入/输出流实例

完整代码：github.com/Snailclimb/…

writeMethod方法

	public void writeMethod(PipedOutputStream out) {
		try {
			System.out.println("write :");
			for (int i = 0; i < 300; i++) {
				String outData = "" + (i + 1);
				out.write(outData.getBytes());
				System.out.print(outData);
			}
			System.out.println();
			out.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
复制代码

readMethod方法

	public void readMethod(PipedInputStream input) {
		try {
			System.out.println("read  :");
			byte[] byteArray = new byte[20];
			int readLength = input.read(byteArray);
			while (readLength != -1) {
				String newData = new String(byteArray, 0, readLength);
				System.out.print(newData);
				readLength = input.read(byteArray);
			}
			System.out.println();
			input.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
复制代码

测试方法

	public static void main(String[] args) {

		try {
			WriteData writeData = new WriteData();
			ReadData readData = new ReadData();

			PipedInputStream inputStream = new PipedInputStream();
			PipedOutputStream outputStream = new PipedOutputStream();

			// inputStream.connect(outputStream);
			outputStream.connect(inputStream);

			ThreadRead threadRead = new ThreadRead(readData, inputStream);
			threadRead.start();

			Thread.sleep(2000);

			ThreadWrite threadWrite = new ThreadWrite(writeData, outputStream);
			threadWrite.start();

		} catch (IOException e) {
			e.printStackTrace();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

	}
复制代码

我们上面定义了两个方法writeMethod和readMethod,前者用于写字节/字符（取决于你用的是PipedOuputStream还是PipedWriter），后者用于读取字节/字符（取决于你用的是PipedInputStream还是PipedReader）.我们定义了两个线程threadRead和threadWrite ，threadRead线程运行readMethod方法，threadWrite运行writeMethod方法。然后 通过outputStream.connect(inputStream)或inputStream.connect(outputStream)使两个管道流产生链接，这样就可以将数据进行输入与输出了。

运行结果：

二 Thread.join()的使用

在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()方法了。另外，一个线程需要等待另一个线程也需要用到join()方法。

Thread类除了提供join()方法之外，还提供了join(long millis)、join(long millis, int nanos)两个具有超时特性的方法。这两个超时方法表示，如果线程thread在指定的超时时间没有终止，那么将会从该超时方法中返回。

2.1 join方法使用

不使用join方法的弊端演示：

Test.java

public class Test {

	public static void main(String[] args) throws InterruptedException {

		MyThread threadTest = new MyThread();
		threadTest.start();

		//Thread.sleep(?);//因为不知道子线程要花的时间这里不知道填多少时间
		System.out.println("我想当threadTest对象执行完毕后我再执行");
	}
	static public class MyThread extends Thread {

		@Override
		public void run() {
			System.out.println("我想先执行");
		}

	}
}
复制代码

运行结果：

可以看到子线程中后被执行，这里的例子只是一个简单的演示，我们想一下： 假如子线程运行的结果被主线程运行需要怎么办？ sleep方法？ 当然可以，但是子线程运行需要的时间是不确定的，所以sleep多长时间当然也就不确定了。这里就需要使用 join方法解决上面的问题。

使用join方法解决上面的问题：

Test.java

public class Test {

	public static void main(String[] args) throws InterruptedException {

		MyThread threadTest = new MyThread();
		threadTest.start();

		//Thread.sleep(?);//因为不知道子线程要花的时间这里不知道填多少时间
		threadTest.join();
		System.out.println("我想当threadTest对象执行完毕后我再执行");
	}
	static public class MyThread extends Thread {

		@Override
		public void run() {
			System.out.println("我想先执行");
		}

	}
}
复制代码

上面的代码仅仅加上了一句：threadTest.join();。在这里join方法的作用就是主线程需要等待子线程执行完成之后再结束。

2.2 join(long millis)方法的使用

join(long millis)中的参数就是设定的等待时间。

JoinLongTest.java

public class JoinLongTest {

	public static void main(String[] args) {
		try {
			MyThread threadTest = new MyThread();
			threadTest.start();

			threadTest.join(2000);// 只等2秒
			//Thread.sleep(2000);

			System.out.println("  end timer=" + System.currentTimeMillis());
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

	static public class MyThread extends Thread {

		@Override
		public void run() {
			try {
				System.out.println("begin Timer=" + System.currentTimeMillis());
				Thread.sleep(10000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}

	}
}
复制代码

运行结果：

不管是运行threadTest.join(2000)还是Thread.sleep(2000)， “end timer=1522036620288”语句的输出都是间隔两秒，“end timer=1522036620288”语句输出后该程序还会运行一段时间，因为线程中的run方法中有Thread.sleep(10000)语句。

另外threadTest.join(2000) 和Thread.sleep(2000) 和区别在于： Thread.sleep(2000)不会释放锁，threadTest.join(2000)会释放锁 。

三 ThreadLocal的使用

变量值的共享可以使用public static变量的形式，所有线程都使用一个public static变量。 如果想实现每一个线程都有自己的共享变量该如何解决呢？ JDK中提供的ThreadLocal类正是为了解决这样的问题。 ThreadLocal类主要解决的就是让每个线程绑定自己的值，可以将ThreadLocal类形象的比喻成存放数据的盒子，盒子中可以存储每个线程的私有数据。

再举个简单的例子： 比如有两个人去宝屋收集宝物，这两个共用一个袋子的话肯定会产生争执，但是给他们两个人每个人分配一个袋子的话就不会出现这样的问题。如果把这两个人比作线程的话，那么ThreadLocal就是用来这两个线程竞争的。

ThreadLocal类相关方法：

方法名称描述
get()返回当前线程的此线程局部变量的副本中的值。
set(T value)将当前线程的此线程局部变量的副本设置为指定的值
remove()删除此线程局部变量的当前线程的值。
initialValue()返回此线程局部变量的当前线程的“初始值”

3.1 ThreadLocal类的初试

Test1.java

public class Test1 {
	public static ThreadLocal<String> t1 = new ThreadLocal<String>();

	public static void main(String[] args) {
		if (t1.get() == null) {
			System.out.println("为ThreadLocal类对象放入值:aaa");
			t1.set("aaaֵ");
		}
		System.out.println(t1.get());//aaa
		System.out.println(t1.get());//aaa
	}

}

复制代码

从运行结果可以看出，第一次调用ThreadLocal对象的get()方法时返回的值是null,通过调用set()方法可以为ThreadLocal对象赋值。

如果想要解决get()方法null的问题，可以使用ThreadLocal对象的initialValue方法。如下：

Test2.java


public class Test2 {
	public static ThreadLocalExt t1 = new ThreadLocalExt();

	public static void main(String[] args) {
		if (t1.get() == null) {
			System.out.println("从未放过值");
			t1.set("我的值");
		}
		System.out.println(t1.get());
		System.out.println(t1.get());
	}
	static public class ThreadLocalExt extends ThreadLocal {
		@Override
		protected Object initialValue() {
			return "我是默认值 第一次get不再为null";
		}
	}


}
复制代码

3.2 验证线程变量间的隔离性

Test3.java

/**
 *TODO 验证线程变量间的隔离性
 */
public class Test3 {

	public static void main(String[] args) {
		try {
			for (int i = 0; i < 10; i++) {
				System.out.println("       在Main线程中取值=" + Tools.tl.get());
				Thread.sleep(100);
			}
			Thread.sleep(5000);
			ThreadA a = new ThreadA();
			a.start();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	static public class Tools {
		public static ThreadLocalExt tl = new ThreadLocalExt();
	}
	static public class ThreadLocalExt extends ThreadLocal {
		@Override
		protected Object initialValue() {
			return new Date().getTime();
		}
	}

	static public class ThreadA extends Thread {

		@Override
		public void run() {
			try {
				for (int i = 0; i < 10; i++) {
					System.out.println("在ThreadA线程中取值=" + Tools.tl.get());
					Thread.sleep(100);
				}
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

	}
}
复制代码

从运行结果可以看出子线程和父线程各自拥有各自的值。

运行结果：

3.3 InheritableThreadLocal

ThreadLocal类固然很好，但是子线程并不能取到父线程的ThreadLocal类的变量，InheritableThreadLocal类就是解决这个问题的。

取父线程的值：

修改Test3.java的内部类Tools 和ThreadLocalExt类如下：

 static public class Tools {
		public static InheritableThreadLocalExt tl = new InheritableThreadLocalExt();
	}
	static public class InheritableThreadLocalExt extends InheritableThreadLocal {
		@Override
		protected Object initialValue() {
			return new Date().getTime();
		}
	}
复制代码

运行结果：

取父线程的值并修改：

修改Test3.java的内部类Tools 和InheritableThreadLocalExt类如下：

	static public class Tools {
		public static InheritableThreadLocalExt tl = new InheritableThreadLocalExt();
	}
	static public class InheritableThreadLocalExt extends InheritableThreadLocal {
		@Override
		protected Object initialValue() {
			return new Date().getTime();
		}

		@Override
		protected Object childValue(Object parentValue) {
			return parentValue + " 我在子线程加的~!";
		}
	}
复制代码

运行结果：

在使用InheritableThreadLocal类需要注意的一点是： 如果子线程在取得值的同时，主线程将InheritableThreadLocal中的值进行更改，那么子线程取到的还是旧值。

参考：

《Java多线程编程核心技术》

《Java并发编程的艺术》

weixin_34236497
关注
Java实现线程间的通信的五种方式
Meiko记录
07-06 3063
如何使两个线程按顺序执行？ 假设有两个线程：线程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多线程知识点总结
08-19
了解线程池的概念也是Java多线程编程中的一个重要知识点。线程池是一种多线程处理形式，它将线程和任务的概念分离开来，能够有效管理线程资源，减少线程创建和销毁的开销，提高程序性能。Java中可以通过Executors类...
Java多线程间的通信
热门推荐
it_man的专栏
01-12 2万+
Java多线程间的通信   Java还提供了一种线程间通信的机制，这种通信通什么实现？ wait，notify等机制   或使用pipeInputStream和pipeOutputStream    1. 线程的几种状态 线程有四种状态，任何一个线程肯定处于这四种状态中的一种： 1) 产生（New）：线程对象已经产生，但尚未被启动，所以无法执行。如通过new产生了一个线程对象后没
【Java多线程】你知道实现Java线程间通信有多少种方法吗？
aaa_hao的博客
03-24 4270
文章目录1. 锁与同步2. 等待/通知机制3. 信号量4. 管道5. 其它通信相关5.1 join() 方法5.2 sleep() 方法sleep() 与 wait() 的区别5.3 ThreadLocal 类5.4 InheritableThreadLocal 合理地使用 Java 多线程可以更好地利用服务器资源。一般来讲，线程内部有自己私有的线程上下文，互不干扰。但是当我们需要多个线程之间相互协作的时候，就需要掌握 Java 线程的通信方式。下文将介绍 Java 线程之间的几种通信机制和原理。 1. 锁
java线程间通讯_Java线程间通讯
cunfen6312的博客
07-29 93
java线程间通讯 Java线程间通讯 (Java Interthread Communication) Java provide benefits of avoiding thread pooling using inter-thread communication. The wait(), notify(), and notifyAll() methods of Object class ...
Java线程间的通信
joeyin
01-24 148
当需要多个线程之间相互协作的时候，就需要用到Java线程的通信方法。 Java中，锁的概念都是基于对象的，所以又称为对象锁。 1. 锁与同步 package chapter7; public class ObjectLock { // 类属性只有一个[不管创建多少个实例]，保证同一个锁 private static Object lock = new Object(); // 可尝试去掉static怎么保证线程安全 static class ThreadA im
java多线程代码案例(创建线程,主线程,线程优先级,线程组,线程同步,线程间的通信)
03-31
本文将深入探讨Java多线程中的关键知识点，包括创建线程、主线程、线程优先级、线程组、线程同步以及线程间的通信。 1. **创建线程** 在Java中，可以通过两种方式创建线程：继承`Thread`类或实现`Runnable`接口。...
Java多线程详解（超详细）_狂神说笔记完整版_项目代码_适合小白随课程学习
08-08
Java多线程详解 在Java编程中，多线程是一种重要的技术，它使得程序能够同时执行多个任务，提高系统的效率和响应性。本教程将详细讲解Java中的多线程概念，包括线程的创建、状态、同步以及高级主题，旨在帮助初学者...
Java多线程学习-动力节点共22页.pdf.zip
10-29
本资料“Java多线程学习-动力节点共22页.pdf.zip”提供了对Java多线程的深入学习，旨在帮助开发者掌握这一关键技术。 1. **线程基础**：Java中的线程是通过`Thread`类或者实现`Runnable`接口来创建的。通过继承`...
Java 多线程学习详细总结
09-01
【Java 多线程学习详细总结...通过理解并熟练掌握这些Java多线程知识点，开发者可以编写出高效、安全的并发程序，解决复杂的并发问题。在实际开发中，应根据具体需求选择合适的线程同步机制，确保程序的稳定性和性能。
JAVA线程之间的通信
康雨城
02-16 1576
wait()方法的原理：首先，JVM会释放当前线程的对象锁监视器的Owner资格；其次，JVM会将当前线程移入监视器的WaitSet队列，而这些操作都和对象锁监视器是相关的。 notify()方法的原理：JVM从对象锁的监视器的WaitSet队列移动一个线程到其EntryList队列.
java线程之间的通信
白小白的小白的博客
05-27 147
// 线程之间的通信，类似与订阅者和消费者之间的关系，比如一个线程生产包子，另一个线程用来吃包子 // 线程之间的通信，前提： 同一个对象中线程的通信 public class Demo28Class extends Thread { public static void main(String[] args) { Object obj1 = new Object(); // 使用匿名类生成第一个对象(顾客) new Thread(){
Java线程间通信
Galip的博客
12-21 118
Java线程间通信 线程间通信又称为进程内通信，多个线程实现互斥访问共享资源时会互相发送信号或者等待信号。 一、同步阻塞和异步非阻塞 同步阻塞 指的是客户端和服务器通信的时候，每向服务器请求一个事件，如果没有得到想要的结果，就进入阻塞状态，相应地，服务器要创建多个线程来一一处理每个请求，请求完成之后，返回给服务端结果，完成一次交互。 缺点： 同步事务提交，客户端等待时间过长。 系统吞吐量不高...
Java 线程间通信
weixin_42494845的博客
10-10 148
要实现多个线程之间的协同，需要涉及到线程之间相互通信，线程间通信分为以下四类： 文件共享 网络共享 共享全局变量 jdk提供的线程协调API 本文只讲解jdk提供的API。 三种线程协作通信的方式： suspend/resume（已弃用） wait/notify park/unpark suspend/resume 示例（生产者—消费者模型）：线程1买包子，发现没有包子，停止执行，线程2生产出包子，通知线程1继续执行。 public class Test { /** 包子 */ pu
java线程间通信
qq_41246557的博客
08-24 164
线程间通信
Java多线程深度解析：知识点与企业实战
"Java多线程相关知识点及企业面试题" 在Java编程中，多线程是核心概念之一，尤其对于构建高效、响应迅速的系统至关重要。以下是对Java多线程知识点的详细总结： 1. **多线程相关概念** - **程序**：一组指令的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值