黑马程序员——java——线程间的通讯 生产者与消费者

线程间的的通讯  生产者与消费者

public class TestDemos3
{
	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
{
	String name;
	String sex;
	}

class Input  implements Runnable
{
	private Object obj;
	private Res r;
	Input(Res r)
	{
		this .r = r;
	}
	public void run()
	{
		 boolean b = false;
		while(true)
		{
		    synchronized(Input.class)
		    {
		       if(b)
		       {
		    	    r.name="张三";
		    	    r.sex="男";
		    	    b=false;
		       }
		       else
		       {
		    	   r.name = "kk";
		    	   r.sex = "woman";
		    	    b=true;
		       }
		    }
		}
	}
	}
class Output implements Runnable

{
    private Res r;
    private Object obj;
    Output(Res r)
    {
    	this.r = r;
    }
    public void run()
    {
    	while(true)
    	{
    		synchronized(Input.class)
    		{
    		    System.out.println(Thread.currentThread().getName()+r.name+": "+r.sex);
    	    }
    	}
    }
}

等待唤醒机制

public class TestDemos3
{
	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 t3 = new Thread(in);
		Thread t2 = new Thread(out);
		Thread t4 = new Thread(out);

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

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

class Input  implements Runnable
{
	private Object obj;
	private Res r;

	Input(Res r)
	{
		this .r = r;
	}
	public void run()
	{
		 boolean b = false;
		while(true)
		{
		    synchronized(r)
		    {
		    	if(r.flag)
		    	{
					try {
						  r.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
		    	}
		       if(b)
		       {
		    	    r.name="张三";
		    	    r.sex="男";
		    	    b=false;
		       }
		       else
		       {
		    	   r.name = "kk";
		    	   r.sex = "woman";
		    	    b=true;
		       }
		       r.flag=true;
		       r.notify();
		    }
		}
	}
	}
class Output implements Runnable

{
    private Res r;
    private Object obj;
    Output(Res r)
    {
    	this.r = r;
    }
    public void run()
    {
    	while(true)
    	{
    		synchronized(r)
    		{
    			if(!r.flag)
    			{
					try {
						r.wait();
					} catch (InterruptedException e)
					{
						e.printStackTrace();
					}
    			}
    		    System.out.println(Thread.currentThread().getName()+r.name+": "+r.sex);
    	            r.flag=false;
    	            r.notify();
    		}
    	}
    }
}

运行程序:

多线程演示生产者与消费者示例

public class ProduceConsumDemos
{

	public static void main(String[] args)
	{
		Ress r = new Ress();

		Inputs in = new Inputs(r);
		Outputs out = new Outputs(r);

		Thread t = new Thread(in);
		Thread t1 = new Thread(in);

		Thread t2 = new Thread(out);
		Thread t3 = new Thread(out);

		t.start();
		t1.start();
		t2.start();
		t3.start();

	}

}

class Ress
{
	private String name;
	private boolean blag = false;
	private int count=0;

	public synchronized void setInput(String name )
	{
		while(blag)
		{
			try
			{
				 wait();
			} catch (InterruptedException e)
			{
				e.printStackTrace();
			}
		}

		this.name = name+"--"+count++;
		System.out.println(Thread.currentThread().getName()+"生产者-"+this.name);
		blag=true;
		this.notifyAll();

	}

	public synchronized void out()
	{
		while(!blag)
		{
			try
			{
				wait();
			} catch (InterruptedException e)
			{
				e.printStackTrace();
			}
		}

		System.out.println(Thread.currentThread().getName()+"消费者---"+this.name);
		blag=false;
		this.notifyAll();

	}
	}

class Inputs implements Runnable
{
	private Ress r;

	Inputs(Ress r)
	{
		this.r=r;
	}
	public void run()
	{

		while(true)
		{
				r.setInput("商品");
		}
	}
}

class Outputs implements Runnable
{
	private Ress r;
	Outputs(Ress r)
	{
		this.r = r;
	}
	public void run()
	{
		while(true)
		    r.out();
	}
}

加入Lock

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

public class Test3
{

	public static void main(String[] args)
	{
		System.out.println("text3启动");
		Resii r = new Resii();

		Inputii in = new Inputii(r);
		Outputii out = new Outputii(r);

		Thread t1 = new Thread(in);
		Thread t2 = new Thread(in);
		Thread t3 = new Thread(out);
		Thread t4 = new Thread(out);
		t1.start();
		t2.start();
		t3.start();
		t4.start();
	}
}
class Resii
{
	private String name ;
	private boolean flag = false;
	private int count=0;

	private Lock lock = new ReentrantLock();
	private Condition conin = lock.newCondition();
	private Condition conout = lock.newCondition();
	public void set(String name )
	{
		lock.lock();
		while(flag)
		{
			try
			{
				conin.await();
			} catch (InterruptedException e)
			{
				e.printStackTrace();
			}
		}
		this.name = name+" :"+count++;
		System.out.println(Thread.currentThread().getName()+"生产者 "+this.name);
		flag = true;
		conout.signal();
		lock.unlock();
	}
	public void out()
	{
		lock.lock();
		while(!flag)
		{
			try
			{
				conout.await();
			} catch (InterruptedException e)
			{
				e.printStackTrace();
			}
		}
		System.out.println(Thread.currentThread().getName()+"消费者________"+this.name);
		flag = false;
		conin.signal();
		lock.unlock();
	}
}

class Inputii implements Runnable
{
	private Resii r;
	Inputii(Resii r)
	{
		this.r=r;
	}
	public void run()
	{
		while (true)
		{
			r.set("商品");
		}
	}
}

class Outputii implements Runnable
{
   private Resii r;
   Outputii(Resii r)
   {
	   this.r = r;
   }
   public void run()
   {
	   while (true)
	   {
		   r.out();
	   }
   }
}

时间: 2024-10-10 09:33:55

黑马程序员——java——线程间的通讯 生产者与消费者的相关文章

黑马程序员————java线程之间的通信

------<a href="http://www.itheima.com" target="blank">Java培训.Android培训.iOS培训..Net培训</a>.期待与您交流! ------- 多线程可以让我们同时共享一个资源,但如果在共享这个资源时需要彼此之间的联系怎么做呢? 经典实例:生产者与消费者. 问题描述,生产者每生产一个消费者就要取走一个,同时进行. 首先java为我们提供了一套等待唤醒机制,让线程与线程之间产生了联

黑马程序员——java基础——多线程

