黑马程序员--第十二天：线程间的通信

最新推荐文章于 2024-05-20 21:03:21 发布
最新推荐文章于 2024-05-20 21:03:21 发布
阅读量500 收藏
点赞数
分类专栏： 黑马程序员--学习笔记 文章标签： 黑马程序员
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/F781492604/article/details/9121655
版权

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------

 

//12-1_3

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

class Input implements Runnable
{
	Res r = new Res();
	Input(Res r){
		this.r = r;
	}
	public void run(){
		int y = 0;
		int x = 0;
		while(y<1000){
			y++;
			x = (x + 1)%2;
			
			synchronized(new Object()){//只要是唯一的就可以，Input.class,OutPut.class,Res.class,Demo.class.
			if(r.flag)
				try{r.wait();}catch(Exception e){}
			if(x == 0){
			r.name = "mike";
			r.sex = "male";}
			else{
			r.name = "丽丽";
			r.sex = "女";}

			r.flag = true;
			r.notify();
			}

			
			//System.out.println(x);

			//break;
		}
	}
}

class Output implements Runnable
{
	Res r = new Res();
	Output(Res r){
		this.r = r;
	}
	public void run(){
		int y =0;
		while(y<1000){
			y++;
			synchronized(new Object()){//只要是唯一的就可以，Input.class,OutPut.class,Res.class,Demo.class.
			if(!r.flag)
				try{r.wait();}catch(Exception e){}
			System.out.println(r.name+"..."+r.sex);
			r.flag = false;
			r.notify();
			}
			//break;
		}
	}
}


class  Demo
{
	public static void main(String[] args) 
	{
		Res r = new Res();
		new Thread(new Input(r)).start();
		new Thread(new Output(r)).start();
		System.out.println("Hello World!");
	}
}


//notigyAll();

/*
wait();
notify();
notifyAll();

都使用在同步中，因为要对持有监视器(锁)的线程的操作
所以要使用在同步中，因为只有同步才具有锁。

为什么这些操作线程的方法要定义在Object的类中呢？
因为这些方法在操作同步中的线程时，都必须要标志他们所操作的线程持有的锁。
只有同一个锁上的被等待的线程，可以被同一个锁上的notify唤醒。
不可以对不同锁中的线程进行唤醒。

也就是说，等待和唤醒必须是同一个锁。

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

//12-4
class Res 
{
	private String name;
	private String sex;
	private boolean flag = false;

	public synchronized void set(String name,String sex){
		if(flag)
				try{wait();}catch(Exception e){}
		this.name = name;
		this.sex = sex;
		flag = true;
		notify();
	}

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

class Input implements Runnable
{
	Res r = new Res();
	Input(Res r){
		this.r = r;
	}
	public void run(){
		int y = 0;
		int x = 0;
		while(y<1000){
			y++;
			x = (x + 1)%2;
			if(x == 0)
				r.set("mike","male");
			else
				r.set("丽丽","女");
		}
	}
}

class Output implements Runnable
{
	Res r = new Res();
	Output(Res r){
		this.r = r;
	}
	public void run(){
		int y =0;
		while(y<1000){
			y++; 
			r.out();
		}
	}
}


class  Demo
{
	public static void main(String[] args) 
	{
		Res r = new Res();
		new Thread(new Input(r)).start();
		new Thread(new Output(r)).start();
		System.out.println("Hello World!");
	}
}
/*12-5
对于多个生产者和消费者，
为什么要定义while判断标记？
原因：让唤醒的线程再一次判断

为什么定义notifyAll？
因为要唤醒对方线程。
英文只用notify，容易出现只唤醒本方线程的情况。导致程序中的所以线程都等待。
*/

class Resource
{
	private String name;
	private int count = 1;
	private boolean flag = false;

