多线程练习——等待唤醒

package 多线程;

public class ThreadcommunicateSafe1 {
	public static void main(String[] args) {
		Info3 mess= new Info3();
		Input3 in = new Input3(mess);
		Output3 out = new Output3(mess);
		new Thread(in).start();
		new Thread(out).start();
	}

}
//1,等待唤醒机制 实现 Input线程和Output线程交替获取执行全交替复活执行
class Info3{
	private String name;
	private String sex;
	private boolean flag;
	public synchronized void set(String name,String sex){
		if(flag)
			try {
				this.wait();
				this.name = name;
				this.sex = sex;
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		flag=false;
		this.notify();
	}
	public synchronized void sop(){
		if(!flag)
			try {
				this.wait();
				System.out.println(Thread.currentThread().getName()+"名字:"+name+"。。。。__性别:"+sex);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		flag = true;
		this.notify();
	}
}
class Input3 implements Runnable{
	Info3 info;
	int x = 0;
	public Input3(Info3 info) {

		this.info=info;
	}
	@Override
	public void run() {
		while (true) {
			if (x==0) {
				info.set("demo", "man");
			} else {
				info.set("丽丽", "女生");
			}
			x=(x+1)%2;
		}
	}
}
class Output3 implements Runnable{
	Info3 info;
	public Output3(Info3 info) {
		this.info=info;
	}
	public void run() {
		while (true) {
			info.sop();
		}
	}
}
//2,通过创建一个标记flag 让Input线程和Output线程交替执行代码 但是Input线程和Output线程 还是随机获取执行权
//class Info2{
//	String name;
//	String sex;
//	boolean flag;
//}
//class Input2 implements Runnable{
//	Info2 info;
//	int x = 0;
//	public Input2(Info2 info) {
//		this.info=info;
//	}
//	@Override
//	public void run() {
//		while (true) {
//			if(info.flag){
//				synchronized(info){
//				if (x==0) {
//					info.name = "demo";
//					info.sex = "man";
//				} else {
//					info.name = "莉莉";
//					info.sex = "女生";
//				}
//				x=(x+1)%2;
//				info.flag=false;
//				}
//			}
//		}
//	}
//}
//class Output2 implements Runnable{
//	Info2 info;
//	public Output2(Info2 info) {
//		this.info=info;
//	}
//	public void run() {
//		while (true) {
//			if(info.flag==false){
//				synchronized(info){
//				System.out.println("名字:"+info.name+"__性别:"+info.sex);
//				info.flag = true;
//				}
//			}
//
//		}
//	}
//}
时间: 2024-08-26 08:08:59

多线程练习——等待唤醒的相关文章

java基础知识回顾之java Thread类学习(八)--java多线程通信等待唤醒机制经典应用(生产者消费者)

 *java多线程--等待唤醒机制:经典的体现"生产者和消费者模型 *对于此模型,应该明确以下几点: *1.生产者仅仅在仓库未满的时候生产,仓库满了则停止生产. *2.消费者仅仅在有产品的时候才能消费,仓空则等待. *3.当消费者发现仓储没有产品可消费的时候,会唤醒等待生产者生产. *4.生产者在生产出可以消费的产品的时候,应该通知等待的消费者去消费. 下面先介绍个简单的生产者消费者例子:本例只适用于两个线程,一个线程生产,一个线程负责消费. 生产一个资源,就得消费一个资源. 代码如下: pub

java基础知识回顾之java Thread类学习(七)--java多线程通信等待唤醒机制(wait和notify,notifyAll)

1.wait和notify,notifyAll: wait和notify,notifyAll是Object类方法,因为等待和唤醒必须是同一个锁,不可以对不同锁中的线程进行唤醒,而锁可以是任意对象,所以可以被任意对象调用的方法,定义在Object基类中. wait()方法:对此对象调用wait方法导致本线程放弃对象锁,让线程处于冻结状态,进入等待线程的线程池当中.wait是指已经进入同步锁的线程,让自己暂时让出同步锁,以便使其他正在等待此锁的线程可以进入同步锁并运行,只有其它线程调用notify方

java多线程的等待唤醒机制及如何解决同步过程中的安全问题

/* class Person{ String name; String sex; boolean flag = true; public void setPerson(String name, String sex){ this.sex=sex; this.name=name; } } class Input implements Runnable{ int x=0; Person p; Input(Person p){ this.p=p; } public void run(){ while

java 22 - 17 多线程之等待唤醒机制(接16)

先来一张图,看看什么叫做等待唤醒机制 接上一章的例子. 例子:学生信息的录入和获取 * 资源类:Student  * 设置学生数据:SetThread(生产者) * 获取学生数据:GetThread(消费者) * 测试类:StudentDemo * 资源类:Student (为了使用等待唤醒机制,添加了个布尔类型的变量,默认为flase) 1 public class Student { 2 String name; 3 int age; 4 boolean flag; // 默认情况是没有数据

多线程的等待唤醒机制之消费者和生产者模式

/** * 等待唤醒之生产者和消费者模型 * 生成者: 创建和添加数据的线程 * 消费者: 销毁和删除数据的线程 * 问题1: 生成者生成数据过快, 消费者消费数据相对慢,不接收数据了, 会造成数据丢失 * 问题2: 消费者消费数据过快, 生成者生成数据相对慢,不发送数据了, 会造成数据被重复读取 * 总结 : 生产数据过快会造成数据丢失 * 生成数据过慢会造成数据被重复读取 * * * wait()和notifyAll()用法: * 1. 必须是同一个对象的wait()和和notifyAll(

多线程等待唤醒机制之生产消费者模式

上篇楼主说明了多线程中死锁产生的原因并抛出问题--死锁的解放方案,那么在本篇文章,楼主将引用一个KFC生产汉堡,顾客购买汉堡的过程来说明死锁解决方案及多线程的等待唤醒机制. 简单地用一幅图来说明KFC生产汉堡,顾客来消费的过程: 场景分析: 资源类:Hamburger 设置汉堡数据:SetThread(生产者) 获取汉堡数据:GetThread(消费者) 测试类:HamburgerTest 不同种类的线程(生产者.消费者)针对同一资源(汉堡)的操作 当汉堡有存货的时候,汉堡师傅不再生产,顾客可消

Java---18---多线程:等待唤醒机制

class Res { String name; String sex; } class Input implements Runnable { private Res r; public Input(Res r) { // TODO Auto-generated constructor stub this.r = r; } public void run() { int x = 0; while (true) { synchronized (r) { if (x == 0) { r.name

多线程之间的通信(等待唤醒机制、Lock 及其它线程的方法)

一.多线程之间的通信. 就是多个线程在操作同一份数据, 但是操作的方法不同. 如: 对于同一个存储块,其中有两个存储位:name   sex, 现有两个线程,一个向其中存放数据,一个打印其中的数据. 为了解决上述问题中的安全问题(在存放线程进行存放操作的时候, 打印线程不能对共有数据进行操作),所以应当对两个线程       操作共有数据的代码部分进行同步(使用synchronized(),来进行同步, 注意 :使用同一个对象作为同步锁. 二.等待唤醒机制. 在上述案例实现过后运行,会发现:打印

Java多线程(一)同步与等待唤醒

 1:数据安全问题 1.1:什么情况下会出现数据安全问题? 多个线程对同一个资源进行操作,并且操作资源的语句有多条.那么这个时候这些语句因为cpu的随机性,有可能被多个线程分开执行.导致数据安全问题. 例子:有3个人分别是你爸.你妈妈.你姐,去你的一个账户汇钱给你,每一个只能存3次,一次只能存100元.每存一次,请打显示出账户里的余额.代码体现: 1 public class SaveMoneyDemo1 { 2 3 public static void main(String[] args)