Java并发编程基础

线程作为操作系统调度的最小单元，多个线程能够同时执行，这将显著提升程序性能，在多核环境中表现得更加明显。但是，过多地创建线程和对线程的不当管理也容易造成问。

什么是线程

现代操作系统在运行一个程序时，会为其创建一个进程。例如，启动一个Java程序，操作系统就会创建一个Java进程。现代操作系统调度的最小单元是线程，也叫轻量级进程（LightWeight Process），在一个进程里可以创建多个线程，这些线程都拥有各自的计数器、堆栈和局部变量等属性，并且能够访问共享的内存变量。处理器在这些线程上高速切换，让使用者感觉到这些线程在同时执行。

为什么要使用多线程

（1）更多的处理器核心
随着处理器上的核心数量越来越多，以及超线程技术的广泛运用，现在大多数计算机都比以往更加擅长并行计算，而处理器性能的提升方式，也从更高的主频向更多的核心发展。如何利用好处理器上的多个核心也成了现在的主要问题。
线程是大多数操作系统调度的基本单元，一个程序作为一个进程来运行，程序运行过程中能够创建多个线程，而一个线程在一个时刻只能运行在一个处理器核心上。试想一下，一个单线程程序在运行时只能使用一个处理器核心，那么再多的处理器核心加入也无法显著提升该程序的执行效率。相反，如果该程序使用多线程技术，将计算逻辑分配到多个处理器核心上，就会显著减少程序的处理时间，并且随着更多处理器核心的加入而变得更有效率。
（2）更快的响应时间
有时我们会编写一些较为复杂的代码（这里的复杂不是说复杂的算法，而是复杂的业务逻辑），例如，一笔订单的创建，它包括插入订单数据、生成订单快照、发送邮件通知卖家和记录货品销售数量等。用户从单击“订购”按钮开始，就要等待这些操作全部完成才能看到订购成功的结果。但是这么多业务操作，如何能够让其更快地完成呢？
在上面的场景中，可以使用多线程技术，即将数据一致性不强的操作派发给其他线程处理（也可以使用消息队列），如生成订单快照、发送邮件等。这样做的好处是响应用户请求的线程能够尽可能快地处理完成，缩短了响应时间，提升了用户体验。
（3）更好的编程模型
Java为多线程编程提供了良好、考究并且一致的编程模型，使开发人员能够更加专注于问题的解决，即为所遇到的问题建立合适的模型，而不是绞尽脑汁地考虑如何将其多线程化。一旦开发人员建立好了模型，稍做修改总是能够方便地映射到Java提供的多线程编程模型上。

线程优先级

现代操作系统基本采用时分的形式调度运行的线程，操作系统会分出一个个时间片，线程会分配到若干时间片，当线程的时间片用完了就会发生线程调度，并等待着下次分配。线程分配到的时间片多少也就决定了线程使用处理器资源的多少，而线程优先级就是决定线程需要多或者少分配一些处理器资源的线程属性。
在Java线程中，通过一个整型成员变量priority来控制优先级，优先级的范围从1~10，在线程构建的时候可以通过setPriority(int)方法来修改优先级，默认优先级是5，优先级高的线程分配时间片的数量要多于优先级低的线程。 设置线程优先级时，针对频繁阻塞（休眠或者I/O操作）的线程需要设置较高优先级，而偏重计算（需要较多CPU时间或者偏运算）的线程则设置较低的优先级，确保处理器不会被独占。在不同的JVM以及操作系统上，线程规划会存在差异，有些操作系统甚至会忽略对线程优先级的设定。

public class Priority {
private static volatile boolean notStart=true;
private static volatile boolean notEnd=true;
static class Job implements Runnable{
private int priority;
private long jobCount;
public Job(int priority){
this.priority=priority;
}
@Override
public void run() {
while(notStart){
Thread.yield();
}
while(notEnd){
Thread.yield();
jobCount++;
}
}

}
public static void main(String[] args) throws InterruptedException{
List<Job> jobs=new ArrayList<Job>();
for(int i=0;i<10;i++){
int priority=i<5?Thread.MIN_PRIORITY:Thread.MAX_PRIORITY;
Job job=new Job(priority);
jobs.add(job);
Thread thread=new Thread(job,"Thread:"+i);
thread.setPriority(priority);
thread.start();
}
notStart=false;
Thread.sleep(1000);
notEnd=false;
for(Job job:jobs){
System.out.println("Job Priority："+job.priority+" Count:"+job.jobCount);
}
}
}

