该系列文章只是记录本人回顾java多线程编程时候记录的笔记。文中所用语言并非严谨的专业术语(太严谨的术语其实本人也不会……)。难免有理解偏差的地方，欢迎指正。
另外，大神请绕路。不喜勿喷。
毕竟好记性不如烂笔头嘛，而且许多东西只要不是你经常用的最终都会一丢丢一丢丢地给忘记。

1 线程的相关概念

1.1 线程状态

先看看下面这张来自百度的java线程状态图：

线程状态图

新建状态（New）

用new语句创建的线程处于新建状态，只是为他分配了内存，并没有开始运行。

就绪状态（Runnable）

调用start()方法，线程就进入就绪状态。
然而也仅仅是处于可运行状态，到底能不能立即运行还要看操作系统的调度。

运行状态（Running）

此时是真正的处于运行状态。是由可运行状态到运行状态。

阻塞状态（Blocked）

线程由于某些原因放弃CPU的占有权。当线程处于阻塞状态时。直到下次该线程处于可运行状态时才有可能再次进入运行状态。

可能的阻塞原因：

1
2
3

- 调用了wait方法，进入了等待池。
- 等待某些资源可用。
- I/O等待、调用了sleep方法、其他线程的join方法等。

死亡状态（Dead）

线程执行结束。注意一个已经死亡的线程是没办法“复活”的。只能重新new一个。

1.2 优先级

大多数资料都显示，java中的线程优先级并不会生效，往往会被操作系统直接忽略。
所以，此处对这部分内容直接略过。

1.3 daemon线程

daemon线程又称为后台线程或精灵线程。

可以通过setDaemon(boolean isDeamon)将一个线程设置为后台线程。比如java的垃圾回收线程。

注意：

当JVM中不存在非daemon线程的时候，JVM就会退出。
将一个线程设置为Daemon线程，必须在其启动之前进行设置。

1.4 中断

java线程的中断表示的是：某个线程是否被其他线程中断过。相当于一个boolean类型的标识位。
此处的中断过类似于你正在写代码，突然有人找你说话，此处可以理解为被中断了。

isInterrupted():是否被中断(如果线程已经结束了,也会返回false)
Thread.interrupted():复位中断标志

线程被中断后抛出java.lang.InterruptedException异常，但是在异常被抛出之前，JVM会先将中断标识位复位。也就是说，在抛出java.lang.InterruptedException异常之后并且在下次中断之前调用isInterrupted()方法会返回false。

1.5 suspend resume stop

这三个API都是deprecated的。已经被废弃。此处提出来只是为了知识点的完整性。

suspend():暂停(睡眠)线程
resume():恢复线程
stop():终止线程

在《java并发编程的艺术》一书中，作者举了个很形象的例子来说明这三个方法的作用:CD机播放音乐时暂停(suspend)、恢复(resume)和停止(stop)的操作。同时，作者也说明了这三个人性化的方法之所以过时是因为:

suspend方法会一致占有着拥有的资源进入睡眠状态
stop方法在终止的线程的时候对资源的释放没有保证

1.6 对象监视器

任何对象都有自己的监视器。当某个对象被同步方法或者同步块调用时，执行方法的线程必须先获得其监视器。
没有获取到监视器的线程将被阻塞在方法的入口处进入阻塞(blocked)状态。

所以，任何对象都可以被当做锁来使用。

1.7 wait()和sleep()

两者都可以让线程等待
wait()调用时,必须先获取到锁
wait()是Object的方法
sleep()是Thread的方法

2 线程通信

一般而言，线程通信至少有两种方式：消息传递和共享内存。

在java里一般是共享内存实现的线程通信。当然也有第三方的消息传递模型的线程通信。
下文所说的线程通信指的是共享内存模型。

2.1 基本概念

和线程通信相关的方法

