阻塞队列实现线程通信

假设车库有3个车位（可以通过boolean[]数组来表示车库）可以停车，写一个程序模拟多个用户开车离开，停车入库的效果。注意：车位有车时不能停车。

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

/*
 * 阻塞队列控制线程通信
 * BlockingQueue的特点是：当生产者试图向BlockingQueue放入元素时，如果队列已满，则该线程被阻塞；
 *                     当消费者试图从BlockingQueue取出元素时，如果该队列为空，则线程被阻塞
 */
/*
 * 假设有3个车位，boolean[]数组表示车库，写一个程序模拟多个用户离开、停车入库的效果。注意：车位有车时不能停车。
 * //如果不考虑车库中车位的具体地址，只控制车库的数量，可以采用阻塞队列或信号量（Semaphore）实现
 */
class Producer extends Thread{
	//车入库
	private BlockingQueue bq;

	public Producer(BlockingQueue bq) {
		super();
		this.bq = bq;
	}
	public void run() {
		
			try {
				bq.put(true);//如果车库满，则不能停车，停车将被阻塞
				System.out.println("一辆车成功停入");
				
				
			} catch (InterruptedException e) {
				
				e.printStackTrace();
			
			
		}
	
		
	}
}
class Consumer extends Thread{
	//车入库
	private BlockingQueue bq;

	public Consumer(BlockingQueue bq) {
		super();
		this.bq = bq;
	}
	public void run() {
		try {
			bq.take();//如果车库空，出库将被阻塞
			System.out.println("一辆车成功取出");
		} catch (InterruptedException e) {
			
			e.printStackTrace();
		}
		
	}
}
public class BlockingQueueTest {
	
	public static void main(String[] args) {
		//创建一个容量为3 的车库
		 BlockingQueue bq = new ArrayBlockingQueue<>(3);
		 //启动4个停车，和3个取车线程
		 new Producer(bq).start();
		 new Producer(bq).start();
		 new Producer(bq).start();
		 new Producer(bq).start();
		 
		 new Consumer(bq).start();
	}
	
	 
	

}

第二种是利用synchronized方法，但是这种没有用到Boolean数组

/*
 * 定义一个停车场类，两个线程共享停车场，利用同步停车场对象实现停车和出库操作
 * 当停车场满时，wait（）,等待取车操作
 * 当停车场为空时，wait(),等待有车停入
 */
//停车场类
class Park{
	boolean[] park = new boolean[3];
	//state变量定义停车场的剩余车辆
	private int state =3;
	
    public synchronized void CarIn(int i) {
    	try {
    		while(state==0) {
    			System.out.println("目前空余车位为："+state+"请等待");
    			wait();
    			
    		}
    		System.out.println(i+"车位停车成功");
    		state=state-1;
    		System.out.println("目前剩余车位为："+state);
    		
    		notify();		
    	}
    	catch(InterruptedException e){
    		e.printStackTrace();
    		
    	}
    }
    public synchronized void CarOut(int i) {
    	try {
    		while(state==3) {
    			//System.out.println("目前空余车位为："+state+"请等待");
    			wait();
    			
    		}
    		System.out.println(i+"车驶出");
    		state=state+1;
    		System.out.println("目前剩余车位为："+state);
    		
    		notify();		
    	}
    	catch(InterruptedException e){
    		e.printStackTrace();
    		
    	}
    }
	
	
	
}
 class CarInThread extends Thread{
	 Park park=new Park();
	 public CarInThread(Park park) {
	     this.park=park;
	 }

	
	    public void run() {
	        super.run();
	        for(int i=1;i<5;i++){
	            park.CarIn(i);
	        }
	    }
	}
 class CarOutThread extends Thread{
	 Park park=new Park();
	 public CarOutThread(Park park) {
	 this.park=park;
	 }
	 
	     public void run() {
	         super.run();
	         for(int i=1;i<5;i++){
	             park.CarOut(i);
	         }
	     }
	 }

	

public class SynchronizedTest {
	public static void main(String[] args) {
		Park park = new Park();
		new CarInThread( park).start();
		new CarOutThread(park).start();
	}

}

总的来说，多线程通信的关键就是共享资源的同步。