线程通讯和同步的两种实现方法

同步和通讯两个方法实现：

1. 一种是利用synchronized标示，利用继承的object类中的wait（）和notify（）或者notifyall（）唤醒方法。synchronized可以声明方法，也可以用来标记某段代码。用来标记某段代码时的用法是：synchronized（）{}。
   

   package thread;
   
   public class ThreadTimes {
   
   	/**
   	 * @param args
   	 * @throws InterruptedException 
   	 */
   	public static void main(String[] args) throws InterruptedException {
   		ThreadTimes tt = new ThreadTimes();
   		final Bussiness bussiness = tt.new Bussiness();
   		new Thread(){
   			@Override
   			public void run() {
   				for (int i = 0; i < 50; i++) {
   					try {
   						bussiness.sub(i);
   					} catch (InterruptedException e) {
   						e.printStackTrace();
   					}
   				}
   			}
   		}.start();
   		
   		for (int i = 0; i < 50; i++) {
   			bussiness.main2(i);
   		}
   	}
   	
   	class Bussiness{
   		boolean isSub = true;
   		public synchronized void sub(int i) throws InterruptedException{
   			while(!isSub){
   				this.wait();
   			}
   			for (int j = 0; j < 10; j++) {
   				System.out.println("sub time "+j+" of "+ i);
   			}
   			isSub = false;
   			this.notify();
   		}
   		
   		public synchronized void main2(int i) throws InterruptedException{
   			while(isSub){
   				this.wait();
   			}
   			for (int j = 0; j < 100; j++) {
   				System.out.println("mian time "+j+" of "+ i);
   			}
   			isSub = true;
   			this.notify();
   		}
   	}
   
   }
   

    
2. 另外一种是加锁，生成锁的对象的方法是：private static Lock lock = new ReentrantLock();Lock是一个接口，而Reentrantlock是一个实现的类。构造方法有：ReentrantLock()和ReentrantLock(fair：boolean)两种。其中第二种传递的是一个boolean值的参数，当设置为true时系统会按照等待的先后时间让线程活得锁，但是效率和性能不如默认值的好，但是同时也可以避免资源匮乏。    通讯方面是利用锁生成Condition对象，然后调用await（）和signal（）或者signalall（）。下面是实现的存款和取款的小程序。第一种实现的方法是lock加condition：

      作为一个示例，假定有一个绑定的缓冲区，它支持 put 和 take 方法。如果试图在空的缓冲区上执行 take 操作，则在某一个项变得可用之前，线程将一直阻塞；如果试图在满的缓冲区上执行 put 操作，则在有空间变得可用之前，线程将一直阻塞。我们喜欢在单独的等待 set 中保存 put 线程和 take 线程，这样就可以在缓冲区中的项或空间变得可用时利用最佳规划，一次只通知一个线程。可以使用两个 Condition 实例来做到这一点

package thread;

import java.util.LinkedList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ProducerConsumer {

	private static Buffer buffer = new Buffer();

	public static void main(String[] args) {
		ExecutorService executor = Executors.newCachedThreadPool();
		executor.execute(new ProduceTask());
		executor.execute(new ConsumerTask());
		executor.shutdown();

	}

	private static class ProduceTask implements Runnable {

		@Override
		public void run() {
			// TODO Auto-generated method stub
			try {
				int i = 1;
				while (true) {
					System.out.println("producer write: " + i);
					buffer.write(i++);
					Thread.sleep((int) (Math.random() * 10000));
				}

			} catch (Exception ex) {
				ex.printStackTrace();
			}

		}

	}

	private static class ConsumerTask implements Runnable {
		@Override
		public void run() {
			// TODO Auto-generated method stub
			try {
				while (true) {
					System.out
							.println("\t\t\tConsumer reads: " + buffer.read());
					Thread.sleep((int) (Math.random() * 10000));
				}
			} catch (Exception ex) {
				ex.printStackTrace();
			}
		}
	}

	private static class Buffer {
		private static final int size = 2;
		private LinkedList<Integer> queue = new LinkedList<Integer>();

		private Lock lock = new ReentrantLock();

		private Condition notFull = lock.newCondition();
		private Condition notEmpty = lock.newCondition();

		public void write(int value) {
			lock.lock();
			try {
				while (queue.size() == size) {
					System.out.println("wait for notFull condition");
					notFull.await();
				}

				// queue.add(value);
				queue.offer(value);
				notEmpty.signal();

			} catch (Exception ex) {
				ex.printStackTrace();
			} finally {
				lock.unlock();
			}
		}

		public int read() {
			int value = 0;
			lock.lock();
			try {
				while (queue.size() == 0) {
					System.out.println("wait for notEmpty condition");
					notEmpty.await();
				}

				value = queue.remove();
				notFull.signal();

			} catch (Exception ex) {
				ex.printStackTrace();
			} finally {
				lock.unlock();

			}
			return value;

		}

	}

}