java线程（2）--------线程通信

学习多线程，当然离不开并发编程，说到并发编程，就不得不了解一下线程通讯喽！！

1.为什么要使用线程通信？

在java多线程并发编程过程中，多个线程处理同一资源，，cpu对线程的选择是随机切换的，为了让线程按照我们既定的规律去对同一资源的处理，各个线程之间使用一种沟通方式，就是线程间的通信。线程通信能够让多个线程高效的，按照相规律的执行，避免对同一资源的争夺。

2什么是线程通信

多个线程在对同一资源进行处理时，在多个线程之间进行协调工作，避免多个线程对同一共享资源的争夺。常用的通信机制为等待–唤醒机制。下面就介绍一下几种等待唤醒机制。

3线程通信的几种方式

1).Condition

public class ConditionDemo {
//	采用打印奇偶数的例子实现线程间的通讯---wait()  notify()
	
	private int i = 0;
//通过condition方法实现多路等待
	private Lock lock = new ReentrantLock();
	private Condition condition = lock.newCondition();
	
	public void odd(){
		while(i<10){
			lock.lock();
			try {
				if (i%2==1) {
					System.out.println("奇数:"+i);
					i++;
					condition.signal();
				}else{
					try {
						condition.await();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}finally{
				lock.unlock();
			}
		}		
	}
	
	public void even(){
		while(i<10){
			lock.lock();
			try{
				if (i%2==0) {
					System.out.println("偶数:"+i);
					i++;
				condition.signal();
				}else{
					try {
						condition.await();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}finally{
				lock.unlock();
			}
		}		
	}
	
	public static void main(String[] args) {
		
		final ConditionDemo demo = new ConditionDemo();
		
		Thread thread1 = new Thread(new Runnable() {
			@Override
			public void run() {
				demo.odd();
			}
		});
		
		Thread thread2 = new Thread(new Runnable() {
			@Override
			public void run() {
				demo.even();
			}
		});
		
		thread1.start();
		thread2.start();
	}
}

2).ContdownLatch---------线程计数器
原理：创建ContdownLatch对象的时候，指定等待线程的数量，比如有一个A线程，要等待其他几个线程执行完成才能继续执行，没执行一个线程，线程计数器减一，当线程计数器为0时，等待的A线程才能执行。

public class ContDownLatchDemo {

//	参数代表等待线程的数量
	private CountDownLatch countDownLatch = new CountDownLatch(3);
//	使用教练、运动员案例进行模拟，即当运动员全部到齐准别完成以后教练开始教学
	
	public void racer(){
		String name = Thread.currentThread().getName();
		System.out.println(name+"正在准备。。。。");
//		睡眠1000毫秒，表示准备阶段
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.err.println("准备完成。。。。。。。。");
//		进行count减一操作，否则count永远是3
		countDownLatch.countDown();
	}
	
	public void coach(){
		String name = Thread.currentThread().getName();
		System.err.println(name+"教练等待。。。。");
		try {
			countDownLatch.await();
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("准备完成"+name+"开始训练");
	}
	
	public static void main(String[] args) {
		
		final ContDownLatchDemo contDownLatchDemo = new ContDownLatchDemo();
		Thread thread1 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				contDownLatchDemo.racer();
			}
		},"学员1");
		Thread thread2 = new Thread(new Runnable() {
					
					@Override
					public void run() {
						contDownLatchDemo.racer();
					}
				},"学员2");
		Thread thread3 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				contDownLatchDemo.racer();
			}
		},"学员3");
		
		Thread thread4 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				contDownLatchDemo.coach();
			}
		},"教练");

		thread4.start();
		thread1.start();
		thread2.start();
		thread3.start();
		
	}
	
}

3).CyclicBarry-----------回环栅栏
注：该方法是所有线程等待至某个状态后一同执行。

public class CyclicBarryDemo {

//	设置线程数量，该方法能够同时启动多个线程
	private CyclicBarrier cyclicBarrier = new CyclicBarrier(3);
	
	public void startThread(){
		String name = Thread.currentThread().getName();
		System.out.println(name+"正在准备。。。。。");
		try {
			cyclicBarrier.await();
		} catch (InterruptedException | BrokenBarrierException e) {
			e.printStackTrace();
		}
		System.out.println("启动完毕："+new Date().getTime());
	}
	
	public static void main(String[] args) {
		final CyclicBarryDemo cyclicBarryDemo = new CyclicBarryDemo();
		Thread thread1 = new Thread(new Runnable() {
			@Override
			public void run() {
			cyclicBarryDemo.startThread();
			}
		},"线程1");
		
		Thread thread2= new Thread(new Runnable() {
			public void run() {
			cyclicBarryDemo.startThread();
			}
		},"线程2");
		
		Thread thread3 = new Thread(new Runnable() {
			public void run() {
			cyclicBarryDemo.startThread();
			}
		},"线程3");
		
		thread1.start();
		thread2.start();
		thread3.start();
		
	}
	
}

4).Semaphore-------------信号量
注：信号量机制举个例子就是打印机，当前有三台打印机，8个人要打印，只有获取到打印机的人才能打印，其他的只能等待。信号量机制能够控制同时访问的线程个数。

public class SemahoreDemo {

	static class Worker implements Runnable{
//		员工数
		private int workNum;
//		机器数
		private Semaphore semaphore;
		
		public Worker(int workNum, Semaphore semaphore) {
			super();
			this.workNum = workNum;
			this.semaphore = semaphore;
		}
				
		public void run(){	
			try {
//				1.工人取机器
				semaphore.acquire();
				String name = Thread.currentThread().getName();
				System.out.println(name+"获取到机器，开始工作。。。。。");
				Thread.sleep(1000);
				semaphore.release();
				System.out.println(name+"机器使用完毕，释放资源");
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
	public static void main(String[] args) {
		int wokrNum = 8;
		Semaphore semaphore = new Semaphore(3);
		for(int i=0;i<wokrNum;i++){
			new Thread(new Worker(i, semaphore)).start();;
		}
		
	}
	
}