我们开始10个工作线程，在特定时间内进行计数。在本机上运行结果如下： Job Priority：1 Count:0
Job Priority：1 Count:1
Job Priority：1 Count:2
Job Priority：1 Count:4
Job Priority：1 Count:5
Job Priority：10 Count:20031886
Job Priority：10 Count:26796976
Job Priority：10 Count:20016609
Job Priority：10 Count:26803874
Job Priority：10 Count:20050373
但是，当我将代码提交到一个在线的java编译器（http://www.shucunwang.com/RunCode/java/），返回的结果却是： Job Priority：1 Count:78808
Job Priority：1 Count:79068
Job Priority：1 Count:78946
Job Priority：1 Count:78767
Job Priority：1 Count:78772
Job Priority：10 Count:79141
Job Priority：10 Count:78969
Job Priority：10 Count:78746
Job Priority：10 Count:78531
Job Priority：10 Count:78702
从两次的输出结果，我们可以看到线程优先级并不靠谱,。也就是说，线程优先级不能作为程序正确性的依赖，而只是对操作系统的一种“建议”，操作系统甚至可以完全不用理会。不同操作系统下会出现不同表现，这是因为Java线程的调度是依托于操作系统内核的。

线程的状态

public class ThreadState {
//该线程不断进行睡眠，进行有限时间等待
static class TimeWaiting implements Runnable{ 
@Override
public void run() { 
while(true){
try {
Thread.sleep(1000);
} catch (InterruptedException e) { 
e.printStackTrace();
}
}
} 
}
//该线程在Waiting.class实例上wait()进入等待状态，知道其他线程调用Waiting.class实例上的notify()和notifyAll()
static class Waiting implements Runnable{ 
@Override
public void run() { 
while(true){
synchronized(Waiting.class){
try {
Waiting.class.wait();
} catch (InterruptedException e) { 
e.printStackTrace();
}
}
}
} 
}
//该线程在Blocked.class实例上加锁后，过一段时间再释放锁，因此下一个线程申请锁将会阻塞住
static class Blocked implements Runnable{ 
@Override
public void run() { 
synchronized(Blocked.class){
while(true){
try {
Thread.sleep(1000);
} catch (InterruptedException e) { 
e.printStackTrace();
}
}
}
} 
}
public static void main(String[] args){
new Thread(new TimeWaiting(),"TimeWaitingThread").start();
new Thread(new Waiting(),"WaitingThread").start();
//使用两个Blocked线程，一个获取锁成功，另一个将会被阻塞
new Thread(new Blocked(),"BlockedThread-1").start();
new Thread(new Blocked(),"BlockedThread-2").start();
}
}

1、执行上述代码。 2、在命令行下输入：jps
找到进程ThreadState的进程标志(PID)3596 3、在命令行下输入：jstack 3596
dump线程快照，我们就可以看到每个线程在虚拟机中所处的状态。

Daemon线程

Daemon线程是一种支持型线程，因为它主要被用作程序中后台调度以及支持性工作（例如虚拟机的垃圾回收线程等）。这意味着，当一个Java虚拟机中不存在非Daemon线程的时候，Java虚拟机将会退出。可以通过调用Thread.setDaemon(true)将线程设置为Daemon线程。 注：Daemon属性需要在线程启动之前设置，不能再启动线程之后设置。
Java虚拟机退出时Daemon线程中的finally块并不一定会执行。

public class Daemon {
static class DaemonRunner implements Runnable{ 
@Override
public void run() { 
try {
Thread.sleep(1000);
} catch (InterruptedException e) { 
e.printStackTrace();
}finally{
System.out.println("DeamonThread finally run.");
}
} 
}
public static void main(String[] args){
Thread thread=new Thread(new DaemonRunner(),"DaemonRunner");
thread.setDaemon(true);
thread.start();
} 
}

运行Daemon程序，可以看到在终端或者命令提示符上没有任何输出。main线程（非Daemon线程）在启动了线程DaemonRunner之后随着main方法执行完毕而终止，而此时Java虚拟机中已经没有非Daemon线程，虚拟机需要退出。Java虚拟机中的所有Daemon线程都需要立即终止，因此DaemonRunner立即终止，但是DaemonRunner中的finally块并没有执行。
注:在构建Daemon线程时，不能依靠finally块中的内容来确保执行关闭或清理资源的逻辑。

启动和终止线程

构造线程

在运行线程之前，首先要构造一个线程对象，线程对象的构造过程中我们可以根据需要设置特定的线程属性，例如线程名称、线程优先级、是否为Daemon线程等。

启动线程

线程对象在初始化完成之后，调用其start()方法就可以启动这个线程。调用start()方法的含义是：当前线程（调用线程对象start()方法的线程，即parent线程）同步告知Java虚拟机，只要线程规划器空闲，应立即启动该线程对象定义的线程。
注：启动一个线程前，最好为这个线程设置线程名称，因为这样在使用jstack分析程序或者进行问题排查时，就会给开发人员提供一些提示，自定义的线程最好能够起个名字。

理解中断