 黑马程序员--java基础--多线程 ------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 进程:是一个正在执行中的程序.每一个进程执行都有一个执行顺序.该顺序是一个执行路径,或者叫一个控制单元. 线程:就是进程中的一个独立的控制单元.线程在控制着进程的执行.一个进程中至少有一个线程. 一个进程至少有一个线程在运行,当一个进程中出现多个线程时,就称这个应用程序是多线程应用程序,每个线程在栈区中都有自己的执行空间,自己的方法区.自己的变量.

黑马程序员——Java多线程基础知识2

多线程协同 线程间的通讯:我们对资源的操作动作不同,比如说两个卡车一个拉煤一个装煤.但是他们共享了一个资源. 怎么样把这个资源拿出来?怎样把车装满?这个资源当然是一个类,他里面的组成元素就是对象!!现在我们就要有操作对象的思想了,我用对象把这车装满,现在一车装一个对象. 等待唤醒机制: 用的不是sleep是wait.flag标记,这是两人沟通的方式.其实每个标记就要做一次等待或者notify,判断wait,改值notify.线程池.notify唤醒里面的线程,按顺序唤醒.wait和notify必

黑马程序员——Java基础知识之多线程协同

多线程协同 线程间的通讯:对资源的操作动作不同,比如说两个卡车一个拉煤一个装煤,但是他们共享了一个资源. 怎么样把这个资源拿出来?怎样把车装满?这个资源当然是一个类,他里面的组成元素就是对象!!现在我们就要有操作对象的思想了,用对象把这车装满,现在一车装一个对象. 等待唤醒机制: 用的不是sleep是wait.flag标记,这是两人沟通的方式.其实每个标记就要做一次等待或者notify,判断wait,改值notify.线程池.notify唤醒里面的线程,按顺序唤醒.wait和notify必须用在

黑马程序员——Java网络编程之UDP传输

网络编程 网络模型 通讯要素:InetAddress(对象):ip地址,网络中设备的标识,不可记忆,可用主机名,本地回环地址:127.0.0.1主机名localhost 端口号 传输协议:UDP,将数据的源及目的封装成数据包中,不需要建立连接,每个数据包的大小限制在64K内,无连接,是不可靠协议,不需要建立连接,速度快.力求速度,不求数据的准确性.比如聊天软件,网络会议. TCP:建立连接,形成传输数据的通道,在连接中进行大数据量传输,通过三次握手完成连接,是可靠协议,必须建立连接效率稍低. S

黑马程序员---Java多线程

---------------------- Android开发.java培训.期待与您交流! ---------------------- 线程与进程是程序运行中体现的两个名词,它包含这不同的程序域.进程指的是一个正在运行的程序,如:360,QQ运行时就是不同的两个进程.当你打开windows任务管理器时,看到的每个进程就是此时windows中正在运行的程序.线程则就是进程中的一个个独立的控制单元,线程控制着进程的执行,也就是说每个正在运行的程序中就包括着很多的线程. 主线程:Java虚拟机运

黑马程序员–Java之多线程09

黑马程序员–Java之多线程09 一.线程和进程 在Java中,并发机制非常重要,程序员可以在程序中执行多个线程,每一个线程完成一个功能,并与其他线程并发执行,这种机制被称为多线程.多线程就是指一个应用程序中有多条并发执行的线索,每条线索都被称作一个线程,它们会交替执行,彼此间可以进行通信.多线程是非常复杂的机制,在每个操作系统中的运行方式也存在差异,window操作系统是多任务操作系统,它以进程为单位.一个进程是一个包含有自身地址的程序,每个独立执行的程序都称为进程,也就是正在执行的程序.系统

黑马程序员——Java基础---IO(下)

黑马程序员——Java基础---IO(下) ------<a href="http://www.itheima.com" target="blank">Java培训.Android培训.iOS培训..Net培训</a>.期待与您交流! ------ 一.概述 Java除了基本的字节流.字符流之外,还提供了File类.properties类.打印流.序列流等和输入输出相关的类,它们能够帮助我们更好的处理信息.下面将对它们进行简单的介绍. 一.正

黑马程序与----java线程学习

线程,有时被称为轻量级进程(Lightweight Process,LWP),是程序执行流的最小单元.一个标准的线程由线程ID,当前指令指针(PC),寄存器集合和堆栈组成.另外,线程是进程中的一个实体,是被系统独立调度和分派的基本单位,线程自己不拥有系统资源,只拥有一点儿在运行中必不可少的资源,但它可与同属一个进程的其它线程共享进程所拥有的全部资源.一个线程可以创建和撤消另一个线程,同一进程中的多个线程之间可以并发执行.由于线程之间的相互制约,致使线程在运行中呈现出间断性.线程也有就绪.阻塞和运