java笔记-多线程-线程通信

最新推荐文章于 2024-06-25 16:45:21 发布
最新推荐文章于 2024-06-25 16:45:21 发布
阅读量641 收藏
点赞数
分类专栏： 走走
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cs_ing/article/details/38264797
版权


多线程间的通信：

//多线程间通信。
//功能：
//    1.Input类向资源中写入信息；
//    2.Output类从资源中读取信息；

//共享资源类；
class Res{
	String name;
	String sex;
}
//实现Runnable接口的类；
class Input implements Runnable{
	//定义共享资源的类参数，然后传递给构造函数；
	//目的是操作同一个共享资源的对象；
	Res r;
	Input(Res r){
		this.r=r;
	}
	//重写Runnable接口的run方法；
	public void run(){
		int x=0;
		while(true){
			//上锁；
			//由于操作同一资源，需和Output上的锁一致。
			//这样一旦上锁，另外一个操做共享资源的函数就不能操作共享数据。
			synchronized(Input.class){
				if(x==0){
					r.name="---a";
					r.sex="boy";
				}
				else{
					r.name="+++b";
					r.sex="girl";
				}
				x=(x+1)%2;
			}
			
		}
	}
}
class Output implements Runnable{
	Res r;
	Output(Res r){
		this.r=r;
	}
	public void run(){
		while(true){
			//上锁；
			//由于操作同一资源，需和Iuput上的锁一致。
			//这样一旦上锁，另外一个操做共享资源的函数就不能操作共享数据。
			synchronized(Input.class){
				System.out.println(r.name+"......"+r.sex);
			}
		}
	}
}
class InputOutputDemo{
	public static void main(String[] args){	
		Res r=new Res();
		//使两个线程操作同一对象。
		Output out=new Output(r);
		Input in=new Input(r);
		//构建两个线程，虽然是两个线程，但操作的是同一个对象中的共享资源。
		Thread t1=new Thread(in);
		Thread t2=new Thread(out);
		//启动线程。
		t1.start();
		t2.start();
	}
}

多线程的唤醒等待机制

//多线程间通信。
//功能：
//    1.Input类向资源中写入信息；
//    2.Output类从资源中读取信息；

//共享资源类；
class Res{
	String name;
	String sex;
	//定义读写操作完成标识。flag为真：有未读的数据，flag为假：数据已读
	boolean flag=false;
}
//实现Runnable接口的类；
class Input implements Runnable{
	//定义共享资源的类参数，然后传递给构造函数；
	//目的是操作同一个共享资源的对象；
	Res r;
	Input(Res r){
		this.r=r;
	}
	//重写Runnable接口的run方法；
	public void run(){
		int x=0;
		while(true){
			//上锁；
			//由于操作同一资源，需和Output上的锁一致。
			//这样一旦上锁，另外一个操做共享资源的函数就不能操作共享数据。
			synchronized(r){
				if(r.flag)	//若数据未读则等待。wait()定义时抛出异常。
					//调用wait方法将自身操作挂起，直到同一个对象上的锁以某种方式将其改变改变，并调用notify方法通知该代码块改变已经完成。
					try{r.wait();}catch(Exception e){}
				if(x==0){
					r.name="---a";
					r.sex="boy";
				}
				else{
					r.name="+++b";
					r.sex="girl";
				}
				x=(x+1)%2;
				//写完数据表明有数据未读，置未读标识符。
				r.flag=true;
				//notify()唤醒一个处于等待状态的线程。不能确切的唤醒特定的线程，
				//具体唤醒哪个线程由jvm决定，并且不是按照优先级。
				r.notify();
			}
			
		}
	}
}
class Output implements Runnable{
	Res r;
	Output(Res r){
		this.r=r;
	}
	public void run(){
		while(true){
			//上锁；
			//由于操作同一资源，需和Iuput上的锁一致。
			//这样一旦上锁，另外一个操做共享资源的函数就不能操作共享数据。
			synchronized(r){
				if(!r.flag){
					//么有未读数据则等待，直到另一线程存储了新的数据并唤醒该线程
					try{r.wait();}catch(Exception e){}
				}
				System.out.println(r.name+"......"+r.sex);
				//数据读取完毕，重置数据读取状态标识符。
				r.flag=false;
				//数据读取完毕，唤醒处于等待状态的线程。
				//notify()唤醒一个处于等待状态的线程。不能确切的唤醒特定的线程，
				//具体唤醒哪个线程由jvm决定，并且不是按照优先级。
				r.notify();
			}
		}
	}
}
class waitNotifyDemo{
	public static void main(String[] args){	
		Res r=new Res();
		//使两个线程操作同一对象。
		Output out=new Output(r);
		Input in=new Input(r);
		//构建两个线程，虽然是两个线程，但操作的是同一个对象中的共享资源。
		Thread t1=new Thread(in);
		Thread t2=new Thread(out);
		//启动线程。
		t1.start();
		t2.start();
	}
}
等待唤醒机制例程优化 