中断可以理解为线程的一个标识位属性，它表示一个运行中的线程是否被其他线程进行了中断操作。中断好比其他线程对该线程打了个招呼，其他线程通过调用该线程的interrupt()方法对其进行中断操作。
线程通过检查自身是否被中断来进行响应，线程通过方法isInterrupted()来进行判断是否被中断，也可以调用静态方法Thread.interrupted()对当前线程的中断标识位进行复位。如果该线程已经处于终结状态，即使该线程被中断过，在调用该线程对象的isInterrupted()时依旧会返回false。
从Java的API中可以看到，许多声明抛出InterruptedException的方法（例如Thread.sleep(longmillis)方法）这些方法在抛出InterruptedException之前，Java虚拟机会先将该线程的中断标识位清除，然后抛出InterruptedException，此时调用isInterrupted()方法将会返回false。

public class Interrupted {
static class SleepRunner implements Runnable{ 
@Override
public void run() {
while(true){
try {
Thread.sleep(1000);
} catch (InterruptedException e) { 
e.printStackTrace();
}
}
} 
}
static class BusyRunner implements Runnable{ 
@Override
public void run() { 
while(true){

}
} 
}
public static void main(String[] args) throws InterruptedException{
//sleepRunner不停的尝试睡眠
Thread sleepRunner=new Thread(new SleepRunner(),"SleepThread");
sleepRunner.setDaemon(true);

//busyRunner不停的运转
Thread busyRunner=new Thread(new BusyRunner(),"BusyThread");
busyRunner.setDaemon(true);
sleepRunner.start();
busyRunner.start();
//休眠5秒，让sleepRunner和busyRunner充分运行
Thread.sleep(1000*5);
sleepRunner.interrupt();
busyRunner.interrupt();
System.out.println("SleepThread interrupted is "+sleepRunner.isInterrupted());
System.out.println("BusyThread interrupted is "+busyRunner.isInterrupted());
//防止sleepRunner和busyRunner立刻退出
Thread.sleep(1000*2);
}
}

输出： java.lang.InterruptedException: sleep interrupted
at java.lang.Thread.sleep(Native Method)
at concurrence.chapter3.Interrupted$SleepRunner.run(Interrupted.java:9)
at java.lang.Thread.run(Unknown Source)
SleepThread interrupted is false
BusyThread interrupted is true 可以看出，抛出InterruptedException的线程SleepThread，其中断标识位被清除了，而一直忙碌运作的线程BusyThread，中断标识位没有被清除。

安全的终止线程

中断状态是线程的一个标识位，而中断操作是一种简便的线程间交互方式，而这种交互方式最适合用来取消或停止任务。除了中断以外，还可以利用一个boolean变量来控制是否需要停止任务并终止该线程。

public class Shutdown {
static class Runner implements Runnable{ 
private long i;
private volatile boolean on=true;
@Override
public void run() { 
while(on&&!Thread.currentThread().isInterrupted()){
i++;
}
System.out.println("Count i="+i);

} 
public void cancel(){
on=false;
}
}
public static void main(String[] args) throws InterruptedException{ 
Thread countThread=new Thread(new Runner(),"CountThread");
countThread.start();
//睡眠1秒，main线程对CountThread进行中断，使CountThread能够感知中断而结束
Thread.sleep(1000*1);
countThread.interrupt();//使用中断来终止线程
//重新开启一个计数线程
Runner second=new Runner();
countThread=new Thread(second,"CountThread");
countThread.start();
//睡眠1秒，main线程对second进行取消，使CountThread能够感知on为false而结束
Thread.sleep(1000*1);
second.cancel();

}
}

示例在执行过程中，main线程通过中断操作和cancel()方法均可使CountThread得以终止。这种通过标识位或者中断操作的方式能够使线程在终止时有机会去清理资源，而不是武断地将线程停止，因此这种终止线程的做法显得更加安全和优雅。

线程间通信

每个运行中的线程，如果仅仅是孤立地运行，那么没有一点儿价值，或者说价值很少，如果多个线程能够相互配合完成工作，这将会带来巨大的价值。

volatile和synchronized关键字