	public synchronized void set(String name){
		while(flag)//多个生产者与消费者的情况必须保证唤醒的线程再次判断flag
			try{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{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("product");
		}
	}
}

class Consumer implements Runnable
{
	private Resource res;
	Consumer (Resource res){
		this.res = res;
	}

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

class  ResDemo
{
	public static void main(String[] args) 
	{
		Resource r = new Resource();
		new Thread(new Producer(r)).start();
		new Thread(new Producer(r)).start();
		new Thread(new Consumer(r)).start();
		new Thread(new Consumer(r)).start();
		System.out.println("Hello World!");
	}
}
/*12-6
JDK5.0 (新特性)
提供了多线程升级解决方案。
将同步synchronized 替换成现实Lock操作。
将Object中wait，notify notifyAll，替换成了Condition对象。
该对象可以Lock锁进行获取。
该实例中，实现了本方只唤醒对方的操作。
*/
import java.util.concurrent.locks.*;

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)//多个生产者与消费者的情况必须保证唤醒的线程再次判断flag
			condition_pro.wait();
		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.wait();
		System.out.println(Thread.currentThread().getName()+"...消费者...+++"+this.name);
		flag = false;
		condition_pro.signal();//
		}finally{
			lock.unlock();//lock 能个检测死锁。
		}
	}
}

class Producer implements Runnable
{
	private Resource res;

	Producer (Resource res){
		this.res = res;
	}

	public void run(){
		while (true)
		{
			try{
			res.set("product");}
			catch(Exception e){}
		}
	}
}

class Consumer implements Runnable
{
	private Resource res;
	Consumer (Resource res){
		this.res = res;
	}

	public void run(){
		while (true)
		{
			try{
			res.out();
			}catch(Exception e){}
		}
	}
}

class  ResDemo
{
	public static void main(String[] args) 
	{
		Resource r = new Resource();
		new Thread(new Producer(r)).start();
		new Thread(new Producer(r)).start();
		new Thread(new Consumer(r)).start();
		new Thread(new Consumer(r)).start();
		System.out.println("Hello World!");
	}
}
/*12-7
stop 方法已过时。

如何停止线程？
只有一种，run方法结束。
开启多线程运行，运行代码通常是循环结构。

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


特殊情况：当线程处于冻结状态。就不会读取到标记。那么线程就不会结束。

当没有指定的方式让冻结的线程恢复到运行状态时，就需要对冻结进行清除。
强制让线程恢复到运行状态中来。这样就可以操作标记让线程结束。

Thread类提供该方法是 interrupt();
*/

class  StopThread implements Runnable
{
	private boolean flag = true;
	public synchronized void run(){//若 wait() 等的方法没有在synchronized 修饰区域，
				//编译可以通过，方法可以运行，当会抛出异常。
		while(flag){
			try
			{
				wait();
			}
			catch (Exception e)
			{
				System.out.println(Thread.currentThread().getName()+"catch");
			}
			System.out.println(Thread.currentThread().getName()+"...生产者.");
		}
	}

	public void changeFlag(){
		flag = false;
	}
}
class  StopDemo
{
	public static void main(String[] args) 
	{
		StopThread st = new StopThread();
		Thread t1 = new Thread(st);
		Thread t2 = new Thread(st);

		t1.start();
		t2.start();
		System.out.println("Hello World!");

		int num = 0;

		while (true)
		{
			if(num++ == 60){
		/*		//个人扩展的方法
				synchronized(st){
					st.notifyAll();//程序可以正常结束，不会产生异常。
				}//------------		*/
				
				t1.setDeamon(true);
				t2.setDeamon(true);//守护线程，后台线程，在所以前台线程都结束是，自动结束后台线程。
				t1.interrupt();//唤醒线程，抛出异常。
				t2.interrupt();
				st.changeFlag();
				break;
			}
			System.out.println(Thread.currentThread().getName()+"..."+num);
		}
	}
}

/* 12-8_10
12-9 join方法
join：
当A线程执行到了B线程的 .join()方法，A就会等待，等B线程都执行完，A才会执行。
join可以用来临时加入线程执行。


12-10 优先级与yield方法：
Thread.yield();//有助于平均 运行效果。临时释放执行权，减缓线程运行。
*/