//多线程间通信。
//功能：
//    1.Input类向资源中写入信息；
//    2.Output类从资源中读取信息；

//共享资源类；
class Res{
	private String name;
	private String sex;
	//定义读写操作完成标识。flag为真：有未读的数据，flag为假：数据已读
	private boolean flag=false;
	//设置共享资源数据
	//由于是对共享数据操作，需上锁。
	public synchronized void set(String name,String sex){
		if(this.flag){
			try{this.wait();}catch(Exception e){}
		}
		this.name=name;
		this.sex=sex;
		flag=true;
		//唤醒处于等待状态的线程，注意此处使用this。
		this.notify();
	}
	//输出共享资源数据
	//由于是对共享数据操作，需上锁。
	public synchronized void out(){
		//没有未读数据则等待。
		if(!this.flag){
			try{this.wait();}catch(Exception e){}
		}
		System.out.println(name+"......"+sex);
		flag=false;
		//唤醒处于等待状态的线程，注意此处使用this。
		this.notify();
	}
}
//实现Runnable接口的类；
class Input implements Runnable{
	//定义共享资源的类参数，然后传递给构造函数；
	//目的是操作同一个共享资源的对象；
	Res r;
	Input(Res r){
		this.r=r;
	}
	//重写Runnable接口的run方法；
	public void run(){
		int x=0;
		while(true){
			if(x==0){
				r.set("-----A","--boy");
			}
			else{
				r.set("+++++B","++girl");
			}
			x=(x+1)%2;
		}
	}
}
class Output implements Runnable{
	Res r;
	Output(Res r){
		this.r=r;
	}
	public void run(){
		while(true){
			r.out();
		}
	}
}
class OptimizeThread{
	public static void main(String[] args){	
		Res r=new Res();
		//使两个线程操作同一对象。
		new Thread(new Output(r)).start();
		new Thread(new Input(r)).start();
		
		/*
		Output out=new Output(r);
		Input in=new Input(r);
		//构建两个线程，虽然是两个线程，但操作的是同一个对象中的共享资源。
		Thread t1=new Thread(in);
		Thread t2=new Thread(out);
		//启动线程。
		t1.start();
		t2.start();
		*/
	}
}

生产者消费者实例

