Java高并发编程---线程间通信

引

 每个线程运行时，都会拥有属于自己的栈空间。这个栈空间中有既定的代码，一步一步地执行了这些代码后，线程终止。如果每个线程都独立工作，没有线程间的交流和配合的话，那就几乎没有价值。
 

volatile和synchronized关键字

 （若看官们不想听我多bb，想快速上手实操可以去看我之前的其他博客：Java高并发编程（一）~（五））
 Java支持多个线程同时访问一个对象或者对象的成员变量，由于每个线程可以拥有这个变量的拷贝（虽然对象以及成员变量分配的内存是在共享内存中的，但是每个执行的线程还是可以拥有一份拷贝，这样做的目的是加速程序的执行，这是现代多核处理器的一个显著特性），所以程序在执行过程中，一个线程看到的变量并不一定是最新的。
 关键字volatile可以用来修饰字段（成员变量），就是告知程序任何对该变量的访问均需要从共享内存中获取，而对它的改变必须同步刷新回共享内存，它能保证所有线程对变量访问的可见性。
 关键字synchronized可以修饰方法或者以同步块的形式来进行使用，它主要确保多个线程在同一个时刻，只能有一个线程处于方法或者同步块中，它保证了线程对变量访问的可见性和排他性。

Synchronized.java

public class Synchronized {
	public static void main(String[] args) {
		// 对Synchronized Class对象进行加锁
		synchronized (Synchronized.class) {
		}
		// 静态同步方法，对Synchronized Class对象进行加锁
		m();
	}
	
	public static synchronized void m() {
	}
}

 加锁的本质其实就是对一个对象的监视器（monitor）进行获取，而这个获取过程是排他的，也就是同一时刻只能有一个线程获取到由synchronized所保护对象的监视器。
 任意一个对象都拥有自己的监视器，当这个对象由同步块或者这个对象的同步方法调用时，执行方法的线程必须先获取到该对象的监视器才能进入同步块或者同步方法，而没有获取到监视器（执行该方法）的线程将会被阻塞在同步块和同步方法的入口处，进入BLOCKED状态。
 任意线程对Object（Object由synchronized保护）的访问，首先要获得Object的监视器。如果获取失败，线程进入同步队列，线程状态变为BLOCKED。当访问Object的前驱（获得了锁的线程）释放了锁，则该释放操作唤醒阻塞在同步队列中的线程，使其重新尝试对监视器的获取。
 

等待/通知机制

 线程的生产者消费者模式中，整个过程开始于一个线程，最终执行于另一个线程，Java中如何实现这一功能？
 简单的办法是让消费者线程不断地循环检查变量是否符合预期，如下面代码所示，在while循环中设置不满足的条件，如果条件满足则退出while循环，从而完成消费者的工作。

	while (value != desire) {
		Thread.sleep(1000);
	}
	doSomething();

上面这段伪代码在条件不满足时就睡眠一段时间，这样做的目的是防止过快的“无效”尝试，但这种方式是存在问题的：

1. 难以确保及时性。在睡眠时，基本不消耗处理器资源，但是如果睡得过久，就不能及时发现条件已经变化，也就是及时性难以保证。
2. 难以降低开销。如果降低睡眠的时间，比如休眠1毫秒，这样消费者能更加迅速地发现条件变化，但是却可能消耗更多的处理器资源，造成了无端的浪费。

等待/通知的机制可以解决这个问题：

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

• 使用wait()、notify()和notifyAll()时需要先对调用对象加锁。
• 调用wait()方法后，线程状态由RUNNING变为WAITING，并将当前线程放置到对象的等待队列。
• notify()或notifyAll()方法调用后，等待线程依旧不会从wait()返回，需要调用notify()或notifAll()的线程释放锁之后，等待线程才有机会从wait()返回。
• notify()方法将等待队列中的一个等待线程从等待队列中移到同步队列中，而notifyAll()方法则是将等待队列中所有的线程全部移到同步队列，被移动的线程状态由WAITING变为BLOCKED。
• 从wait()方法返回的前提是获得了调用对象的锁。

等待/通知机制依托于同步机制，其目的就是确保等待线程从wait()方法返回时能够感知到通知线程对变量做出的修改。
 

