线程间通信 等待唤醒机制 wait notify notifyAll lock Condition唤醒 停止线程interrupt 守护线程setDaemon join yield

最新推荐文章于 2021-12-11 08:00:00 发布
最新推荐文章于 2021-12-11 08:00:00 发布
阅读量618 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010209842/article/details/39963833
版权

线性间通信

就是多个线程在操作同一个资源，但是操作的动作不同。

简单例子：银行，是管钱的地方，有人往里存钱，有人往外取钱，同时进行。

wait； notify（）；notifyAll()；

都是用在同步中，因为要对持有的监视器（锁）的线程操作。

所以要使用在同步中，因为只有在同步中才具有锁。


为什么这些操作线程的方法要定义Object类中呢？

因为这些方法在操作同步中线程时，都必须要标识他们所操作线程只有的锁。

只有同一个锁上的被等待线程，可以被同一个锁上notify唤醒。

不可以对不同锁中的线程进行唤醒。

等待和唤醒必须是同一个锁。

而锁可以是任意对象，所以可以被任意对象调用的方法定义Object类中。

class Res
{
	String name;
	String sex;
	boolean flag = false;
}

class Input implements Runnable
{
	private Res r;
	Input(Res r)
	{
		this.r =r ;
	}

	public void run()
	{
		int x = 0;
		while(true)
		{
			synchronized(r)
			{

				if(r.flag)
					try{r.wait();}catch(Exception e){}
				if (x==0)
				{
				r.name = "mike";
				r.sex = "man";
				}
				else
				{
				r.name = "lily";
				r.sex = "men";
				}
				x=(x+1)%2;
				r.flag=true;
				r.notify();
			}
			
		}
	}
}

class Output implements Runnable
{
	private Res r;
	Output(Res r)
	{
		this.r =r ;
	}

	public void run()
	{
		while(true)
		{
			synchronized(r)
			{
			if (!r.flag)
				try{r.wait();}catch(Exception e){}
				System.out.println(r.name+"---"+r.sex);
				r.flag=true;
				r.notify();
			}
		}
	}
}

class Test
{
	public static void main(String[] args)
	{
		Res r = new Res();

		Input in = new Input(r);
		Output out = new Output(r);

		Thread t1 = new Thread (in);
		Thread t2 = new Thread (out);

		t1.start();
		t2.start();


	}
}

代码优化 

class Res
{
	private String name;
	private String sex;
	private boolean flag = false;
	
	public synchronized void set(String name, String sex)
	{
		if (flag)
			try{this.wait();}catch(Exception e){}
		this.name = name;
		this.sex = sex;
		flag = true;
		this.notify();
	}
	public synchronized void out()
	{
		if (!flag)
			try{this.wait();}catch(Exception e){}
		System.out.println(name+"--"+sex);	

		flag = false;
		this.notify();
	}
}

class Input implements Runnable
{
	private Res r;
	Input(Res r)
	{
		this.r =r ;
	}

	public void run()
	{
		int x = 0;
		while(true)
		{
				if (x==0)
					r.set("mike","man" );
				else
					r.set("lily","men" );
				x=(x+1)%2;	
		}
	}
}

class Output implements Runnable
{
	private Res r;
	Output(Res r)
	{
		this.r =r ;
	}

	public void run()
	{
		while(true)
		{
			r.out();
		}
	}
}

class Test
{
	public static void main(String[] args)
	{
		Res r = new Res();

		new Thread(new Input(r)).start();
		new Thread(new Output(r)).start();


	}
}

当出现多个生产者和消费者同时生产东西的时候。

使用while循环，并使用notifyAll唤醒全部。

为什么要定义while判断标记。

原因：让被唤醒的线程再一次判断标记。

为什么定义notify。

因为需要唤醒对方线程。

因为只用notify，容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。

class Test
{
	public static void main(String[] args)
	{
		Resource r = new Resource();

		Producer pro =new Producer(r);
		Consumer con =new Consumer(r);

		Thread t1 =new Thread(pro); 
		Thread t2 =new Thread(pro); 
		Thread t3 =new Thread(con); 
		Thread t4 =new Thread(con); 

		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}
class Resource
{
	private String name;
	private int count=1;
	private boolean flag = false;