class Resource{
	private String name;
	private int count=1;
	private boolean flag;
	public synchronized void set(String name){
		//此处使用if语句只判断一次，当有多个线程进入if语句并处于等待状态时，
		//容易爆发安全隐患。改为while。
		//此处的notify唤醒的应该是out语句中的线程，但notify唤醒的线程较单一
		//改为notifyAll。
		while(flag){	//使进入该语句并处于等待状态的多个线程唤醒时都判断flag
			try{
				wait();
			}
			catch(Exception e){
			
			}
		}
		this.name=name+"......"+count++;//此处将商品名称自动加上商品编号。
		System.out.println("\t\t\t++++++product::"+this.name);
		flag=true;
		this.notify();
	}
	public synchronized void out(){
		//此处使用if语句只判断一次，当有多个线程进入if语句并处于等待状态时，
		//容易爆发安全隐患。改为while。
		//此处的notify唤醒的应该是set语句中的线程，但notify唤醒的线程较单一
		//改为notifyAll。
		while(!flag){	//使进入该语句并处于等待状态的多个线程唤醒时都判断flag
			try{
				wait();
			}
			catch(Exception e){
			
			}
		}
		System.out.println("------consumer::"+this.name);
		flag=false;
		this.notifyAll();
	}
}
class consumer implements Runnable{
	private Resource r;
	public void run(){
		while(true){
			r.out();
		}
	}
	consumer(Resource r){
		this.r=r;
	}
}
class product implements Runnable{
	private Resource r;
	public void run(){
		while(true){
			r.set("商品");
		}
	}
	product(Resource r){
		this.r=r;
	}
}
class ProConDemo{
	public static void main(String[] args){
		Resource r=new Resource();
		product pro=new product(r);
		consumer con=new consumer(r);
		Thread p1=new Thread(pro);
		Thread c1=new Thread(con);
		Thread p2=new Thread(pro);
		Thread c2=new Thread(con);
		Thread p3=new Thread(pro);
		Thread c3=new Thread(con);
		
		p1.start();
		c1.start();
		p2.start();
		c2.start();
		p3.start();
		c3.start();
	}
}

本方线程只唤醒对方线程

/*
** JDK1.5中提供了多线程的升级解决方案。
** 将同步synchronized替换成显式Lock操作。
** 将Object中的wait,notify,notifyAll替换为Condition对象。
** 该对象可以通过Lock锁对象的方法获取。
** 该对象可以调用awake(),signal(),signalAll().

** 该实例实现了：本方线程只唤醒对方线程的操作。
*/
import java.util.concurrent.locks.*;
class Resource{
	private String name;
	private int count=1;
	private boolean flag;
	//创建Lock对象。
	final Lock lock=new ReentrantLock();
	//通过Lock对象的方法创建Condition对象。
	final Condition condition_con=lock.newCondition();
	final Condition condition_pro=lock.newCondition();
	public void set(String name)throws InterruptedException{	//awake方法提示有异常抛出
		//直接上锁。
		lock.lock();
		try{
			while(flag){
				condition_pro.await();		//挂起本方线程。
			}
			this.name=name+"......"+count++;//此处将商品名称自动加上商品编号。
			System.out.println("\t\t\t++++++product::"+this.name);
			flag=true;
			condition_con.signal();			//唤醒对方线程。
		}
		//无论程序如何运行，最后都要解锁。
		finally{
			lock.unlock();				
		}
	}
	public void out(){
		//直接上锁。
		lock.lock();
		try{
			while(!flag){	//使进入该语句并处于等待状态的多个线程唤醒时都判断flag
				try{
					condition_con.await();	//挂起本方线程。
				}
				catch(Exception e){
			
				}
			}
			System.out.println("------consumer::"+this.name);
			flag=false;
			condition_pro.signal();			//唤醒对方线程。
		}
		//无论程序如何运行，最后都要解锁。
		finally{
			lock.unlock();
		}
	}
}
class consumer implements Runnable{
	private Resource r;
	public void run(){
		try{								//捕捉定义的out方法中的异常。
			while(true){
				r.out();
			}
		}
		catch(Exception e){
			
		}
	}
	consumer(Resource r){
		this.r=r;
	}
}
class product implements Runnable{
	private Resource r;
	public void run(){
		try{								//捕捉定义的set方法中的异常。
			while(true){
				r.set("商品");
			}
		}
		catch(Exception e){
		}
		
	}
	product(Resource r){
		this.r=r;
	}
}
class newLock{
	public static void main(String[] args){
		Resource r=new Resource();
		product pro=new product(r);
		consumer con=new consumer(r);
		Thread p1=new Thread(pro);
		Thread p2=new Thread(pro);
		Thread p3=new Thread(pro);
		Thread c1=new Thread(con);
		Thread c2=new Thread(con);
		Thread c3=new Thread(con);
		
		p1.start();
		p2.start();
		p3.start();
		c1.start();
		c2.start();
		c3.start();	
	}
}

