1. 线程

1.1 进程和线程

• 进程：操作系统资源分配的最小单位。
• 线程：操作系统调度的最小单位。

一个进程里可以创建多个线程。

1.2 为什么要使用多线程

• 更多的处理器核心
• 更快的响应时间
• 更好的编程模型

1.3 线程优先级

范围1-10，默认值5，优先级高的线程分配更多的时间片。

• 针对频繁阻塞（休眠或 I/O 操作）的线程需要设置较高优先级
• 针对偏重计算（需要较多 CPU 时间或者偏运算）的线程则设置较低的优先级，确保 CPU 不会被独占。

1.4 线程的状态

• NEW： 初始状态，线程被构建，但是还没有调用 start() 方法。
• RUNNABLE： 运行状态，Java 线程将操作系统中的就绪和运行两种状态笼统地称作“运行中”。
• BLOCKED： 阻塞状态，表示线程阻塞于锁。
• WAITING： 等待状态，表示线程进入等待状态，进入该状态表示当前线程需要等待其他线程做出一些特定动作（通知或中断）。
• TIME_WAITING： 超时等待状态，该状态不同于 WAITING，它是可以在指定的时间自行返回的。
• TERMINATED： 终止状态，表示当前线程已经执行完毕。
  

1.5 Daemon 线程

支持型线程，在启动线程之前调用 Thread.setDaemon(true) 设置。随着虚拟机退出而终止，使用时注意不能依靠结尾的 finally 块来确保执行关闭或清理资源的逻辑，因为虚拟机会退出，不一定会执行。

1.6 线程中断

• 调用某线程的 interrupt() 方法对其进行中断操作。
• 线程调用 isInterrupted() 来判断是否被中断（注意如果线程已终止，即使被中断过也会返回 false）。
• 调用静态方法 Thread.interrupted() 对当前线程的中断标识位进行复位。
• 线程抛出 InterruptedException 之前 Java虚拟机 会先清除该线程的中断标识位，此时再调用 isInterrupted() 将返回 false。

2. 线程间通信

2.1 volatile 和 synchronized 关键字

• volatile：修饰成员变量。告知程序任何对该变量的访问均需从共享内存总获取，而对它的改变必须同步刷新回共享内存，保证所有线程对变量访问的可见性。
• synchronized：修饰方法或以同步块形式使用。确保多个线程在同一时刻，只能有一个线程处于方法或者同步块总，保证线程对变量访问的可见性和排他性。(基于对象监视器实现)

2.2 等待 / 通知机制

2.2.1 相关方法（java.lang.Object 的方法）

2.2.2 使用细节

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

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

2.2.3 等待 / 通知的经典范式

等待方（消费者）遵循如下原则：

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

伪代码：

synchronized(对象){
	while(条件不满足){
		对象.wait();
	}
	对应的处理逻辑
}

通知方（生产者）遵循如下原则：
4. 获得对象的锁。
5. 改变条件。
6. 通知所有等待在对象上的线程。

伪代码：

synchronized(对象){
	改变条件
	对象.notifyAll();
}

2.3 管道输入 / 输出流

用于线程之间数据传输，传输媒介位内存。

2.3.1 包括四种实现

• PipedOutputStream （面向字节）
• PipedInputStream（面向字节）
• PipedReader（面向字符）
• PipedWriter（面向字符）

2.3.2 使用示例

Piped 类型的流需要通过connect()方法进行绑定：

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{
			//读取控制台输入，并通过 PipedWriter 写给对应的 PipedReader
			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{
				//读取 PipedWriter 写过来的数据并打印到控制台
				while((receive = in.read()) != -1){
					System.out.print((char) receive);
				}
			}catch(IOException ex){
			}
		}
	}
}

2.4 Thread.join() 的使用

2.4.1 含义

如果当前线程执行了 threadA.join() 语句，当前线程等待 threadA 线程终止之后才从 threadA.join() 处返回。
另外还有两个超时方法：

• join(long millis)
• join(long millis, int nanos)

2.4.2 实现

基于等待 / 通知机制，join() 方法中使用 wait() 实现；
线程终止时会调用自身的 notifyAll() 方法，通知所有等待在该线程对象上的线程。

2.5 ThreadLocal 的使用

2.5.1 介绍

线程变量，以 ThreadLocal 对象为键、任意对象为值的存储结构，附带在线程对象上。
通过 set(T) 方法来设置值，通过 get() 方法获取当前线程原先设置的值。

2.5.1 应用示例：耗时统计工具类

在方法入口前调用 begin() 方法，在方法调用后执行 end() 方法，好处是两个方法的调用不需要在一个方法或者类中。

public class Profiler{	
	//第一次 get() 方法调用时会先调用 initialValue 方法进行初始化（如果 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() + " millis");
	}
}

3. 线程应用实例

3.1 等待超时模式

在 等待/通知的经典方式（加锁、条件循环、处理逻辑3步骤）上修改：
消费者伪代码：

//对当前对象加锁
public synchronized Object get(long) throws InterruptedException{
	//计算出等待后的具体超时时间点
	long future = System.currentTimeMillis() + mills;
	//计算剩余的等待时长
	long remaining = millis;
	//当超时大于0并且 result 返回值不满足要求则等待
	while((result == null) && remaining > 0){
		wait(remaining);
		//计算剩余的等待时长，继续参与判断
		remaining = future - System.currentTimeMillis();
	}
	//处理逻辑
	return result;
}