method	DESC
notify()	通知一个在对象上等待的线程，使其从wait()方法返回,返回的前提是该线程获取到了对象的锁
notifyAll()	通知所有等待在该对象上的线程
wait()	调用wait方法的线程将释放锁(如果已经持有锁的话)并进入waiting状态。只有等待其他线程的通知或被中断才会返回。
wait(long t)	和wait方法的不同是：等待t毫秒还是没有被唤醒的话会“超时返回”
wait(long,int)	对超时时间控制更加细致的wait(long)版本
join()	线程T调用tx.join()的意思是:T等待tx线程结束后才从tx.join()返回,接着执行T自己的后续代码

几个注意点

调用wait、notify、notifyAll时必须先获得锁
调用wait方法后，线程有running状态–>waitting状态，并将当前线程至于对象的等待池中。
调用notify或者notifyAll方法后waiting状态的线程能够返回的前提是：调用notifyAll或notify方法的线程先释放锁，并且该线程获得了锁。
notify调用后，会将等待池(等待队列)中的一个线程移动到同步队列中。被移动的线程状态:waiting–>blocked。
notifyAll方法调用后，会将等待池中所有的线程移动至同步队列中。被移动的线程状态:waiting–>blocked。

join()的一个有趣的例子

注意：该示例来自《java并发编程的艺术》一书

import java.util.concurrent.TimeUnit;
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 Runner(previous), String.valueOf(i));
			thread.start();
			previous = thread;
		}
		TimeUnit.SECONDS.sleep(5);
		System.out.println(Thread.currentThread().getName() + " terminate.");
	}
	static class Runner implements Runnable {
		private Thread previous;
		public Runner(Thread thread) {
			this.previous = thread;
		}
		public void run() {
			try {
				previous.join();
			} catch (InterruptedException e) {
			}
			System.out.println(Thread.currentThread().getName() + " terminate.");
		}
	}
}

以上示例的结果其实就是所有线程依次串行执行。

2.2 线程同步示例

此处是本人改写的一个生产者和消费者的案例。

生产者不断生成，消费者不断消费。

public class ProducerConsumer {
	public static void main(String[] args) {
		Container container = new Container(5);
		for (int i = 0; i < 10; i++) {
			new Thread(new Producer(container), "P-" + i).start();
			new Thread(new Consumer(container), "C-" + i).start();
		}
	}
	public static class Product {
		private String name;
		public Product(String name) {
			super();
			this.name = name;
		}
		public String getName() {
			return name;
		}
		public void setName(String name) {
			this.name = name;
		}
		@Override
		public String toString() {
			return "[name=" + name + "]";
		}
	}
	public static class Container {
		private int nextIndex = 0;
		Product[] products = null;
		public Container(int size) {
			this.products = new Product[size > 0 ? size : 5];
		}
		public void push(Product product) {
			synchronized (products) {
				while (this.nextIndex >= this.products.length) {
					try {
						// 访问products的线程先wait
						this.products.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				// 叫醒在products等待池上等待的线程
				this.products.notifyAll();
				this.products[nextIndex++] = product;
			}
		}
		public Product pop() {
			synchronized (products) {
				while (this.nextIndex <= 0) {
					try {
						this.products.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
				// 叫醒在products等待池上等待的线程
				this.products.notifyAll();
				return this.products[--nextIndex];
			}
		}
	}
	public static class Producer implements Runnable {
		private Container container;
		public Producer(Container container) {
			super();
			this.container = container;
		}
		@Override
		public void run() {
			for (int i = 0; i < Integer.MAX_VALUE; i++) {
				Product p = new Product(Thread.currentThread().getName() + "_" + i);
				this.container.push(p);
				System.out.println("生产者[" + Thread.currentThread().getName() + "]生产>>>>>>:" + p);
				try {
					Thread.sleep((long) (Math.random() * 1000));
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
	public static class Consumer implements Runnable {
		private Container container;
		public Consumer(Container container) {
			super();
			this.container = container;
		}
		@Override
		public void run() {
			for (int i = 0; i < Integer.MAX_VALUE; i++) {
				Product product = this.container.pop();
				System.out.println("消费者[" + Thread.currentThread().getName() + "]消费<<<<<<:" + product);
				try {
					Thread.sleep((long) (Math.random() * 2000));
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

参考资料

《java并发编程的艺术》

java多线程-02-基本操作及线程通信示例