中断线程

//线程的中断。
//线程的运行一般都是循环结构。只要构建中断循环标识就ok。
//对于上锁的线程，需要使用：对象.interrupt();来完成。
//interrupt激活冻结(等待)的线程。
class breakThread implements Runnable{
	//构建循环中断标识。
	public boolean flag=true;
	public synchronized void run(){
		while(flag){
			try{
				//线程一进入即进入冻结状态。
				wait();
			}
			//捕获中断异常标识，然后置循环中断标识。
			catch(InterruptedException e){
				System.out.println("Breaking Thread....");	
				flag=false;
			}
			System.out.println(Thread.currentThread().getName()+".....run.");
		}
		System.out.println("Thread Over.");
	}
	public void changeFlage(){
		flag=false;
	}
}
class StopThread{
	public static void main(String[] args){
		int num=0;
		breakThread bt=new breakThread();
		Thread t=new Thread(bt);
		t.start();
		
		while(true){
			if(++num==60){
				System.out.println("need to stop thread!");
				//num为60置线程中断，其实是激活冻结(等待)的线程。。
				t.interrupt();				
				break;
			}
			System.out.println("Main Thread run......"+num);
		}
	}
}

守护线程

//守护线程；
//当运行的线程全部为守护线程时，java虚拟机退出。
//守护线程可理解为守护前台线程，但前台线程结束，后台线程(守护线程)也就么有存在的必要了。
//守护线程开启必须在守护线程启动之前。
class breakThread implements Runnable{
	//构建循环中断标识。
	public boolean flag=true;
	public synchronized void run(){
		System.out.println(Thread.currentThread().getName()+".....run.");
	}
}
class StopThread{
	public static void main(String[] args){
		int num=0;
		breakThread bt=new breakThread();
		Thread t=new Thread(bt);
		//守护线程开启必须在线程启动之前。
		t.Daemon(true);
		t.start();
		
		while(true){
			if(++num==60){
				System.out.println("Stop main thread。");		
				//一旦main线程结束，只剩下t守护线程，java虚拟机退出。	
				break;
			}
			System.out.println("Main Thread run......"+num);
		}
	}
}

线程join方法

//join方法
//当A线程执行到了B线程的join方法时，A就会等待，等待B线程都执行完，A才会执行。
class Demo implements Runnable
{
	public void run(){
		for(int x=0;x<60;x++){
			System.out.println(Thread.currentThread().getName()+"....."+x);
		}		
	}
}
class joinDemo{
	public static void main(String[] args)throws Exception{
		Demo d=new Demo();
		Thread t1=new Thread(d);
		Thread t2=new Thread(d);
		
		t1.start();
		//加入join表明，t1线程申请获得cpu执行权，main线程暂时冻结。待t1线程执行完毕，main线程恢复。
		t1.join();
		t2.start();
		//若在t1，t2线程启动后执行t1.join(),则main线程冻结，t1和t2线程交替执行，main线程只等待t1线程结束后即恢复运行。
		
		for(int y=0;y<60;y++){
			System.out.println(Thread.currentThread().getName()+"..."+y);
		}
		System.out.println("Main thread over.");
	}
}


