【Thread】- 4种线程通信方式

最新推荐文章于 2023-06-30 18:25:43 发布
最新推荐文章于 2023-06-30 18:25:43 发布
阅读量192 收藏
点赞数
文章标签： java 操作系统 python
原文链接：https://my.oschina.net/yangzhiwei256/blog/3017190
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

suspend、resume、stop

  • suspend：线程挂起：阻塞,但是不会释放持有资源，包含锁资源(过期)
  • resume：恢复线程执行：挂起-->就绪
  • stop: 暴力终止线程

终止线程优雅做法，设置线程执行的开关

volatile 保证数据的可见性，线程执行时每次都会从公共内存加载on数据

Thread.currentThread().isInterrupted()： 判断线程是否被中断：interrupted()

private static class Runner implements Runnable {
    private long i;
    private volatile boolean on = true;
    [@Override](https://my.oschina.net/u/1162528)
    public void run() {
        while (on && !Thread.currentThread().isInterrupted()){
            i++;
        }
        System.out.println("Count i = " + i);
    }
    public void cancel() {
        on = false;
    }
}

缺点：

  1. 独占，suspend方法是线程作用的公共同步对象的锁不会被释放，造成其他线程无法访问公共同步对象

  2. 数据不一致：例如对象属性赋值时中间挂起执行线程，导致整个线程的关联的对象属性赋值执行过程不完整，造成数据不一致的情况

  • 测试代码
package com.zhiwei.thread;

public class ThreadSuspend {

	@SuppressWarnings("deprecation")
	public static void main(String[] args) throws InterruptedException {
		
		SuspendThread suspendThread = new SuspendThread();
		suspendThread.start();
		
		Thread.sleep(5000);
		
		System.out.println("线程第1次被挂起-------------------");
		suspendThread.suspend();
		
		System.out.println("线程第1次恢复运行-------------------");
		suspendThread.resume();
		
		Thread.sleep(5000);
		
		System.out.println("线程第2次被挂起-------------------");
		suspendThread.suspend();
	}
	
}

class SuspendThread extends Thread{
	
	private long i = 0;
	
	public long get(){
		return i;
	}
	
	public void set(long i){
		this.i = i;
	}
	
