java并发_线程通信

三.线程间通信

通信机制分为两种：共享内存机制和消息通信机制。volatile 和synchronized 是共享内存机制的实现方式，同时也要考虑通信的及时性和开销问题，等待/通知机制则保证了通信双方“高效沟通”的一种方式。管道输入/输出流则是消息通信机制的实现方式。线程间的执行顺序是通过Thread.join()来实现的。

1)volatile和synchronized关键字

概述：线程间通信在JAVA内存模型基础上的实现机制，是通过volatile,synchronized来体现的。

关键字volatile可以用来修饰字段（成员变量），就是告知程序任何对该变量的访问均需要
从共享内存中获取，而对它的改变必须同步刷新回共享内存，它能保证所有线程对变量访问
的可见性。

关键字synchronized可以修饰方法或者以同步块的形式来进行使用，它主要确保多个线程
在同一个时刻，只能有一个线程处于方法或者同步块中，它保证了线程对变量访问的可见性
和排他性。

volatile和synchronized的比较：

①volatile轻量级，只能修饰变量。synchronized重量级，还可修饰方法

②volatile只能保证数据的可见性，不能用来同步，因为多个线程并发访问volatile修饰的变量不会阻塞。

synchronized不仅保证可见性，而且还保证原子性，因为，只有获得了锁的线程才能进入临界区，从而保证临界区中的所有语句都全部执行。多个线程争抢synchronized锁对象时，会出现阻塞。

底层实现原理：对象的监视器

2）等待/通知机制

解决生产者，消费者消息通知及时性和难以降低开销的矛盾

等待/通知机制:是指一个线程A调用了对象O的wait()方法进入等待状态，而另一个线程B
调用了对象O的notify()或者notifyAll()方法，线程A收到通知后从对象O的wait()方法返回，进而
执行后续操作。上述两个线程通过对象O来完成交互，而对象上的wait()和notify/notifyAll()的
关系就如同开关信号一样，用来完成等待方和通知方之间的交互工作。

3) 等待/通知的经典范式

概述：

等待方：

1. 获取对象的锁
2. 如果条件不满足，那么调用对象的wait()方法，被通知后仍要检查条件
3. 条件满足则执行对应的逻辑

通知方：

1. 获得对象的锁
2. 改变条件
3. 通知所有等待在对象上的线程

用于线程之间的数据传输，而传输的媒介为内存

4）管道输入\输出流

	/**
	 * 管道输入/输出流
	 * @author uns
	 *
	 */
	public class Piped {

	public static void main(String[] args) {
		PipedReader reader = new PipedReader();
		PipedWriter writer = new PipedWriter();
		try {
			writer.connect(reader);//输入流和输出流进行连接
			Thread thread = new Thread(new Print(reader),"PrintThread");
			thread.start();
			int received = 0;
			while ((received = System.in.read()) !=-1) {
				System.out.println((char)received);
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
	static class Print implements Runnable {
		private PipedReader  reader;
		
		public Print(PipedReader reader) {
			this.reader = reader;
		}
		public void run() {
			int received = 0;
			try {
				while ((received = reader.read()) !=-1) {
					System.out.println((char)received);
				}
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

用来维护线程的执行先后关系

5）Thread.join()

含义：thread.Join把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执行线程B。

启动10个线程，把上一个线程加入的到当前线程，执行Thread.join()方法，上一个线程执行完，再执行当前线程。

	 /**
	 * Thread.join()方法
	 * 维护线程执行顺序
	 * @author LeeRujun
	 *
	 */
	public class Join {

	public static void main(String[] args) {
		Thread thread = Thread.currentThread();//上一个线程
		for (int i = 0; i < 10; i++) {
			Thread thread2 = new Thread(new Domain(thread),String.valueOf(i));
			thread2.start();
			thread  =thread2;
		}
		try {
			TimeUnit.SECONDS.sleep(5);
			System.out.println(Thread.currentThread().getName());
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}	
		
	}

	
	static class Domain implements Runnable{
		private Thread thread;
        
		public Domain(Thread thread) {
			this.thread = thread;
		}
		public void run() {
			try {
				thread.join();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println(Thread.currentThread().getName());
		}
		
	}
	}

线程之间数据存储结构

6）ThreadLocal

ThreadLocal，即线程变量，是一个以ThreadLocal对象为键、任意对象为值的存储结构