Cs1275
关注
专栏目录
狂神说java--多线程笔记（及源码）
fllow_wind的博客
05-10 1350
多线程 1.线程 进程 多线程 多线程：多条执行路径，主线程与子线程并行交替执行（普通方法只有主线程一条路径）。 程序：指令和数据的有序集合，本身没有任何运行的含义，是一个静态的概念。 进程：在操作系统中运行的程序就是进程，即执行程序的一次执行过程，是一个动态的概念。 一个进程可以有多个线程，比如视频中同时听声音，看图像，看弹幕等。 线程是CPU调度和执行的基本单位。 注意： ​ 很多多线程是模拟出来的，真正的多线程是指有多个cpu，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个
Java学习笔记-多线程
haozhzhzh的博客
09-09 3696
4-5 多线程 线程与进程 进程 是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间 线程 是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换，并发执行，一个进程最少有一个线程 线程实际上是进程基础之上的进一步划分，一个进程启动之后，里面的若干执行路径又可以划分成若干个线程 线程调度 分时调度 所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU时间 抢占式调度 优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选
Java并发编程-多线程个人笔记
最新发布
weixin_53836048的博客
06-25 1753
参考自JavaGuide
B站【狂神说Java笔记】-多线程
闲言
08-03 3727
目录狂神视频地址1.任务2.进程3.多线程4.Thread 和Runnable小结5.案例：龟兔赛跑6.静态代理7.Lambda表达式8.线程状态9.线程休眠（sleep）10.线程礼让（yield）11.线程强制执行：（join）12.线程优先级13.守护(daemon)线程14.队列和锁15.死锁16.Lock（锁）17.线程池 狂神视频地址 https://www.bilibili.com/video/BV1V4411p7EF 1.任务   生活中的例子、边吃饭、边玩手机   开车、打电话、挂点滴
Java多线程学习笔记 - 1
涞公子的博客
03-13 2509
多任务 概述： 多任务就是同时运行多个任务。 好处： 充分利用了CPU的资源，提高了代码的执行效率。 执行方式： 并发：在一段时间内交替去执行多项任务【任务数 > 核数】 并行：多个计算机内核一起执行任务，一个内核负责执行一个任务【任务数 <= 核数】 实现方式： 多线程或多进程。 进程与线程介绍： 进程 概述： 线程 概述： 进程与线程之间的关系 一个进程内含有一个或多个线程，但至少含有一个线程。 ...
java基础---多线程知识点
weixin_41563161的博客
10-24 1914
目录 1、多线程有什么用？ 2、创建线程的方式 3、start()方法和run()方法的区别 4、Runnable接口和Callable接口的区别 5、CyclicBarrier和CountDownLatch的区别 6、volatile关键字的作用 7、什么是线程安全 8、Java中如何获取到线程dump文件 9、一个线程如果出现了运行时异常会怎么样 10、如何在两个线程之间共...
万字图解Java多线程
热门推荐
qq_35598736的博客
09-06 6万+
前言 java多线程我个人觉得是javaSe中最难的一部分，我以前也是感觉学会了，但是真正有多线程的需求却不知道怎么下手，实际上还是对多线程这块知识了解不深刻，不知道多线程api的应用场景，不知道多线程的运行流程等等，本篇文章将使用实例+图解+源码的方式来解析java多线程。 文章篇幅较长，大家也可以有选择的看具体章节，建议多线程的代码全部手敲，永远不要相信你看到的结论，自己编码后运行出来的，才是自己的。 什么是java多线程? 进程与线程 进程 当一个程序被运行，就开启了一个进程， 比如启动了qq，w.
Java学习笔记-线程状态
cyh0503的博客
07-08 2750
线程状态概述 当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，有几种状态呢？在APi中java.lang.Thread.State这个枚举中给出了六种线程状态： 这里先列出哥哥线程状态发生的条件，下面将会对每种状态进行详细解析 线程状态 导致状态发生条件 NEW（新建） 线程刚被创建，但是并未启动。还没调用start方法。 R...
Java多线程个人学习笔记
Tylers_zhang的博客
02-23 962
Java多线程个人学习笔记Java Concurrency Java多线程2021.2.21 并发与并行2 线程与进程3 线程调度4 主线程5 创建线程类5.1创建多线程程序的第一种方式-创建Thread的子类5.2 多线程原理-随机性打印的原理5.3 多线程与原理-多线程内存图解5.4 创建多线程程序的第二种方式-实现Runnable接口（尽量使用这种，不要盲目使用第一种）5.5 Thread和Runnable的区别5.6 匿名内部类方式实现线程的创建（需要加深理解，反复看）6 Thread类的常用方法6
java多线程基础学习[狂神说java-多线程笔记]
Alivorth的博客
11-08 1124
java多线程基础学习一、线程简介1.类比2.程序进程线程3.线程的核心概念二、线程的实现(重点)调用方法与调用多线程的区别Thread 类1.thread使用方法2. 代码实现3.应用Runnable 接口1.Runable使用方法2. 代码实现3.应用Callable接口1.Callable使用方法2.代码实现三、线程的状态线程的5个状态线程方法观察线程的状态线程的优先级守护线程（daemon）四、线程同步同步方法与同步块死锁Lock(锁)五、线程协作生产者消费者模式线程池 一、线程简介 所有的资料来
零基础Java入门课程-多线程
07-01
在IT行业中，Java是一种广泛应用的编程语言，尤其在企业级...文档"零基础Java入门课程-多线程-20201217202008101.docx"很可能是课程的详细讲义或笔记，包含了上述知识点的详细解释和实例，建议仔细研读，以加深理解。
基于Java的源码-多线程反射泛型及正则表达式学习笔记和源码.zip
07-23
《深入理解Java多线程、反射、泛型与正则表达式》 在Java编程领域，多线程、反射、泛型以及正则表达式是四个至关重要的概念，它们为开发者提供了强大的工具，使得程序更加高效、灵活且可维护。这份学习资料包括了...
基于java的开发源码-多线程反射泛型及正则表达式学习笔记和源码.zip
03-25
线程间的通信和同步是多线程编程的关键，Java提供了synchronized关键字、wait()、notify()和notifyAll()方法、Lock接口（如ReentrantLock）等工具来确保线程安全。在学习笔记中，你可能会看到如何创建、启动、控制和...
java笔记--
04-16
本笔记将深入探讨Java的基础知识和核心概念。 1. **Java基础** - **语法**：Java语法与C++类似，但更加简洁。例如，Java使用垃圾回收机制自动管理内存，避免了C++中的内存泄漏问题。 - **类与对象**：Java是面向...
java笔记-IO流-字节打印流
cs.Ing
08-12 1849
PrintStream将各种数据类型的数据原样打印。 PrintStream 字节打印流 构造函数可以接收的参数类型 1.File对象 ：File 2.字符串路径：String 3.字节输出流：FileOutputStream  PrintWriter  字符打印流  构造函数可以接收的参数类型 1.File对象 ：File 2.字符串路径：String 3.字节输出
BOM&DOM基础
cs.Ing
09-22 1297
一、知识回顾     * BOM 概述     browser object modal :浏览器对象模型。     浏览器对象：window对象。     Window 对象会在 或 每次出现时被自动创建。     * BOM 的各个对象          * window对象                 innerHeight，innerWidth          
java笔记-集合框架-泛型、Map集合
cs.Ing
08-04 1179
泛型限定 /* 泛型的限定： ? extends E:可以接收E类型或者E类型的子类，上限。 ? super E:可以接收E类型或者E类型的父类型。下限。 ?：为通配符或者占位符。 由于迭代器中内容的类型不同，使用泛型输出不同类型内容的集合。 */ import java.util.*; class GenerationLimits { public static void ma
java笔记-GUI编程
cs.Ing
08-13 1136
GUI（图形用户界面） Graphical User Interface(图形用户接口)
java笔记-IO流-管道流
cs.Ing
08-12 1131
对象的存储和
Java多线程学习笔记：从基础到深入
资源摘要信息:"多线程笔记_java/多线程_" 知识点： 1. 多线程基础概念： 在Java中，线程（Thread）是程序执行流的最小单位，是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值