Java支持多个线程同时访问一个对象或者对象的成员变量，由于每个线程可以拥有这个变量的拷贝（虽然对象以及成员变量分配的内存是在共享内存中的，但是每个执行的线程还是可以拥有一份拷贝，这样做的目的是加速程序的执行，这是现代多核处理器的一个显著特性），所以程序在执行过程中，一个线程看到的变量并不一定是最新的。
关键字volatile可以用来修饰字段（成员变量），就是告知程序任何对该变量的访问均需要从共享内存中获取，而对它的改变必须同步刷新回共享内存，它能保证所有线程对变量访问的可见性。
举个例子，定义一个表示程序是否运行的成员变量boolean on=true，那么另一个线程可能对它执行关闭动作（on=false），这里涉及多个线程对变量的访问，因此需要将其定义成为volatile boolean on＝true，这样其他线程对它进行改变时，可以让所有线程感知到变化，因为所有对on变量的访问和修改都需要以共享内存为准。但是，过多地使用volatile是不必要的，因为它会降低程序执行的效率。
关键字synchronized可以修饰方法或者以同步块的形式来进行使用，它主要确保多个线程在同一个时刻，只能有一个线程处于方法或者同步块中，它保证了线程对变量访问的可见性和排他性。
同一时刻只能有一个线程获取到由synchronized所保护对象的监视器。任意一个对象都拥有自己的监视器，当这个对象由同步块或者这个对象的同步方法调用时，执行方法的线程必须先获取到该对象的监视器才能进入同步块或者同步方法，而没有获取到监视器（执行该方法）的线程将会被阻塞在同步块和同步方法的入口处，进入BLOCKED状态。

可以看到，任意线程对Object（Object由synchronized保护）的访问，首先要获得Object的监视器。如果获取失败，线程进入同步队列，线程状态变为BLOCKED。当访问Object的前驱（获得了锁的线程）释放了锁，则该释放操作唤醒阻塞在同步队列中的线程，使其重新尝试对监视器的获取。

等待/通知机制

一个线程修改了一个对象的值，而另一个线程感知到了变化，然后进行相应的操作，整个过程开始于一个线程，而最终执行又是另一个线程。前者是生产者，后者就是消费者，这种模式隔离了“做什么”（what）和“怎么做”（How），在功能层面上实现了解耦，体系结构上具备了良好的伸缩性，但是在Java语言中如何实现类似的功能呢？
简单的办法是让消费者线程不断地循环检查变量是否符合预期，如下面代码所示，在while循环中设置不满足的条件，如果条件满足则退出while循环，从而完成消费者的工作。

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

这段伪代码在条件不满足时就睡眠一段时间，这样做的目的是防止过快的“无效”尝试，这种方式看似能够解实现所需的功能，但是却存在如下问题。
1）难以确保及时性。在睡眠时，基本不消耗处理器资源，但是如果睡得过久，就不能及时发现条件已经变化，也就是及时性难以保证。
2）难以降低开销。如果降低睡眠的时间，比如休眠1毫秒，这样消费者能更加迅速地发现条件变化，但是却可能消耗更多的处理器资源，造成了无端的浪费。
以上两个问题，看似矛盾难以调和，但是Java通过内置的等待/通知机制能够很好地解决这个矛盾并实现所需的功能。
等待/通知的相关方法是任意Java对象都具备的，因为这些方法被定义在所有对象的超类java.lang.Object上，方法和描述如下表


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

public class WaitNotify {
static boolean flag=true;
static Object lock=new Object();
static class Wait implements Runnable{ 
@Override
public void run() { 
//加锁拥有lock的Monitor
synchronized(lock){
//当条件不满足时， 继续wait，同时释放了lock的锁
while(flag){ 
try {
System.out.println("flag is true.wait! "+System.currentTimeMillis());
lock.wait();
} catch (InterruptedException e) { 
e.printStackTrace();
}
}
//条件满足时，完成工作
System.out.println("flag is false.running "+System.currentTimeMillis());
}
} 
}

static class Notify implements Runnable{ 
@Override
public void run() { 
//加锁，拥有lock的Monitor
synchronized(lock){
//发送通知，通知时不会释放lock的锁
//直到当前线程释放了lock后，WaitThread才能从wait方法中返回
System.out.println("hold lock.notify "+System.currentTimeMillis());
lock.notifyAll();
flag=false;
try {
Thread.sleep(1000*5);
} catch (InterruptedException e) { 
e.printStackTrace();
}
}
//再次加锁
synchronized(lock){
System.out.println("hold lock.again "+System.currentTimeMillis());
try {
Thread.sleep(1000*5);
} catch (InterruptedException e) { 
e.printStackTrace();
}
}
} 
}
public static void main(String[] args) throws InterruptedException{
Thread waitThread=new Thread(new Wait(),"WaitThread");
waitThread.start();
Thread.sleep(1000);
Thread notifyThread=new Thread(new Notify(),"NotifyThread");
notifyThread.start();
}
}

