java架构学习——3. 多线程之间实现通讯

最新推荐文章于 2021-04-21 22:31:26 发布
最新推荐文章于 2021-04-21 22:31:26 发布
阅读量211 收藏
点赞数
分类专栏： java架构学习 文章标签： 多线程 线程通讯
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wmq_fly/article/details/83064428
版权

本篇博文主要包含：

  • 多线程之间通讯
  • synchronized保证多线程安全
  • wait、notify、notifyAll方法在synchronized中的用法及解决重复消费问题
  • wait与sleep的区别
  • Lock锁（手动）
  • Lock 接口与 synchronized 关键字的区别
  • Lock锁中使用Condition类控制线程的等待与唤醒
  • 如何停止线程
  1. 什么是多线程之间通讯？
    多线程之间通讯，其实就是多个线程在操作同一个资源，但是操作的动作不同。例如：第一个线程写入(input)用户，另一个线程取读取(out)用户.实现读一个，写一个操作。
    代码演示：
/**
 * 共享资源源实体类
 *
 */
class People{
	String name;
	String sex;
}

/**
 * 写线程类
 *
 */
class OutputThread extends Thread{
	People people;
	public OutputThread(People people) {
		this.people = people;
	}
	
	@Override
	public void run() {
		int count = 0 ;
		while(true) {
				if(count==0) {
					people.name = "方向";
					people.sex = "女";
				}else {
					people.name = "目标";
					people.sex = "男";
				}
			count = (count+1)%2;
		}
	}
}

/**
 * 读线程类
 *
 */
class InputThread extends Thread{
	People people;
	public InputThread(People people) {
		this.people = people;
	}
	
	@Override
	public void run() {
		while(true) {
			System.out.println(people.name+",  "+people.sex);
		}
	}
}

public class OutInputThread {
	public static void main(String[] args) {
		//共享people对象
		People people = new People();
		
		OutputThread out = new OutputThread(people);
		InputThread input = new InputThread(people);
		
		out.start();
		input.start();
	}
}

运行结果：
在这里插入图片描述
由运行结果可以看出，数据发生错乱，造成线程安全问题。

  1. 加上synchronized关键字
/**
 * 共享资源源实体类
 *
 */
class People{
	String name;
	String sex;
}

/**
 * 写线程类
 *
 */
class OutputThread extends Thread{
	People people;
	public OutputThread(People people) {
		this.people = people;
	}
	
	@Override
	public void run() {
		int count = 0 ;
		while(true) {
			//解决线程安全问题加上synchronized
			synchronized(people) {
				if(count==0) {
					people.name = "方向";
					people.sex = "女";
				}else {
					people.name = "目标";
					people.sex = "男";
				}
			}
			count = (count+1)%2;
		}
	}
}

/**
 * 读线程类
 *
 */
class InputThread extends Thread{
	People people;
	public InputThread(People people) {
		this.people = people;
	}
	
	@Override
	public void run() {
		while(true) {
			//解决线程安全问题加上synchronized
			synchronized(people) {
				System.out.println(people.name+",  "+people.sex);
			}
		}
	}
}

public class OutInputThread {
	public static void main(String[] args) {
		//共享people对象
		People people = new People();
		
		OutputThread out = new OutputThread(people);
		InputThread input = new InputThread(people);
		
		out.start();
		input.start();
	}
}

运行结果：
在这里插入图片描述
线程安全问题解决了，但是消费者在重复消费。如何解决这个问题呢？我们使用wait()、notify()处理这个问题。

  1. wait()、notify、notifyAll()方法
    wait()、notify()、notifyAll()是三个定义在Object类里的方法，可以用来控制线程的状态。
    这三个方法最终调用的都是jvm级的native方法。随着jvm运行平台的不同可能有些许差异。
    （1）如果对象调用了wait方法就会使持有该对象的线程把该对象的控制权交出去，然后处于等待状态。
    （2）如果对象调用了notify方法就会通知某个正在等待这个对象的控制权的线程可以继续运行。
    （3）如果对象调用了notifyAll方法就会通知所有等待这个对象控制权的线程继续运行。
    注意:一定要在线程同步中使用,并且是同一个锁的资源
    代码演示：
/**
 * 共享资源源实体类
 *
 */
class PeopleWaitNotify{
	String name;
	String sex;
	//
	Boolean flag = false;
}

/**
 * 写线程类
 *
 */
class OutputWaitNotifyThread extends Thread{
	PeopleWaitNotify people;
	public OutputWaitNotifyThread(PeopleWaitNotify people) {
		this.people = people;
	}
	