	public synchronized void set(String name)
	{
		while(flag)
		try{this.wait();}catch (Exception e){}
		this.name = name+"--"+count++;

		System.out.println (Thread.currentThread().getName()+"。生产者>>>"+this.name);
		flag= true;
		this.notifyAll();
	}
	public synchronized void out()
	{	
		while(!flag)
			try{this.wait();}catch(Exception e){}
		System.out.println (Thread.currentThread().getName()+"。消费者____"+this.name);
		flag=false;
		this.notifyAll();
	}
}
class Producer implements Runnable
{
	private Resource res;
	Producer(Resource res)
	{
		this.res= res;
	}
	public void run()
	{
		while(true)
		{
			res.set("+商品+");
		}
	}
}

class Consumer implements Runnable
{
	private Resource res;
		Consumer(Resource res)
		{
			this.res= res;
		}
		public void run()
		{
			while(true)
			{
				res.out();
			}
		}
}

JDK1.5中提供了多线程升级解决方案。

将同步synchronized替换成了现实Lock操作。

将Object中的wait，notify，notifyAll，替换类Condition对象。

await代替wait，signal代替notify，signalAll代替notifyAll

condition对象可以同时支持多个对象锁，可以分别对对象进行等待和唤醒。

该对象可以Lock锁 进行获取。

finally 释放锁 一定要执行。

该示例中，实现了本方只唤醒对方的操作。

private Lock lock = new ReentrantLock ();
private Condition condition_pro = lock.newCondition();

private Condition condition_con = lock.newCondition();

import java.util.concurrent.locks.*;

class Test
{
	public static void main(String[] args)
	{
		Resource r = new Resource();

		Producer pro =new Producer(r);
		Consumer con =new Consumer(r);

		Thread t1 =new Thread(pro); 
		Thread t2 =new Thread(pro); 
		Thread t3 =new Thread(con); 
		Thread t4 =new Thread(con); 

		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}

class Resource
{
	private String name;
	private int count=1;
	private boolean flag = false;
	private Lock lock = new ReentrantLock ();
	private Condition condition_pro = lock.newCondition();
	private Condition condition_con = lock.newCondition();

	public  void set(String name) throws InterruptedException 
	{
		lock.lock();
		try
		{
			while(flag)
				condition_pro.await();
			this.name = name+"--"+count++;

			System.out.println (Thread.currentThread().getName()+"。生产者>>>"+this.name);
			flag= true;
			condition_con.signal();
		}	
		finally 
		{
			lock.unlock();
		}
		
	}
	public  void out() throws InterruptedException
	{	
		lock.lock();
		try
		{
			while(!flag)
				condition_con.await();
			System.out.println (Thread.currentThread().getName()+"。消费者____"+this.name);
			flag=false;
			condition_pro.signal();
		}	
		finally 
		{
			lock.unlock();
		}
	}
}
class Producer implements Runnable
{
	private Resource res;
	Producer(Resource res)
	{
		this.res= res;
	}
	public void run()
	{
		while(true)
		{
			try
			{
				res.set("+商品+");
			}
			catch (InterruptedException e)
			{
			}
		}
	}
}

class Consumer implements Runnable
{
	private Resource res;
		Consumer(Resource res)
		{
			this.res= res;
		}
		public void run()
		{
			while(true)
			{
				try
				{
					res.out();
				}
				catch (InterruptedException e)
				{
				}
			}
		}
}

停止线程

停止线程，只有一种，就是run方法结束。

开启多线程运行，运行代码通常是循环结构。

只要控制循环，就可以让run方法结束，也就是线程结束。

class StopThread implements Runnable
{	
	private boolean flag =true;
	public void run()
	{

		while(flag)
		{
			System.out.println(Thread.currentThread().getName()+".....run");
		}	
	}
	public void changeFlag()
		{
			flag = false;
		}
}

class Test
{
	public static void main(String[] args)
	{
		StopThread st = new StopThread();

		Thread t1= new Thread(st);
		Thread t2= new Thread(st);
		
		t1.start();
		t2.start();

		int num = 0;

		while(true)
		{
			if(num++ ==10)
			{
				st.changeFlag();
				break;
			}
			System.out.println(Thread.currentThread().getName()+"...."+num);
		}
	}
}

interrupt（强制唤醒等待）

特殊情况

当线程处于了冻结状态。

就不会读取到标记。那么线程就不会结束。

当没有指定的方式让冻结的线程恢复到运行状态时，这时需要对冻结状态进行清除。

强制让线程恢复到运行状态中来，这样就可以操作标记让线程结束。

Thread提供了该方法：interrupt

class StopThread implements Runnable
{	
	private boolean flag =true;
	public synchronized void run()
	{
		while(flag)
		{
			try
			{
				wait();
			}
			catch (InterruptedException e)
			{
				System.out.println(Thread.currentThread().getName()+".....Exception");
				flag = false;
			}
			System.out.println(Thread.currentThread().getName()+".....run");
		}	
	}
	public void changeFlag()
		{
			flag = false;
		}
}

class Test
{
	public static void main(String[] args)
	{
		StopThread st = new StopThread();

		Thread t1= new Thread(st);
		Thread t2= new Thread(st);
		
		t1.start();
		t2.start();

		int num = 0;

		while(true)
		{
			if(num++ ==10)
			{
				t1.interrupt();
				t2.interrupt();
				break;
			}
			System.out.println(Thread.currentThread().getName()+"...."+num);
		}
	System.out.println("over");
	}
}
setDaemon

守护线程（跟随前台线程，只要主线程结束，守护线程跟着结束）

当正在运行的线程都是守护线程时，java虚拟机退出。

1守护线程必须在启动线程前调用。

2主线程结束，守护线程跟着结束。

class StopThread implements Runnable
{	
	private boolean flag =true;
	public  void run()
	{
		while(flag)
		{
			System.out.println(Thread.currentThread().getName()+".....run");
		}	
	}
	public void changeFlag()
		{
			flag = false;
		}
}
class Test
{
	public static void main(String[] args)
	{
		StopThread st = new StopThread();

		Thread t1= new Thread(st);
		Thread t2= new Thread(st);
		
		t1.setDaemon(true);
		t2.setDaemon(true);
		t1.start();
		t2.start();

		int num = 0;

		while(true)
		{
			if(num++ ==10)
			{
				break;
			}
			System.out.println(Thread.currentThread().getName()+"...."+num);
		}
	System.out.println("over");
	}
}
join

当A线程执行到了B线程的.join()方法时，A线程就会等待。等B线程都执行完，A才会执行。

join可以用来临时加入线程执行。

join夺取主线程权限，当join的线程运行完，才执行其他线程。

class Demo implements Runnable
{
	public void run()
	{
		for (int x=0;x<70 ;x++ )
		{
			System.out.println(Thread.currentThread().getName()+"-----"+x);
		}
	}
}

class Test
{
	public static void main(String[] args) throws Exception
	{
		Demo d = new Demo();

		Thread t1 = new Thread(d);
		Thread t2 = new Thread(d);
		
		t1.start();
		t1.join();	 //t1要主线程的执行权；
		t2.start();

		for (int x=0;x<80 ;x++ )
		{
			System.out.println("main-----"+x);
		}
	System.out.println("over");
	}
}
toString
返回该线程的字符串表示形式，包括线程名称，优先级和线程组。

Thread[Thread-0,5,main]


优先级

1-10

默认优先级是5（1优先级最小，10优先级最大）

MAX PRIORITY 10级

MIN PRIORITY 1级

NORM PRIORITY 5级