管道输入/输出流

 管道输入/输出流和普通的文件输入/输出流或者网络输入/输出流不同之处在于，它主要用于线程之间的数据传输，而传输的媒介为内存。
 管道输入/输出流主要包括了如下4种具体实现：PipedOutputStream、PipedInputStream、PipedReader和PipedWriter，前两种面向字节，而后两种面向字符。
示例代码：Piped.java

public class Piped {
	public static void main(String[] args) throws Exception {
		PipedWriter out = new PipedWriter();
		PipedReader in = new PipedReader();
		// 将输出流和输入流进行连接，否则在使用时会抛出IOException
		out.connect(in);
		Thread printThread = new Thread(new Print(in), "PrintThread");
		printThread.start();
		int receive = 0;
			try {
				while ((receive = System.in.read()) != -1) {
				out.write(receive);
			}
			} finally {
				out.close();
			}
		}
		
		static class Print implements Runnable {
			private PipedReader in;
			public Print(PipedReader in) {
			this.in = in;
			}
			public void run() {
			int receive = 0;
			try {
			while ((receive = in.read()) != -1) {
			System.out.print((char) receive);
			}
			} catch (IOException ex) {
			}
		}
	}
}

 

Thread.join()

 如果一个线程A执行了thread.join()语句，其含义是：当前线程A等待thread线程终止之后才从thread.join()返回。线程Thread除了提供join()方法之外，还提供了join(long millis)和join(longmillis,int nanos)两个具备超时特性的方法。这两个超时方法表示，如果线程thread在给定的超时时间里没有终止，那么将会从该超时方法中返回。
Join.java

public class Join {
	public static void main(String[] args) throws Exception {
			Thread previous = Thread.currentThread();
			for (int i = 0; i < 10; i++) {
				// 每个线程拥有前一个线程的引用，需要等待前一个线程终止，才能从等待中返回
				Thread thread = new Thread(new Domino(previous), String.valueOf(i));
				thread.start();
				previous = thread;
			}
			TimeUnit.SECONDS.sleep(5);
			System.out.println(Thread.currentThread().getName() + " terminate.");
		}
		static class Domino implements Runnable {
			private Thread thread;
			public Domino(Thread thread) {
				this.thread = thread;
			}
			public void run() {
				try {
						thread.join();
				} catch (InterruptedException e) {
				}
				System.out.println(Thread.currentThread().getName() + " terminate.");
		}
	}
}

输出：

main terminate.
0 terminate.
1 terminate.
2 terminate.
3 terminate.
4 terminate.
5 terminate.
6 terminate.
7 terminate.
8 terminate.
9 terminate.

因此，每个线程终止的前提是前驱线程的终止，每个线程等待前驱线程终止后，才从join()方法返回，这里涉及了等待/通知机制（等待前驱线程结束，接收前驱线程结束通知）。
 当线程终止时，会调用线程自身的notifyAll()方法，会通知所有等待在该线程对象上的线程。可以看到join()方法的逻辑结构j就是加锁、循环和处理逻辑3个步骤。
 

ThreadLocal

 ThreadLocal，即线程变量，是一个以ThreadLocal对象为键、任意对象为值的存储结构。这个结构被附带在线程上，也就是说一个线程可以根据一个ThreadLocal对象查询到绑定在这个线程上的一个值。可以通过set(T)方法来设置一个值，在当前线程下再通过get()方法获取到原先设置的值。
示例代码：Profiler.java

public class Profiler {
		// 第一次get()方法调用时会进行初始化（如果set方法没有调用），每个线程会调用一次
		private static final ThreadLocal<Long> TIME_THREADLOCAL = new ThreadLocal<Long>() {
			protected Long initialValue() {
				return System.currentTimeMillis();
			}
		};
		public static final void begin() {
			TIME_THREADLOCAL.set(System.currentTimeMillis());
		}
		public static final long end() {
			return System.currentTimeMillis() - TIME_THREADLOCAL.get();
		}
		public static void main(String[] args) throws Exception {
			Profiler.begin();
			TimeUnit.SECONDS.sleep(1);
			System.out.println("Cost: " + Profiler.end() + " mills");
		}
}

 Profiler可以被复用在方法调用耗时统计的功能上，在方法的入口前执行begin()方法，在方法调用后执行end()方法，好处是两个方法的调用不用在一个方法或者类中，比如在AOP（面向方面编程）中，可以在方法调用前的切入点执行begin()方法，而在方法调用后的切入点执行end()方法，这样依旧可以获得方法的执行耗时。