	@Override
	public void run() {
		int count = 0 ;
		while(true) {
			//解决线程安全问题加上synchronized
			synchronized(people) {
				if(people.flag) {
					try {
						// 当前线程变为等待（从运行状态变为等待状态），但是可以释放锁
						people.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				if(count==0) {
					people.name = "方向";
					people.sex = "女";
				}else {
					people.name = "目标";
					people.sex = "男";
				}
				//唤醒其他等待线程（从等待状态变为运行状态）
				people.notify();
				people.flag= true;
			}
			count = (count+1)%2;
			
		}
	}
}

/**
 * 读线程类
 *
 */
class InputWaitNotifyThread extends Thread{
	PeopleWaitNotify people;
	public InputWaitNotifyThread(PeopleWaitNotify people) {
		this.people = people;
	}
	
	@Override
	public void run() {
		while(true) {
			//解决线程安全问题加上synchronized
			synchronized(people) {
				if(!people.flag) {
					try {
						people.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				System.out.println(people.name+",  "+people.sex);
				people.notify();
				people.flag = false;
			}
		}
	}
}

public class WaitNotifyOutInputThread {
	public static void main(String[] args) {
		//共享people对象
		PeopleWaitNotify people = new PeopleWaitNotify();
		
		OutputWaitNotifyThread out = new OutputWaitNotifyThread(people);
		InputWaitNotifyThread input = new InputWaitNotifyThread(people);
		
		out.start();
		input.start();
	}
}

运行结果：
在这里插入图片描述
使用wait()、notify()实现消费者重复消费问题，即生产者线程消费一个，消费者线程立马消费； 生产者没有任何生产，消费者不能读；消费者，没有消费完，生产者不能在继续生产。

注意：wait()、notify()及notifyAll()是用在synchronized代码块内的

  1. wait与sleep的区别
    （1） 对于sleep()方法，我们首先要知道该方法是属于Thread类中的。而wait()方法，则是属于Object类中的。
    sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持着，当指定的时间到了又会自动恢复运行状态。
    （2）在调用sleep()方法的过程中，线程不会释放对象锁。
    而当调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备获取对象锁进入运行状态。
  2. Lock锁
    在 jdk1.5 之后，并发包中新增了 Lock 接口(以及相关实现类)用来实现锁功能，Lock 接口提供了与 synchronized 关键字类似的同步功能，但需要在使用时手动获取锁和释放锁。

（1）lock的写法：

Lock lock  = new ReentrantLock();
lock.lock();
try{
//可能会出现线程安全的操作
}finally{
//一定在finally中释放锁
//也不能把获取锁在try中进行，因为有可能在获取锁的时候抛出异常
  lock.ublock();
}

（2）Lock 接口与 synchronized 关键字的区别

  • Lock 接口可以尝试非阻塞地获取锁 当前线程尝试获取锁。如果这一时刻锁没有被其他线程获取到，则成功获取并持有锁。
  • Lock 接口能被中断地获取锁 与 synchronized 不同，获取到锁的线程能够响应中断，当获取到的锁的线程被中断时，中断异常将会被抛出，同时锁会被释放。
  • Lock 接口在指定的截止时间之前获取锁，如果截止时间到了依旧无法获取锁，则返回。
  • synchronized的缺点：效率低、扩展性不好、不能自动化
    代码演示：
/**
 * 共享资源源实体类
 *
 */
class People{
	String name;
	String sex;
}

/**
 * 写线程类
 *
 */
class OutputThread extends Thread{
	People people;
	public OutputThread(People people) {
		this.people = people;
	}
	
	@Override
	public void run() {
		int count = 0 ;
		while(true) {
			//解决线程安全问题加上synchronized
			synchronized(people) {
				if(count==0) {
					people.name = "方向";
					people.sex = "女";
				}else {
					people.name = "目标";
					people.sex = "男";
				}
			}
			count = (count+1)%2;
		}
	}
}

/**
 * 读线程类
 *
 */
class InputThread extends Thread{
	People people;
	public InputThread(People people) {
		this.people = people;
	}
	
	@Override
	public void run() {
		while(true) {
			//解决线程安全问题加上synchronized
			synchronized(people) {
				System.out.println(people.name+",  "+people.sex);
			}
		}
	}
}

public class OutInputThread {
	public static void main(String[] args) {
		//共享people对象
		People people = new People();
		
		OutputThread out = new OutputThread(people);
		InputThread input = new InputThread(people);
		
		out.start();
		input.start();
	}
}
  1. Condition用法
    在synchronized中使用wait()、notify()控制线程的等待与唤醒，而在Lock锁中使用Condition。
    Condition的功能类似于在传统的线程技术中的,Object.wait()和Object.notify()的功能。

代码演示：

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

/**
 * 共享资源源实体类
 *
 */
class PeopleLock{
	String name;
	String sex;
	boolean flag = false;
	//在共享资源里定义lock锁
	Lock lock = new ReentrantLock();
}

/**
 * 写线程类
 *
 */
class OutputLockThread extends Thread{
	PeopleLock people;
	Condition newCondition;
	
	public OutputLockThread(PeopleLock people,Condition newCondition) {
		this.people = people;
		this.newCondition = newCondition;
	}
	
	@Override
	public void run() {
		int count = 0 ;
		while(true) {
			try {
				//开启锁
				people.lock.lock();
				
				if(people.flag) {
					try {
						// 当前线程变为等待（从运行状态变为等待状态），但是可以释放锁
						newCondition.await();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				if(count==0) {
					people.name = "方向";
					people.sex = "女";
				}else {
					people.name = "目标";
					people.sex = "男";
				}
				count = (count+1)%2;
				people.flag= true;
				//唤醒其他等待线程（从等待状态变为运行状态）
				newCondition.signal();
				
			} catch (Exception e) {
				e.printStackTrace();
			}finally {
				//关闭锁
				people.lock.unlock();
			}
		}
	}
}

/**
 * 读线程类
 *
 */
class InputLockThread extends Thread{
	PeopleLock people;
	Condition newCondition;
	
	public InputLockThread(PeopleLock people,Condition newCondition) {
		this.people = people;
		this.newCondition = newCondition;
	}
	
	@Override
	public void run() {
		while(true) {
			try {
				//开启锁
				people.lock.lock();
				if(!people.flag) {
					try {
						// 当前线程变为等待（从运行状态变为等待状态），但是可以释放锁
						newCondition.await();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				System.out.println(people.name+",  "+people.sex);
				people.flag= false;
				//唤醒其他等待线程（从等待状态变为运行状态）
				newCondition.signal();
				
			} catch (Exception e) {
				e.printStackTrace();
			}finally {
				//关闭锁
				people.lock.unlock();
			}
		}
	}
}

public class LockThread {
	public static void main(String[] args) {
		//共享people对象
		PeopleLock people = new PeopleLock();
		//同一个newCondition
		Condition newCondition = people.lock.newCondition();
		
		OutputLockThread out = new OutputLockThread(people,newCondition);
		InputLockThread input = new InputLockThread(people,newCondition);
		
		out.start();
		input.start();
	}
}

运行结果：
在这里插入图片描述
使用Lock锁和Condition代替synchronized和wait()、notify()。

  1. 如何停止线程

（1） 使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。

代码演示：

class StopThread extends Thread{
	//使用volatile关键字保证原子可见性
	private volatile boolean flag = true;
	
	@Override
	public void run() {
		System.out.println("子线程运行begin。。。。。");
		while(flag) {
			
		}
		System.out.println("子线程运行end。。。。。");
	}
	
	public void stopThread() {
		this.flag = false;
	}
}


public class StopThreadDemo {
	public static void main(String[] args) {
		StopThread stopThread = new StopThread();
		stopThread.start();
		
		for(int i=0; i<5; i++) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(i);
			if(i==3) {
				stopThread.stopThread();
			}
		}
	}
}

运行结果：
在这里插入图片描述

（2） 使用stop方法强行终止线程（这个方法不推荐使用，因为stop和suspend、resume一样，也可能发生不可预料的结果），不可恢复。

代码演示：

class StopThread extends Thread{
	//使用volatile关键字保证原子可见性
	private volatile boolean flag = true;
	
	@Override
	public void run() {
		System.out.println("子线程运行begin。。。。。");
		while(flag) {
			
		}
		System.out.println("子线程运行end。。。。。");
	}
}


public class StopThreadDemo {
	public static void main(String[] args) {
		StopThread stopThread = new StopThread();
		stopThread.start();
		
		for(int i=0; i<5; i++) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(i);
			if(i==3) {
				stopThread.stop();
			}
		}
	}
}

运行结果：
在这里插入图片描述
（3） 使用interrupt方法中断线程。

代码演示：

class StopThread extends Thread{
	//使用volatile关键字保证原子可见性
	private volatile boolean flag = true;
	
	@Override
	public void run() {
		System.out.println("子线程运行begin。。。。。");
		while(flag) {
			try {
				wait();
			} catch (Exception e) {
				stopThread();
				e.printStackTrace();
			}
		}
		System.out.println("子线程运行end。。。。。");
	}
	
	public void stopThread() {
		this.flag = false;
	}
}


public class StopThreadDemo {
	public static void main(String[] args) {
		StopThread stopThread = new StopThread();
		stopThread.start();
		
		for(int i=0; i<5; i++) {
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			System.out.println(i);
			if(i==3) {
				//当前等待的线程直接抛出异常
				stopThread.interrupt();
			}
		}
	}
}

运行结果：
在这里插入图片描述

wmq_fly
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java使用WMQ实现远程通讯.docx
05-25
Java客户端将消息发送到客户端队列，消息经过通道到达远程队列。使用java服务端程序读取消息
wmq.jmsra-7.0.1.3.rar
04-28
wildfly standalone deployments中的wmq.jmsra-7.0.1.3.rar
传统方式实现三个线程之间的通信: notify与notifyAll
li346985170的专栏
12-30 680
使用notify方法只唤醒一个线程(任意唤醒一个), 而notifyAll则唤醒该对象监视器上等待的所有线程,被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争 /////////////////////////////////////这里用notify会有问题,但是用notifyAll就可以实现.但对于notifyAll我还是不太懂 public class Tradi
（三）多线程之间实现通讯
冷夜轩的博客
06-28 173
多线程之间实现通讯多线程之间如何实现通讯什么是多线程之间通讯？多线程之间通讯，其实就是多个线程在操作同一个资源，但是操作的动作不同。多线程之间通讯需求案例:第一个线程写入(input)用户，另一个线程取读取(out)用户；实现读一个，写一个操作。 代码实战：共享资源源实体类/** 共享资源源实体类 */ class UserInfo { public String userSex; ...
Java——多线程那些问题
热门推荐
在此立一个IT职业上的flag：https://github.com/Zeb-D/my-review
07-19 1万+
Java多线程问题总结 多线程有什么用？ （1）发挥多核CPU的优势 单核CPU上所谓的”多线程”那是假的多线程，同一时间处理器只会处理一段逻辑，只不过线程之间切换得比较快，看着像多个线程”同时”运行罢了。多核CPU上的多线程才是真正的多线程，它能让你的多段逻辑同时工作，多线程，可以真正发挥出多核CPU的优势来，达到充分利用CPU的目的。 （2）防止阻塞 如果单核CPU使用单线程，...
《多线程系列五》一文读懂Java多线程框架原理
我是香菜
04-21 2316
目录 1、AQS 是什么？ 2、AQS 模型 3、AQS state 4、AQS 两种资源共享方式： 5、模板方式实现自定义 6、锁的分类:公平锁和非公平锁，乐观锁和悲观锁 7、CAS 8、总结 1、AQS 是什么？ AQS 是类 AbstractQueuedSynchronizer的简称，也是常用锁的基类，比如常见的ReentrantLock，Semaphore，CountDownLatch 等等。 AQS提供了一种实现阻塞锁和一系列依赖FIFO等待队列的同步器的框架。是Java..
Java 高并发编程详解：多线程与架构设计
GitChat
12-10 6838
内容简介 本书主要包含四个部分： 部分主要阐述 Thread 的基础知识，详细介绍线程的 API 使用、线程安全、线程间数据通信，以及如何保护共享资源等内容，它是深入学习多线程内容的基础。 第二部分引入了 ClassLoader，这是因为 ClassLoader 与线程不无关系，我们可以通过 synchronized 关键字，或者 Lock 等显式锁的方式在代码的编写阶段对共享资源进行数据一致...
Java全能学习面试手册——Java面试题库.zip
10-01
Java全能学习面试手册——Java面试题库.zip 01 7道消息队列ActiveMQ面试题！.pdf 02 10道Java高级必备的Netty面试题！.pdf 03 10道Java面试必备的设计模式面试题！.pdf 04 10个Java经典的List面试题！.pdf 05 10个...
Java全能学习面试手册——Java架构师进阶资料面试资料.zip
10-01
Java全能学习面试手册——Java架构师进阶资料面试资料.zip 01 7道消息队列ActiveMQ面试题！.pdf 02 10道Java高级必备的Netty面试题！.pdf 03 10道Java面试必备的设计模式面试题！.pdf 04 10个Java经典的List面试题！...
龟兔赛跑——Java程序设计课程多线程部分教学设计.pdf
12-06
龟兔赛跑——Java程序设计课程多线程部分教学设计.pdf
《Java语言程序设计——基础篇》第五章方法示例.zip
06-05
进阶篇主要介绍数据结构、高级GUI设计、多线程、集合架构、网络和Web程序设计、算法效率和排序、MVC，以及高级Java数据库程序设计等方面的内容，循序渐进，可读性强。《Java语言程序设计——基础篇》以示例讲解解决...
《Java语言程序设计——基础篇》第四章循环示例.zip
06-02
进阶篇主要介绍数据结构、高级GUI设计、多线程、集合架构、网络和Web程序设计、算法效率和排序、MVC，以及高级Java数据库程序设计等方面的内容，循序渐进，可读性强。《Java语言程序设计——基础篇》以示例讲解解决...
java架构学习——17. 表单重复提交&防止模拟请求&跨域解决方案&XSS攻击
wmq_fly的博客
02-15 719
一、http长连接与短连接 在HTTP/1.0中，默认使用的是短连接。也就是说，浏览器和服务器每进行一次HTTP操作，就建立一次连接，但任务结束就中断连接。如果客户端浏览器访问的某个HTML或其他类型的 Web页中包含有其他的Web资源，如JavaScript文件、图像文件、CSS文件等；当浏览器每遇到这样一个Web资源，就会建立一个HTTP会话。 但从 HTTP/1.1起，默认使用长连接，用以保...
java架构学习——15. Cookie与Session实现原理&外网映射工具的使用
wmq_fly的博客
02-15 457
一、Web开发入门 1、软件的结构 C/S (Client - Server 客户端-服务器端) 典型应用：QQ软件 ，飞秋，红蜘蛛。 特点： 1）必须下载特定的客户端程序。 2）服务器端升级，客户端升级。 B/S （Broswer -Server 浏览器端- 服务器端） 典型应用： 腾讯官方（www.qq.com） 163新闻网站， 蚂蚁课堂官网（俗称：网站） 特点： 1）不需要安装特定的...
java架构学习——13. 垃圾回收机制算法分析&使用Jmeter压力测试工具
wmq_fly的博客
02-14 351
一、基本概念 什么是垃圾回收机制？ 垃圾回收机制不定时，向堆内存清理不可达对象。 手动GC回收 代码演示： public class GcDemo { public static void main(String[] args) { GcDemo gc = new GcDemo(); //将对象设置为不可达，垃圾回收机制将对其进行回收 gc = null; //手动...
java架构学习——12. JVM参数调优配置
wmq_fly的博客
02-14 291
一、 自动内存管理机制 Java虚拟机原理 所谓虚拟机，就是一台虚拟的机器。他是一款软件，用来执行一系列虚拟计算指令，大体上虚拟机可以分为 系统虚拟机和程序虚拟机， 大名鼎鼎的Visual Box、Vmare就属于系统虚拟机，他们完全是对物理计算的仿真，提供了一个可以运行完整操作系统的软件平台。 程序虚拟机典型代码就是Java虚拟机，它专门为执行单个计算程序而计算，在Java虚拟机中执行的指令我...
java架构学习——4. java并发包&信号量&并发队列
wmq_fly的博客
02-12 270
一、同步容器类 Vector与ArrayList区别： ArrayList是最常用的List实现类，内部是通过数组实现的，它允许对元素进行快速随机访问。数组的缺点是每个元素之间不能有间隔，当数组大小不满足时需要增加存储能力，就要讲已经有数组的数据复制到新的存储空间中。当从ArrayList的中间位置插入或者删除元素时，需要对数组进行复制、移动、代价比较高。因此，它适合随机查找和遍历，不适合插...
java架构学习——5. 线程池原理剖析&锁的深度化
wmq_fly的博客
02-12 254
一、线程池 什么是线程池 Java中的线程池是运用场景最多的并发框架，几乎所有需要异步或并发执行任务的程序 都可以使用线程池。在开发过程中，合理地使用线程池能够带来3个好处。 第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。 第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。 第三：提高线程的可管理性。线程是稀缺资源，如果无限制地创建，不仅会消耗...
java架构学习——11. Netty高级
wmq_fly的博客
02-14 254
一、TCP粘包、拆包问题解决方案 什么是粘包/拆包 一个完整的业务可能会被TCP拆分成多个包进行发送，也有可能把多个小的包封装成一个大的数据包发送，这个就是TCP的拆包和封包问题。 下面可以看一张图，是客户端向服务端发送包： 1.） 第一种情况，Data1和Data2都分开发送到了Server端，没有产生粘包和拆包的情况。 2.）第二种情况，Data1和Data2数据粘在了一起，打成了一个大...
java如何实现多线程之间的通讯和协作？
最新发布
09-27
Java可以通过wait()、notify()、notifyAll()等方法实现多线程之间的通讯和协作。wait()方法可以使线程进入等待状态，直到其他线程调用notify()或notifyAll()方法唤醒它；notify()方法可以随机唤醒一个等待中的线程；...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值