class  StopThread implements Runnable
{
	private boolean flag = true;
	public synchronized void run(){//若 wait() 等的方法没有在synchronized 修饰区域，
				//编译可以通过，方法可以运行，当会抛出异常。
		while(flag){
			try
			{
				wait();
			}
			catch (Exception e)
			{
				System.out.println(Thread.currentThread().getName()+"catch");
			}
			System.out.println(Thread.currentThread().toString()+"...生产者.");
		}
	}

	public void changeFlag(){
		flag = false;
	}
}
class  StopDemo
{
	public static void main(String[] args) 
	{
		StopThread st = new StopThread();
		Thread t1 = new Thread(st);
		Thread t2 = new Thread(st);

		t1.start();
		t1.setPriority(Thread.MAX_PRIORITY);
		t2.start();
		System.out.println("Hello World!");

		int num = 0;

		while (true)
		{
			if(num++ == 60){
		/*		//个人扩展的方法
				synchronized(st){
					st.notifyAll();//程序可以正常结束，不会产生异常。
				}//------------		*/
				
				t1.setDeamon(true);
				t2.setDeamon(true);//守护线程，后台线程，在所以前台线程都结束是，自动结束后台线程。
				t1.interrupt();
				t2.interrupt();
				t1.join();//主线程会等到t1 线程结束后在运行。
				st.changeFlag();
				break;
			}
			System.out.println(Thread.currentThread().getName()+"..."+num);
		}
	}
}


---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ---------------------- 