                Demo d = new Demo();

		Thread t1 = new Thread(d);
		Thread t2 = new Thread(d);
		
		t1.start();
		
		t1.setPriority(Thread.MAX_PRIORITY);

		t2.start();
yield

暂缓线程执行

Thread.yield()

可以达到减缓线程执行，可以达到线程交替运行的效果

同时运行

class ThreadTest
{
	new Thread()
	{
		public void run()
		{
			for (int x=0;x<100 ;x++ )
			{
				Syetem.out.println(Thread.currentThread().getName()+"---"+x);
							}
		}
	}.start();

	for (int x=0;x<100 ;x++ )
		{
			Syetem.out.println(Thread.currentThread().getName()+"---"+x);
		}
		
	Runnable r = new Runnable()
	{
		publiec void run()
		{
			for (int x=0;x<100 ;x++ )
			{
				Syetem.out.println(Thread.currentThread().getName()+"---"+x);
			}
		}
	};
	new Thread(r).start();
}
逍遥单机君
关注
Java 并发编程：Java 线程模型介绍及使用
栗筝i的博客
08-01 369
Java 线程是指程序中可以独立执行的单个代码执行路径。Java 使用类和包来实现多线程编程。线程是并发编程的基础，可以提高应用程序的性能，特别是在处理 I/O 密集型或 CPU 密集型任务时。线程（Thread）：是一个独立的执行单元，可以与其他线程并发执行；进程（Process）：是一个正在执行的程序，每个进程至少包含一个线程（主线程）；多线程（Multithreading）：在同一进程内同时运行多个线程，以实现并发处理。
【Java多线程】并发编程不得不知的重要概念(持续更新)
墩墩分墩
07-24 782
1. 串行：一个线程执行到底，相当于单线程。 2. 并发：多个线程交替执行，抢占cpu的时间片，但是速度很快，在外人看来就像是多个线程同时执行。 3. 并行：多个线程在不同的cpu中同时执行。
java等待唤醒机制的使用（wait/notify）
qq_17441227的博客
03-07 632
1.B的调用A中obj对象的相关属性 package com.ckx.client; /** * 需求：B的执行需要等待A中obj对象的创建完成才能继续 * 因为B需要A中的obj对象搞事情 */ public class Wait2Notify { static Object obj; public static void main(String[] args){...
14.5 wait和notify方法 停止线程
KAIFAWORD的专栏
05-27 955
wait（）一个线程如果执行了wait方法，那个该线程会进入一个以锁对象为标识符的线程池中等待。等着中会释放资源。 notify（）如果一个线程开启了notify方法，那么久会唤醒以锁对象为标识符的线程中其中的一个。 notifyall（）唤醒全部的线程。 这个2个方法一定要用锁对象来调用。 stop（）停止线程//这个已经过时 500升水池 5进水，2出水
java线程唤醒与等待_java - 线程等待与唤醒
weixin_39671621的博客
02-12 222
概要wait(), notify(), notifyAll()等方法介绍在Object.java中，定义了wait(), notify()和notifyAll()等接口。wait()的作用是让当前线程进入等待状态，同时，wait()也会让当前线程释放它所持有的锁。而notify()和notifyAll()的作用，则是唤醒当前对象上的等待线程；notify()是唤醒单个线程，而notifyAll()...
Linux驱动的等待队列、轮询及内核线程
with_dream的博客
09-04 1352
1、简介根据不同需求，linux内核有不同I/O操作模型： 非阻塞： 进程在不能进行设备操作时，并不挂起，它或者放弃，或者不停地查询，直到可以进行操作为止 阻塞： 指在执行设备操作时，若不能获得资源，则挂起进程直到满足可操作条件后再进行各项操作等待队列： 用来阻塞或唤醒一个进程，实现阻塞I/O访问 轮询操作: 阻塞I/O访问的应用程序通常使用select()和poll()系统调用查询机制来
线程lock锁 解决wait notify 问题的解决方案
yuliang20171205的博客
12-27 777
java多线程入门的源代码
03-28
`wait()`, `notify()`和`notifyAll()`用于线程间的通信，但必须在同步环境中使用，以避免死锁。 5. 线程池： Java 5引入了Executor框架，可以创建和管理线程池。ThreadPoolExecutor是核心类，它可以控制并发级别，...
Java 第三个模块 多线程面试题
菜鸟心声：学的不仅是技术，更是梦想！
12-11 800
第三个模块 多线程面试题1.并行和并发有什么区别？2.同步和异步的区别？3.程序、线程和进程的区别？4.守护线程是什么？5.创建线程有哪几种方式？6.说一下 runnable 和 callable 有什么区别？7.线程有哪些状态？8. sleep() 和 wait() 有什么区别？9.notify()和 notifyAll()有什么区别？10.线程的 run()和 start()有什么区别？11.创建线程池有哪几种方式？12.线程池中 submit()和 execute()方法有什么区别？13. 在 jav
Java多线程编程线程的协同、停止、暂停、继续等操作实现
08-08
当一个线程调用`wait()`时，它会释放当前持有的锁并进入等待状态，直到其他线程调用`notify()`或`notifyAll()`唤醒它。这种机制常用于实现生产者消费者模型或者哲学家就餐问题等经典并发问题。 2. **线程的停止** ...
java 线程wait()与notify()的用法(被唤醒后的线程到底重新执行同步代码块还是从那是等待的那里继续执行)
热门推荐
hbgCSDN的专栏
12-05 2万+
java 线程wait()与notify()的用法(被唤醒后的线程到底重新执行同步代码块还是从那是等待的那里继续执行)   2013-09-24 22:15:58|  分类： java |举报 |字号 订阅 我们先来看看这两个方法的定义:       wait()   导致当前线程等待，直到其他线程调用此对象的 notify()方法或 notifyAll()方
Java多线程 之 线程等待与唤醒 wait(), notify(),notifyAll()
萧曳丶
06-09 1660
文章目录1. wait(), notify(), notifyAll()等方法介绍2. wait()和notify()示例3. wait(long timeout)和notify()4. wait() 和 notifyAll()5. 为什么notify(), wait()等函数定义在Object中，而不是Thread中 1. wait(), notify(), notifyAll()等方法介绍  ...
Lock与Condition结合，等待通知机制await(),signal()与singanlAll()
sinat_33852001的博客
09-10 1136
java.util.concurrent并发包下 一.Lock显式锁性能比synchronized高很多。（1.6以后，synchronized已经优化过） 1.尝试非阻塞的获取锁 2.获取锁的过程中可以被中断 3.超时可以放弃获取锁 而线程在尝试获取synchronized(阻塞锁)的过程中不允许被中断。 二.Lock和synchronized锁的共同点：可重入，非公平。 1...
Java等待唤醒机制wait/notify深入解析
11-25 9586
本文将帮助你彻底弄明白Java的wait/notify等待唤醒机制。为了弄明白wait/notify机制，我们需要清楚线程通信、volatile和synchronized关键字、wait/notify方法、Object的monitor机制。本文将会从这几个方面详细讲解Java的wait/notify等待唤醒机制。 一、线程通信 如果一个线程从头到尾执行完也不和别的线程打交道的话，那就不会有各种安全性问题了。但是协作越来越成为社会发展的大势，一个大任务拆成若干个小任务之后...
17.多线程(2)
wu_intellect的博客
10-12 167
8.定时器 定时器可以用于比如系统每周删除一次日志文件,或者在指定日期关闭系统。 定时器类 import java.util.TimerTask; /** * 定时器 * 用于给线程任务定时操作 * */ public class MyTask extends TimerTask{ @Override public void run() { for (int i = 0; i <= 10; i++) { System.out.println(Thread.curren
线程间通信、等待唤醒机制、生产者消费者问题(Lock,Condition)、停止线程和守护线程、线程优先级...
weixin_30907523的博客
02-18 162
1线程间通信 1.1线程间通信 其实就是多个线程在操作同一个资源，但是操作的动作不同。 比如一个线程给一个变量赋值，而另一个线程打印这个变量。 1.2等待唤醒机制 wait()：将线程等待，释放了CPU执行权，同时将线程对象存储到线程池中。 notify()：唤醒线程池中一个等待的线程，若线程池有多个等待的线程，则任意唤醒一个。 notifyAll...
yolov10预训练模型.rar
11-05
在按照YOLOv10官网上的步骤进行时，运行app.py文件时，如果没有预训练模型的话会报错。解压压缩包里的内容到同级目录下（在requirements.txt文档下面），这样运行后就不会报错。
Linux Socket编程、IO模型及进程间通信的完整实用案例
最新发布
11-05
在IT领域，Linux系统是广泛应用于服务器和嵌入式设备的操作系统。对于系统开发者和管理员，深入理解Linux的Socket编程、IO模型以及进程间通信（IPC）是至关重要的。本资料包提供了三个主要部分的学习资源：`process_comm`涉及进程间通信，`linux_socket`涵盖Socket编程，而`io_mode`则讨论Linux的IO模型。接下来，我们将详细探讨这些关键知识点。 让我们来看看**Linux Socket编程**。Socket是网络通信的基本接口，它允许两个或多个进程通过网络进行数据交换。在Linux中，Socket编程通常涉及到以下步骤：创建Socket，绑定IP地址和端口号，监听连接请求，接受连接，发送和接收数据，最后关闭Socket。`linux_socket`目录可能包含了示例代码，演示如何创建TCP或UDP Socket，处理并发连接，以及实现基本的错误处理机制。理解Socket编程有助于开发网络服务，如Web服务器、FTP服务器等。 我们来讨论**Linux IO模型**。在Linux中，有五种主要的IO模型：阻塞IO、非阻塞IO、IO复用（
apsw-3.38.5.post1-cp310-cp310-win_amd64.whl.rar
11-05
python whl离线安装包 pip安装失败可以尝试使用whl离线安装包安装 第一步 下载whl文件，注意需要与python版本配套 python版本号、32位64位、arm或amd64均有区别 第二步 使用pip install XXXXX.whl 命令安装，如果whl路径不在cmd窗口当前目录下，需要带上路径 WHL文件是以Wheel格式保存的Python安装包， Wheel是Python发行版的标准内置包格式。 在本质上是一个压缩包，WHL文件中包含了Python安装的py文件和元数据，以及经过编译的pyd文件， 这样就使得它可以在不具备编译环境的条件下，安装适合自己python版本的库文件。 如果要查看WHL文件的内容，可以把.whl后缀名改成.zip，使用解压软件（如WinRAR、WinZIP）解压打开即可查看。 为什么会用到whl文件来安装python库文件呢？ 在python的使用过程中，我们免不了要经常通过pip来安装自己所需要的包， 大部分的包基本都能正常安装，但是总会遇到有那么一些包因为各种各样的问题导致安装不了的。 这时我们就可以通过尝试去Python安装包大全中（whl包下载）下载whl包来安装解决问题。
Java线程等待唤醒机制详解：wait(), notify()与notifyAll()
在实际应用中，wait(), notify()和notifyAll()通常与条件变量（如java.util.concurrent.locks.Condition）结合使用，以提供更高级别的线程同步和通信机制。这些方法的正确使用需要配合适当的同步机制，如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值