	@Override
	public void run() {
		while(true){
			System.out.println("i:"+i);
			try {
				Thread.sleep(1000);
				i++;
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
}

效果：

wait、notify

wait:当前访问对象的线程被阻塞，并且放弃之前拥有的资源，直到被notify/notifyAll方法唤醒，在原来中断的地方继续执行

扩展：线程从原来中断的地方继续执行的原因：操作系统是统一管理所有的软硬件资源的软件，进程是程序分配资源的单位，线程则是进程进行资源进一步划分的最小的分配资源单位，当线程或进程被中断的时候，操作系统会自动将当前线程/进程的状态存入线程控制块(TCB)和进程控制块(PCB)，然后阻塞当前运行的线程/进程，当线程/进程达到运行的条件，操作系统会从之前保存的TCB/PCB中读取信息，恢复中断前的状态，所以线程/进程就成从中断的地方继续运行

notify: 唤醒访问目标对象的1个阻塞线程，线程进入就绪状态，分配CPU资源即可运行

注意：如果存在多个线程访问同一个对象，notify唤醒的线程是随机的，notifyAll可以唤醒所有的阻塞线程

测试案例：

package com.zhiwei.thread;

public class WaitAndNotify {
	
   private static Object object = new Object();
   
	public static void main(String[] args) throws InterruptedException{
	  threadWait tw = new threadWait();
      threadNotify tn = new threadNotify();
      Thread th1 = new Thread(tw);
      Thread th2 = new Thread(tn);
      th1.start();
      th2.start();
	}
	
	
	private static class threadWait implements Runnable{
		@Override
		public void run() {
			synchronized (object) { 
				try {
					System.out.println(Thread.currentThread().getName() + ":object对象锁释放前！");
					object.wait();  
			System.out.println(Thread.currentThread().getName() + "：object对象锁释放后！"); 
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
	
	private static class threadNotify implements Runnable{

		@Override
		public void run() {
			synchronized (object) {
				try {
					System.out.println(Thread.currentThread().getName()+"：object对象锁获取前！");
					object.notify(); 
					System.out.println(Thread.currentThread().getName()+":object对象锁获取后！(JVM决定唤醒另外线程)");
				} catch (Exception e) {
					e.printStackTrace();
				}
			}		
		}
	}
}

结果：

Thread-0: object对象锁释放前！
Thread-1：object对象锁获取前！
Thread-1: object对象锁获取后！(JVM决定唤醒另外线程)
Thread-0：object对象锁释放后！

分析：

  1. 线程threadWait执行时synchronized (object)的原因，线程threadNotify线程阻塞，等待threadWait释放对象锁才可以执行

  2. 当threadWait执行到 object.wait()时，threadWait线程被手动阻塞中断，释放对象锁，因此控制台只会输出之前的

“Thread-0:object对象锁释放前！”
  1. 因threadWait释放对象锁，线程threadNotify运行，当执行object.notify(); 时，因object只有1个阻塞线程，因此threadWait线程被唤醒，但是由于threadNotify还在执行同步代码块，因此线程threadWait进入阻塞状态，当线程threadNotify执行完成同步代码块，控制台输出
"Thread-1：object对象锁获取前！
Thread-1:object对象锁获取后！(JVM决定唤醒另外线程)"
  1. threadNotify持有的object对象锁释放，threadWait获取对象锁继续执行，控制台输出
"Thread-0：object对象锁释放后！"

await、signal

await和signal类似wait和notify的关系，await会阻塞当前线程，直到接收到signal后唤醒继续执行，这也是线程的一种通信机制

需求：多线程交替打印字符

测试代码

package com.zhiwei.thread;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class TheadAwait {

	public boolean flag = true;
	Lock lock = new ReentrantLock();
	Condition condition = lock.newCondition();

	public void get() {
		try {
			Thread.sleep(5000);
			lock.lock();
			while (!flag) {
				condition.await();
			}
			System.out.println(Thread.currentThread().getName()+":-----------------");
			flag = !flag;
			condition.signal();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}

	public void put() {
		try {
			Thread.sleep(5000);
			lock.lock();
			while (flag) {
				condition.await();
			}
			System.out.println(Thread.currentThread().getName()+":*****************");
			flag = !flag;
			condition.signal();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}

	public static void main(String[] args) {

		TheadAwait alternatelyPrint = new TheadAwait();
		while (true) {
			new Thread(new Runnable() {
				@Override
				public void run() {
					alternatelyPrint.get();
				}
			}).start();

			new Thread(new Runnable() {
				@Override
				public void run() {
					alternatelyPrint.put();
				}
			}).start();
		}
	}
}

效果：

Callable、Future

Callable: 可理解成线程执行的具体任务，但具有返回值 Future：Callable执行的返回值

作用：在线程执行的过程中可获取到线程执行的状态，例如异步的情况，可通过线程执行后的状态进行响应的控制，而不至于因为线程执行的不确定性造成不可控

注意：future.get() 会造成线程阻塞，一致到有返回值才进行下一步操作

  • 测试代码
package com.zhiwei.thread;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * callable对象是具有返回值的对象，并且将结果返回给Future对象：
 * completService可以一次执行一组callable独享方法,并返回最早的结果
 */
public class CallableAndFuture {

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

		ExecutorService threadPool = Executors.newSingleThreadExecutor();
		Future<String> future = threadPool.submit(new Callable<String>() {
			public String call() throws Exception {
				Thread.sleep(5000);
				return "hello Java World!";
			}
		});
		
		System.out.println("5s线程返回结果：" + future.get());
		threadPool.shutdown();
	}
}

效果：5s后

转载于:https://my.oschina.net/yangzhiwei256/blog/3017190

weixin_34240657
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java多线程(Thread)间通信和共享数据
m0_65014849的博客
02-08 905
Java多线程间通信和共享数据
Thread之线程通信（wait和notify）
会者定离，一期一祈
02-08 1788
目录线程通信的定义轮询实现结论wait和notify实现wait方法nofify方法结论补充说明 线程通信的定义 线程是程序中独立的个体，但这些个体如果不经过处理就不能成为一个整体。线程间的通信就是使它们成为整体的方案之一。 可以说通过线程通信，线程之间的交互性会更强大，能够大大提高CPU的复用率，同时也可以对线程任务进行有效的把控和监督 轮询实现 import lombok.SneakyThrows; import java.util.ArrayList; import java.util.List;
线程间通信的方式----全面解析
programmerylj的博客
06-28 309
一.volatile和synchronize 1.volatile:读取数据时每次都从主内存中读取，每次写数据都要刷新到主内存，保证了数据的可见性和有序性。 2.synchronize：对需要操作的数据进行加锁，保证只有一个线程访问，保证数据的可见性和原子性，但是不保证数据的有序性。 二.等待通知机制 调用此类方法首先都要获得锁，即该语句要放到synchronize语句块内部。如果没有加锁会抛出异常：Exception in thread “main” java.lang.IllegalMonitorSta
初步认识Thread网络
m0_46411607的博客
06-30 2254
初步认识Thread网络
线程之间的通信（thread signal）
weixin_34411563的博客
07-08 604
线程通信的目的是为了能够让线程之间相互发送信号。另外，线程通信还能够使得线程等待其它线程的信号，比如，线程B可以等待线程A的信号，这个信号可以是线程A已经处理完成的信号。 通过共享对象通信 有一个简单的实现线程之间通信的方式，就是在共享对象的变量中设置信号值。比如线程A在一个同步块中设置一个成员变量hasDataToProces...
Java线程间的通信方式详解
09-02
本文将详细介绍两种常见的Java线程通信方式：同步和while轮询。 1. 同步（Synchronized） 同步是Java中控制线程并发的一种手段，它通过`synchronized`关键字实现。在Java中，同步主要有两种形式：同步方法（通过在...
vc++ multithread多线程教程---线程通信--利用事件对象,线程同步--使用信号量,线程同步--使用互斥量,线程同步--使用临界区
04-04
本教程将深入探讨四种常见的线程同步机制：事件对象、信号量、互斥量以及临界区，帮助开发者理解和掌握如何在VC++中安全地实现多线程通信。 一、事件对象 事件对象是Windows API中用于线程间通信的一种同步机制。它...
RT-Thread线程-创建线程
最新发布
04-25
通过以上步骤，我们就能在STM32H750VBT6上成功创建并运行RT-Thread线程。这个过程涉及到操作系统原理、嵌入式编程、实时调度等多个领域的知识，深入理解和熟练掌握这些技能对于开发高效的嵌入式系统至关重要。在实际...
RT-thread线程间同步和通信之信号量（动态）
08-24
信号量是RTOS中用于线程间同步和通信的一种机制，尤其在STM32这样的微控制器上应用广泛。本文将深入探讨RT-thread中动态信号量的概念、实现原理以及如何通过信号量控制硬件资源，例如LED灯的亮灭。 信号量是一种...
qt object多线程- 串口通信
03-13
本篇文章将深入探讨如何在Qt中利用对象的继承方式实现多线程来处理串口通信任务。 首先，我们要理解Qt中的多线程。在C++中，线程是程序执行的最小单位，多线程可以让我们同时执行多个任务，提高程序的运行效率。Qt...
深入理解并发编程之线程之间的通讯
李永志的博客
01-25 436
线程间的通信是使线程间能够互相发送信号。当多个线程在处理同一个资源，并且**任务不同时(正常情况下多线程执行是同时处理的，但是我们期望的是不同时)**，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。只要线程不是同时操作共享变量就不会发生线程安全问题。
线程间通信的几种实现方式
热门推荐
InterfaceJ的博客
01-13 18万+
线程间通信的几种实现方式 首先，要短信线程间通信的模型有两种：共享内存和消息传递，以下方式都是基本这两种模型来实现的。我们来基本一道面试常见的题目来分析： 题目：有两个线程A、B，A线程向一个集合里面依次添加元素&amp;quot;abc&amp;quot;字符串，一共添加十次，当添加到第五次的时候，希望B线程能够收到A线程的通知，然后B线程执行相关的业务操作。 方式一：使用 volatile 关键字 基于 volatile...
c++thread学习(2) 线程之间通信的一种方式
weixin_30621711的博客
12-19 482
以下内容讲的是这样一个例子： 现有类A, 其结构如下所示： class A: { .... 一些数据成员和成员函数； .... dataType data; 主函数 process(dataType& data,...);//data需要其他线程送入，而且根据系统需求，只要data更新，process便执行一次。 }; 现在我们想让类...
线程之间通信的方法
if_i_were_a的博客
03-28 1712
线程之间通信的方法有四种: 1. 共享内存的方法 该方法有两种实现形式: synchronized和volatile 使用synchronized，多线程环境下会造成阻塞，如果有多个线程同时要对内存中的一个数据进行操作，那么他们都把内存中的值读到自己的工作内存中。使用synchronized修饰的haul同一时间只能有一个线程进行操作，对数据更新完之后重新刷新会主存，自动释放锁，然后下一个...
ThreadX内核源码分析(SMP) - 核间通信(arm)
arm7star的博客
07-05 1746
多核情况下，一个核可能改变另外一个核的执行状态，例如一个核挂起另外一个核正在执行的线程，如果没有机制通知另外一个核该线程被挂起的话，那么被挂起的线程就感知不到自己被挂起了；ThreadX内核使用SGI中断，从一个核发送一个中断信号到目的核上去，从而使另外一个核产生中断，另外一个核就会去检查状态变化，例如是否要重新调度(别的核改变了该核需要执行的线程)。 参考《ARMv8-A_Architecture_Reference_Manual_(Issue_A.a).pdf》"D8.6.28 ICC_S
线程通信的四种方式
weixin_43786099的博客
11-10 2万+
多个线程在并发执行的时候，他们在CPU中是随机切换执行的，这个时候我们想多个线程一起来完成一件任务，这个时候我们就需要线程之间的通信了，多个线程一起来完成一个任务，线程通信一般有4种方式： 通过 volatile 关键字 通过 Object类的 wait/notify 方法 通过 condition 的 await/signal 方法 通过 join 的方式 现在有一个问题，两个线程分别打印字符串，但是当线程A每输出两次的时候，线程B就输出一次，如此反复10次。 通过 volatile 关键字 通过
java实现线程间通信的四种方式
Hadwin1991的博客
06-21 1万+
java实现线程间通信的三种方式
rt-thread线程的使用
04-28
RT-Thread是一个开源的嵌入式实时操作系统，支持多线程、优先级调度、软件定时器、动态内存管理等特性。下面是RT-Thread线程的使用方法： 1. 创建线程：使用 `rt_thread_t` 结构体定义一个线程控制块，使用 `rt_thread_create()` 函数创建一个线程。 2. 启动线程：使用 `rt_thread_startup()` 函数启动线程。 3. 线程函数：线程函数是线程的执行体，可以在函数中实现需要执行的操作。线程函数的定义需要满足一定的格式要求。 4. 线程等待：线程可以调用 `rt_thread_delay()` 函数进行延时等待，也可以通过 `rt_thread_suspend()` 函数挂起线程等待某个条件的发生。 5. 线程退出：线程可以通过调用 `rt_thread_exit()` 函数来结束自己的执行。 6. 线程优先级：线程可以使用 `rt_thread_control()` 函数来设置自己的优先级和时间片等调度参数。 7. 线程通信：线程之间可以通过消息队列、信号量、互斥量等方式进行通信和同步。 以上是RT-Thread线程的基本使用方法，具体实现需要参考RT-Thread的文档和示例代码。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值