输出： flag is true.wait! 1468915940333
hold lock.notify 1468915941333
hold lock.again 1468915946333
flag is false.running 1468915951333
上述第3行和第4行输出的顺序可能会互换，上述例子主要说明了调用wait()、notify()以及notifyAll()时需要注意的细节，如下。
1）使用wait()、notify()和notifyAll()时需要先对调用对象加锁。
2）调用wait()方法后，线程状态由RUNNING变为WAITING，并将当前线程放置到对象的等待队列。
3）notify()或notifyAll()方法调用后，等待线程依旧不会从wait()返回，需要调用notify()或notifAll()的线程释放锁之后，等待线程才有机会从wait()返回。
4）notify()方法将等待队列中的一个等待线程从等待队列中移到同步队列中，而notifyAll()方法则是将等待队列中所有的线程全部移到同步队列，被移动的线程状态由WAITING变为BLOCKED。
5）从wait()方法返回的前提是获得了调用对象的锁。
从上述细节中可以看到，等待/通知机制依托于同步机制，其目的就是确保等待线程从wait()方法返回时能够感知到通知线程对变量做出的修改。

WaitThread首先获取了对象的锁，然后调用对象的wait()方法，从而放弃了锁并进入了对象的等待队列WaitQueue中，进入等待状态。由于WaitThread释放了对象的锁，NotifyThread随后获取了对象的锁，并调用对象的notify()方法，将WaitThread从WaitQueue移到SynchronizedQueue中，此时WaitThread的状态变为阻塞状态。NotifyThread释放了锁之后，WaitThread再次获取到锁并从wait()方法返回继续执行。

等待/通知的经典范式

该范式分为两个部分，分别针对等待方（消费者）和通知方（生产者）。 等待方（消费者）遵循的原则： 1、获取对象的锁。 2、如果条件不满足，那么调用对象的wait()方法，被通知后仍然要检查条件。 3、条件满足则执行对应的逻辑。 对应伪代码为：

synchronized(对象){
//当条件不满足时， 继续wait，同时释放了lock的锁
while(条件不满足){  
lock.wait(); 
}
//条件满足时，完成对应的处理逻辑 
}

通知方（生产者）遵循如下原则： 1、获取对象的锁 2、改变条件 3、通知所有等待在对象上的线程 对应的伪代码如下

synchronized(对象){
//改变条件 
对象.notifyAll(); //通知等待线程
}

生产者/消费者

我们使用操作系统PV操作中常举的例子，放苹果和拿苹果。我们将会把对应模式的PV操作也列出来，与Java实现的生产者/消费者模式进行对比。 首先，我们仿造上面的例子写一个简单的生产者和消费者

public class SingleProduceConsumer {
static boolean empty=true; 
static Object plate=new Object();//盘子
static class Consumer implements Runnable{ 
@Override
public void run() { 
//加锁
synchronized(plate){
//当条件不满足时，继续wait
while(empty){
try {
plate.wait();
} catch (InterruptedException e) { 
e.printStackTrace();
}
}
//条件满足时，完成工作
System.out.println("从盘子里拿一个苹果！"); 
} 
}
}
static class Produce implements Runnable{ 
@Override
public void run() { 
//加锁
synchronized(plate){ 
//改变条件
System.out.println("向盘子里放入一个苹果！");
empty=false; 
plate.notifyAll();
}

} 
}
public static void main(String[] args) throws InterruptedException{
Thread consumerThread=new Thread(new Consumer());
consumerThread.start();
Thread produceThread=new Thread(new Produce());
produceThread.start();
Thread.sleep(100);
consumerThread.interrupt();
produceThread.interrupt();
}
}

输出： 向盘子里放入一个苹果！
从盘子里拿一个苹果！
（1）一个生产者，一个消费者，公用一个缓冲区。
定义两个同步信号量：
empty——表示缓冲区是否为空，初值为1。
   full——表示缓冲区中是否为满，初值为0。
生产者进程
while(TRUE){
生产一个产品;
     P(empty);
     产品送往Buffer;
     V(full);
}
消费者进程
while(True){
P(full);
   从Buffer取出一个产品;
   V(empty);
   消费该产品;
   }

public class ProduceConsumerOne {
static AtomicInteger plate=new AtomicInteger(0);//盘子
static class Consumer implements Runnable{ 
@Override
public void run() { 
try{
while(true){
//加锁
synchronized(plate){
//当条件不满足时，继续wait
while(plate.intValue()==0){ 
plate.wait(); 
}
//条件满足时，完成工作
plate.set(0);
System.out.println("从盘子里拿一个苹果！"); 
plate.notifyAll();
} 
} 
}catch (InterruptedException e) { 
return;
}

}
}
static class Produce implements Runnable{ 
@Override
public void run() { 
try {
while(true){
//加锁
synchronized(plate){ 
while(plate.intValue()==1){
plate.wait();
}
plate.set(1);
System.out.println("向盘子里放入一个苹果！"); 
plate.notifyAll();
}
}
} catch (InterruptedException e) { 
return;
}
} 
}
public static void main(String[] args) throws InterruptedException{
Thread consumerThread=new Thread(new Consumer());
consumerThread.start();
Thread.sleep(10);
Thread produceThread=new Thread(new Produce());
produceThread.start();
Thread.sleep(100);
produceThread.interrupt();
Thread.sleep(10);
consumerThread.interrupt(); 
}
}