F781492604
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
黑马程序员--线程篇
u013485029的专栏
04-07 812
《线程基础篇》 ----------------------------------------------------------------------------------------------------------------- 多线程概述：        进程：进程就是一个正在进行着的程序；        线程：就是进程中的一个独立的控制单元，线程在控制着进程的执行； 创
java 模式匹配_java模式匹配以及相应的例题
weixin_42397925的博客
02-19 263
publicclassPatternMatching{/**该方法用来判断子串是否存在于父串中若存在返回true，否则返回falsesearchMe表示父串，substring表示子串*/publicbooleanmatch(StringsearchMe,Stringsubstring){booleanflag=true;//flag表示标记变量，用来判断是否匹配...
工具类：判断实体对象中的全部属性是否都有值
北平～
12-16 3446
日常开发中，我们经常会遇到这样的场景，前端传来一个实体，我们需要将这个实体中的全部信息入库保存。但是因为数据库中的字段规定不能为空，所以在入库之前我们必须保证实体中的所有属性有值。 在业务中直接一个一个判断的话，就显得代码繁琐累赘了，所以我们可以封装一个工具类，专门用来进行实体中属性是否为空判断（或者判断有些属性是否使用了默认值比如integer）。 代码如下： public class CheckObjectIsNullUtils { /** * 判断对象属性是否全部有值（st
黑马程序员--Java基础学习(多线程)第十二天
shdoshzdd的博客
08-22 296
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- Java基础学习(多线程)第十二天 一，线程间通信 线程间通信：其实就是多个线程在操作同一个资源，但是操作的动作不同。 class Res { String name; String sex; boolean flag= false; public void set
黑马程序员---第四讲 多线程的应用（2）
六月有你的博客
12-29 251
第四讲 多线程的应用（2）一、线程安全问题的另一解决方案前面我们已经知道，同步代码块的锁是任意对象，同步方法的锁是this对象，静态方法的锁是类的字节码文件对象。但是前面的方法不够明确，我们很难看到代码是在哪锁的，又是在哪解锁的。为了更清晰的表达在哪里加锁，在哪里解锁，JDK5中提供了Lock锁。 代码实现如下：package cn.itcast_01;import java.util.concu
[学习笔记]黑马程序员-Hadoop入门视频教程
zhangyifeng_1995的博客
02-03 6219
[学习笔记]黑马程序员-Hadoop入门视频教程
黑马程序员--多线程
sinat_29779023的博客
07-26 571
——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——- 注：视频来源，毕向东老师的 JAVA 基础视频。一、线程和进程1）进程：是一个在执行中的程序。每一个进程都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。2）线程：就是进程中的一个独立的控制单元。线程在控制着进程的执行。3） 理解：一个进程中，至少有一个线程。在JVM 启动的时候会有一个进程叫java
黑马程序员--- 学习笔记(第十二天
﹉`葬伈
04-06 932
多线程之间的通信 其实就是多线程在操作同一资源,但是操作的动作不同 wait(); notify(); notifyAll(); 都使用在同步中,因为要对持有监视器的线程操作,所以都要使用在 同步中,因为只有同步才具有监视器 为什么这些操作线程方法要定义在Object类中呢? 因为这些方法在操作同步中的线程,都必须要在标识他们的操作线程只有 的锁,只有
书《微服务架构基础（Spring Boot+Spring Cloud+Docker）》-黑马程序员-学习笔记
最新发布
weixin_43873121的博客
05-20 1377
书：《微服务架构基础（Spring Boot+Spring Cloud+Docker）》-黑马程序员的学习笔记
黑马程序员安卓 笔记代码（包含源码） 第76期
01-26
【标题】"黑马程序员安卓 笔记代码（包含源码） 第76期" 提供的是安卓开发的相关学习资料，其中包含了源码，这通常意味着我们可以深入理解代码的实现细节和设计思路。作为第76期，这可能是一个长期系列教程的一部分...
黑马程序员Android视频教程
08-17
### 黑马程序员Android视频教程知识点解析 #### 一、Android基础概述 - **定义与特点**：Android是一种基于Linux内核（不包括GNU组件）的开源操作系统，主要用于移动设备。它由Google公司及其领导下的开放手机联盟...
黑马程序员入学Java精华总结
11-07
### 黑马程序员入学Java精华总结 #### 一、Java概述与基础知识 1. **何为编程？** - 编程是指通过编写计算机能够理解的指令来解决问题或完成特定任务的过程。这些指令通常被组织成算法，并使用某种编程语言实现。...
黑马程序员--javascript：27,29 邮件实例，注册表单实例。
F781492604的专栏
06-10 916
<!-- table {border:#3366FF 1px solid; widows:80%} table th, table td {border:#00FF00 1px solid; padding:10px} table th {background-color:#66FF99} table td {background-color:#FFCCFF} .
黑马程序员--java高新技术 26--javaBean,泛型，类加载器，代理spring小框架
F781492604的专栏
06-05 863
---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ----------------------   /*设计模式： Singleton: 单例模式 Factorty: 工厂模式 Iterator: 迭代器模式 Template: 模板模式 Coposite: 组合模式 Proxy: 代理模式 Decrator
黑马程序员--java高新技术 25--枚举，反射
F781492604的专栏
06-05 728
---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ----------------------   /*1.5 新特性总结： 静态导入 可变参数 增强for(foreach) 基本数据的自动拆装箱 枚举 泛型 */ /*25-2 API: Application Programming Interfac
黑马程序员--第二十五天：正则表达式
F781492604的专栏
06-02 675
---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ----------------------   /*25-1_4 正则表达式：符合一定规则的表达式。 作用：用于专门操作字符串。 特点：用一些特定的符合来表示一些代码操作。这样可以简化书写。 所以学习正则表达式就是在学习一些特殊符合的使用。 好处：可以简化
RT-Thread消息队列基础实验：线程通信与静态队列操作
4. 当线程间通信时，发送方使用`rt_mq_send()`将消息放入队列，接收方通过`rt_mq_recv()`从队列中取出消息。 通过这个实验，学习者不仅掌握了如何在RT-Thread环境中使用消息队列，还锻炼了对线程同步和并发处理的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值