50--多线程（九）

线程的通信

常用方法介绍：
1.wait()：令当前线程挂起并放弃CPU、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其他线程调用notify()或notifyAll()方法唤醒，唤醒后等待重新获得对监视器的所有权后才能继续执行
1）在当前线程中调用方法：对象名.wait()
2）使当前线程进入等待（某对象）状态，直到另一线程对该对象发出 notify (或notifyAll) 为止。
3）调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）
4）调用此方法后，当前线程将释放对象监控权，然后进入等待
5）在当前线程被notify后，要重新获得监控权，然后从断点处继续代码的执行。

2.notify()：唤醒正在排队等待同步资源的线程中优先级最高者结束等待
3.notifyAll ()：唤醒正在排队等待资源的所有线程结束等待.
1）在当前线程中调用方法：对象名.notify()
2）功能：唤醒等待该对象监控权的一个/所有线程。
3）调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）

注意：
这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报 java.lang.IllegalMonitorStateException异常。
因为这三个方法必须有锁对象调用，而任意对象都可以作为synchronized的同步锁，因此这三个方法只能在Object类中声明。

实例

使用两个线程打印 1-100。线程1, 线程2 交替打印
实例：

package com.qwy17;
class MyThread implements Runnable{
    
    
	private static int num=1;
	@Override
	public void run() {
    
    
		printNum();
	}
	
	private  synchronized void printNum(){
    
    
		while(true){
    
    
			notify();
			if(num<=100){
    
    
				System.out.println(Thread.currentThread().getName()+",打印："+num);
				num++;
			}else{
    
    
				break;
			}
			try {
    
    
				wait();
			} catch (InterruptedException e) {
    
    
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}
public class PrintNumTest {
    
    
	public static void main(String[] args) {
    
    
		MyThread my= new MyThread();
		Thread t1 = new Thread(my);
		Thread t2 = new Thread(my);
		t1.setName("线程A");
		t2.setName("线程B");
		t1.start();
		t2.start();
					
		
	}
}

部分执行结果：
线程A,打印：1
线程B,打印：2
线程A,打印：3
线程B,打印：4
线程A,打印：5
…省略部分结果
线程A,打印：97
线程B,打印：98
线程A,打印：99
线程B,打印：100

实例2：

package com.qwy18;
class MyThread extends Thread{
    
    
	private static int num=1;
	private static Object obj= new Object();
	@Override
	public void run() {
    
    
		  try {
    
    
			Thread.currentThread().sleep(10);
		} catch (InterruptedException e) {
    
    
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		printNum();
	}
	
	private   void printNum(){
    
    
		synchronized (obj) {
    
    
			while(true){
    
    
				obj.notify();
				if(num<=100){
    
    
					System.out.println(Thread.currentThread().getName()+",打印："+num);
					num++;
				}else{
    
    
					break;
				}
				try {
    
    
					obj.wait();
				} catch (InterruptedException e) {
    
    
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		
	}
}
public class PrintNumTest {
    
    
	public static void main(String[] args) {
    
    
		MyThread t1= new MyThread();
		MyThread t2= new MyThread();
		
		t1.setName("线程A");
		t2.setName("线程B");
		t1.start();
		t2.start();
					
		
	}
}

打印可能的部分结果：
线程A,打印：1
线程B,打印：2
线程A,打印：3
线程B,打印：4
线程A,打印：5
线程B,打印：6
线程A,打印：7
线程B,打印：8
线程A,打印：9
线程B,打印：10
…省略

以上两个例子中必须注意：wait(),notify(),notifyAll()这三个方法必须有锁对象调用

生产者/消费者问题:
1.生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。
2.这里可能出现两个问题：
1)生产者比消费者快时，消费者会漏掉一些数据没有取到。
2)消费者比生产者快时，消费者会取相同的数据。
实例：

package com.qwy19;
class Clerk{
    
    
	private int productNum;
	public synchronized void createProduct(){
    
    
		if(productNum>=20){
    
    
			try {
    
    
				//挂起生产者
				wait();
			} catch (InterruptedException e) {
    
    
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}else{
    
    
			//开始生产
			productNum++;
			System.out.println(Thread.currentThread().getName()+"开始生产产品，产品总数量："+productNum);
			//唤醒消费者
			notifyAll();
		}
	}
	public synchronized void sellProduct(){
    
    
		if(productNum<=0){
    
    
			//挂起消费者
			try {
    
    
				wait();
			} catch (InterruptedException e) {
    
    
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}else{
    
    
			productNum--;
			System.out.println(Thread.currentThread().getName()+",开始销售商品，剩余商品数量："+productNum);
			notifyAll();//唤醒生产者
		}
	}
}
class Productor extends Thread{
    
    
	private Clerk clerk;
	
	public Productor(Clerk clerk) {
    
    
		super();
		this.clerk = clerk;
	}

	@Override
	public void run() {
    
    
		while (true) {
    
    
			try {
    
    
				sleep(10);
			} catch (InterruptedException e) {
    
    
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

			clerk.createProduct();
		}
	}
	
}
class Customer extends Thread{
    
    
	private Clerk clerk;
	
	public Customer(Clerk clerk) {
    
    
		super();
		this.clerk = clerk;
	}

	@Override
	public void run() {
    
    
		while(true){
    
    
			try {
    
    
				sleep(1000);
			} catch (InterruptedException e) {
    
    
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

			clerk.sellProduct();
		}
	}
}
public class ProductTest {
    
    
	public static void main(String[] args) {
    
    
		Clerk clerk= new Clerk();
		Productor p1= new Productor(clerk);
		p1.setName("生产者--AA");
		Customer c1= new Customer(clerk);
		Customer c2= new Customer(clerk);
		c1.setName("消费者A");
		c2.setName("消费者B");
		
		p1.start();
		c1.start();
		c2.start();
	}
}

运行结果：（略）
未完待续
=============================================================================================
如有不妥之处，欢迎大家给予批评指出，如果对您有帮助，给留下个小赞赞哦
==============================================================================================

线程的通信

实例

猜你喜欢