输出： 向盘子里放入一个苹果！
从盘子里拿一个苹果！
向盘子里放入一个苹果！
从盘子里拿一个苹果！
向盘子里放入一个苹果！
从盘子里拿一个苹果！
向盘子里放入一个苹果！
从盘子里拿一个苹果！
向盘子里放入一个苹果！
从盘子里拿一个苹果！
向盘子里放入一个苹果！
从盘子里拿一个苹果！ ......

（2）一个生产者，一个消费者，公用n个环形缓冲区。
定义两个同步信号量：
empty——表示缓冲区是否为空，初值为n。
full——表示缓冲区中是否为满，初值为0。
设缓冲区的编号为1～n-1，定义两个指针in和out，分别是生产者进程和消费者进程使用的指，指向下一个可用的缓冲区。
生产者进程
while(TRUE){
     生产一个产品;
     P(empty);
     产品送往buffer（in）；
     in=(in+1)mod n；
     V(full);
}
消费者进程
while(TRUE){
 P(full);
   从buffer（out）中取出产品；
   out=(out+1)mod n；
   V(empty);
   消费该产品;
   }

public class ProduceConsumerN {
static final int MaxSize=10;
static AtomicInteger basket=new AtomicInteger(0);//篮子初始为空
static class Consumer implements Runnable{ 
@Override
public void run() { 
try{
while(true){
//加锁
synchronized(basket){
//当条件不满足时，继续wait
while(basket.intValue()==0){ 
basket.wait(); 
}
//条件满足时，完成工作
int i=basket.intValue();
basket.set(basket.intValue()-1);
System.out.println("从篮子里拿苹果 "+i+" ！"); 
basket.notifyAll();
} 
} 
}catch (InterruptedException e) { 
return;
}

}
}
static class Produce implements Runnable{ 
@Override
public void run() { 
try {
while(true){
//加锁
synchronized(basket){ 
//当条件不满足时，继续wait
while(basket.intValue()==MaxSize){
basket.wait();
}
//当条件满足时，完成工作
int i=basket.intValue();
basket.set(basket.intValue()+1);
System.out.println("向盘子里放入苹果"+(i+1)+"！"); 
basket.notifyAll();
}
}
} catch (InterruptedException e) { 
return;
}

} 
}
public static void main(String[] args) throws InterruptedException{
Thread consumerThread=new Thread(new Consumer());
consumerThread.start();
Thread.sleep(10);
Thread produceThread=new Thread(new Produce());
produceThread.start();
Thread.sleep(100);
consumerThread.interrupt();
produceThread.interrupt();
}
}

输出： ...... 向盘子里放入苹果5！
向盘子里放入苹果6！
向盘子里放入苹果7！
向盘子里放入苹果8！
向盘子里放入苹果9！
向盘子里放入苹果10！
从篮子里拿苹果 10 ！
从篮子里拿苹果 9 ！
从篮子里拿苹果 8 ！ ......
（3）一组生产者，一组消费者，公用n个环形缓冲区
在这个问题中，不仅生产者与消费者之间要同步，而且各个生产者之间、各个消费者之间还必须互斥地访问缓冲区。
定义四个信号量：
empty——表示缓冲区是否为空，初值为n。
full——表示缓冲区中是否为满，初值为0。
mutex1——生产者之间的互斥信号量，初值为1。
mutex2——消费者之间的互斥信号量，初值为1。
设缓冲区的编号为1～n-1，定义两个指针in和out，分别是生产者进程和消费者进程使用的指针，指向下一个可用的缓冲区。
生产者进程
while(TRUE){
     生产一个产品;
     P(empty);
     P(mutex1)；
     产品送往buffer（in）；
     in=(in+1)mod n；
     V(mutex1);
     V(full);
}
消费者进程
while(TRUE){
 P(full)
   P(mutex2)；
   从buffer（out）中取出产品；
   out=(out+1)mod n；
   V（mutex2）；
   V(empty);
   消费该产品;
   }
需要注意的是无论在生产者进程中还是在消费者进程中，两个P操作的次序不能颠倒。应先执行同步信号量的P操作，然后再执行互斥信号量的P操作，否则可能造成进程死锁。

public class MultiProduceConsumerN {
static final int MaxSize=10;
static Object mutexProduce=new Object();
static Object mutexConsumer=new Object();
static AtomicInteger basket=new AtomicInteger(0);//篮子初始为空
static class Consumer implements Runnable{ 
@Override
public void run() { 
try{
while(true){
synchronized(mutexConsumer){
//加锁
synchronized(basket){
//当条件不满足时，继续wait
while(basket.intValue()==0){ 
basket.wait(); 
}
//条件满足时，完成工作
int i=basket.intValue();
basket.set(basket.intValue()-1);
System.out.println(Thread.currentThread().getName()+"从篮子里拿苹果 "+i+" ！"); 
basket.notifyAll();
} 
} 
} 
}catch (InterruptedException e) { 
return;
}

}
}
static class Produce implements Runnable{ 
@Override
public void run() { 
try {
while(true){
synchronized(mutexProduce){
//加锁
synchronized(basket){ 
//当条件不满足时，继续wait
while(basket.intValue()==MaxSize){
basket.wait();
}
//当条件满足时，完成工作
int i=basket.intValue();
basket.set(basket.intValue()+1);
System.out.println(Thread.currentThread().getName()+"向盘子里放入苹果"+(i+1)+"！"); 
basket.notifyAll();
}
} 
}
} catch (InterruptedException e) { 
return;
}

} 
}
public static void main(String[] args) throws InterruptedException{
Thread consumer1=new Thread(new Consumer(),"Consumer1");
consumer1.start();
Thread consumer2=new Thread(new Consumer(),"Consumer2");
consumer2.start(); 
Thread.sleep(10);
Thread produce1=new Thread(new Produce(),"Produce1");
produce1.start();
Thread produce2=new Thread(new Produce(),"Produce2");
produce2.start();
Thread.sleep(100);
produce1.interrupt();
produce2.interrupt(); 
Thread.sleep(10);//消费完剩余产品
consumer1.interrupt();
consumer2.interrupt();

}
}

输出： ...... Produce2向盘子里放入苹果8！
Produce2向盘子里放入苹果9！
Produce2向盘子里放入苹果10！
Consumer1从篮子里拿苹果 10 ！
Produce2向盘子里放入苹果10！
Consumer2从篮子里拿苹果 10 ！
Consumer2从篮子里拿苹果 9 ！
Consumer2从篮子里拿苹果 8 ！
Consumer2从篮子里拿苹果 7 ！
......

管道输入/输出流

管道输入/输出流和普通的文件输入/输出流或者网络输入/输出流不同之处在于，它主要用于线程之间的数据传输，而传输的媒介为内存。管道输入/输出流主要包括了如下4种具体实现：PipedOutputStream、PipedInputStream、PipedReader和PipedWriter，前两种面向字节，而后两种面向字符。
下面的例子创建了printThread线程，它用来接受main线程的输入，任何main线程的输入均通过PipedWriter写入，而printThread在另一端通过PipedReader将内容读出并打印。

public class Piped {
static class Print implements Runnable{ 
private PipedReader in;
public Print(PipedReader in){
this.in=in;
}
@Override
public void run() { 
int receive=0;
try{
while((receive=in.read())!=-1){
System.out.print((char)receive);
}
}catch(IOException e){

}
} 
}

public static void main(String[] args) throws IOException {
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();
}
} 
}

运行程序，在控制台下输入的字符将会原样输出。 repeat my words 回车
repeat my words
对于Piped类型的流，必须先要进行绑定，也就是调用connect()方法，如果没有将输入/输出流绑定起来，对于该流的访问将会抛出异常。

Thread.join()

如果一个线程A执行了thread.join()语句，其含义是：当前线程A等待thread线程终止之后才从thread.join()返回。线程Thread除了提供join()方法之外，还提供了join(long millis)和join(longmillis,int nanos)两个具备超时特性的方法。这两个超时方法表示，如果线程thread在给定的超时时间里没有终止，那么将会从该超时方法中返回。
下面的例子中，创建了10个线程，编号0~9，每个线程调用前一个线程的join()方法，也就是线程0结束了，线程1才能从join()方法中返回，而线程0需要等待main线程结束。

public class Join {
static class Domino implements Runnable{
private Thread preThread;
public Domino(Thread preThread){
this.preThread=preThread;
}
@Override
public void run() {
 try {
preThread.join();
} catch (InterruptedException e) { 
e.printStackTrace();
}
 System.out.println(Thread.currentThread().getName()+" terminate.");
} 
}

public static void main(String[] args) throws InterruptedException{
Thread preThread=Thread.currentThread();
for(int i=0;i<10;i++){
//每个线程都拥有前一个线程的引用，需要等待前一个线程终止，才能从等待中返回
Thread thread=new Thread(new Domino(preThread),"Thread"+String.valueOf(i));
thread.start();
preThread=thread;
}
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName()+" terminate.");
}
}

输出： main terminate.
Thread0 terminate.
Thread1 terminate.
Thread2 terminate.
Thread3 terminate.
Thread4 terminate.
Thread5 terminate.
Thread6 terminate.
Thread7 terminate.
Thread8 terminate.
Thread9 terminate.
从上述输出可以看到，每个线程终止的前提是前驱线程的终止，每个线程等待前驱线程终止后，才从join()方法返回，这里涉及了等待/通知机制（等待前驱线程结束，接收前驱线程结束通知）。
Thread.join()方法的部分源码：

// 加锁当前线程对象
public final synchronized void join() throws InterruptedException {
// 条件不满足，继续等待
while (isAlive()) {
wait(0);
}
// 条件符合，方法返回
}

当线程终止时，会调用线程自身的notifyAll()方法，会通知所有等待在该线程对象上的线程。可以看到join()方法的逻辑结构与等待/通知经典范式一致，即加锁、循环和处理逻辑3个步骤。

ThreadLocal

当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。从线程的角度看，目标变量就象是线程的本地变量，这也是类名中“Local”所要表达的意思。可以理解为如下三点：
1、每个线程都有自己的局部变量
每个线程都有一个独立于其他线程的上下文来保存这个变量，一个线程的本地变量对其他线程是不可见的。
2、独立于变量的初始化副本
ThreadLocal可以给一个初始值，而每个线程都会获得这个初始化值的一个副本，这样才能保证不同的线程都有一份拷贝。
3、状态与某一个线程相关联
ThreadLocal 不是用于解决共享变量的问题的，不是为了协调线程同步而存在，而是为了方便每个线程处理自己的私有状态而引入的一个机制，理解这点对正确使用ThreadLocal至关重要。
ThreadLocal的接口方法

public T get() { }
public void set(T value) { }
public void remove() { }
protected T initialValue() { }

get()方法是用来获取ThreadLocal在当前线程中保存的变量副本，set()用来设置当前线程中变量的副本，remove()用来移除当前线程中变量的副本，initialValue()是一个protected方法，用来给ThreadLocal变量提供初始值，每个线程都会获取这个初始值的一个副本。

public class ThreadLocalTest {
    //创建一个Integer型的线程本地变量
public static final ThreadLocal<Integer> local = new ThreadLocal<Integer>() {
@Override
protected Integer initialValue() {
return 0;
}
};
//计数
static class Counter implements Runnable{
@Override
public void run() {
            //获取当前线程的本地变量，然后累加100次
int num = local.get();
for (int i = 0; i < 100; i++) {
num++;
}
            //重新设置累加后的本地变量
local.set(num);
System.out.println(Thread.currentThread().getName() + " : "+ local.get());
}
}
public static void main(String[] args) throws InterruptedException {
Thread[] threads = new Thread[5];
for (int i = 0; i < 5; i++) {
            threads[i] = new Thread(new Counter() ,"CounterThread-[" + i+"]");
            threads[i].start();
} 
}
}

输出： CounterThread-[2] : 100
CounterThread-[4] : 100
CounterThread-[1] : 100
CounterThread-[3] : 100
CounterThread-[0] : 100
对initialValue函数的正确理解

public class ThreadLocalMisunderstand {

static class Index {
private int num; 
public void increase() {
num++;
}
public int getValue() {
return num;
}
}
private static Index num=new Index();
    //创建一个Index型的线程本地变量
public static final ThreadLocal<Index> local = new ThreadLocal<Index>() {
@Override
protected Index initialValue() {
return num;
}
};
//计数
static class Counter implements Runnable{
@Override
public void run() {
            //获取当前线程的本地变量，然后累加10000次
Index num = local.get();
for (int i = 0; i < 10000; i++) {
num.increase();
}
            //重新设置累加后的本地变量
local.set(num);
System.out.println(Thread.currentThread().getName() + " : "+ local.get().getValue());
}
}
public static void main(String[] args) throws InterruptedException {
Thread[] threads = new Thread[5];
for (int i = 0; i < 5; i++) {
            threads[i] = new Thread(new Counter() ,"CounterThread-[" + i+"]");
} 
for (int i = 0; i < 5; i++) {
threads[i].start();
}
}
}

输出： CounterThread-[0] : 13647
CounterThread-[2] : 16116
CounterThread-[1] : 13671
CounterThread-[3] : 27743
CounterThread-[4] : 29289
现在得到的计数不一样了，并且每次运行的结果也不一样，说好的线程本地变量呢？ 之前提到，我们通过覆盖initialValue函数来给我们的ThreadLocal提供初始值，每个线程都会获取这个初始值的一个副本。而现在我们的初始值是一个定义好的一个对象，num是这个对象的引用。换句话说我们的初始值是一个引用。引用的副本和引用指向的不就是同一个对象吗？

如果我们想给每一个线程都保存一个Index对象应该怎么办呢？那就是创建对象的副本而不是对象引用的副本。

private static ThreadLocal<Index> local = new ThreadLocal<Index>() {
@Override
protected Index initialValue() {
return new Index(); //注意这里
}
};

有兴趣的可以查看ThreadLocal源码进行分析。