Java 多线程编程基础——Thread 类

线程

咱们在阅读程序时，表面看来是在跟踪程序的处理流程，实际上跟踪的是线程的执行。

单线程程序

在单线程程序中，在某个时间点执行的处理只有一个。

Java 程序执行时，至少会有一个线程在运行，这个运行的线程被称为主线程（Main Thread）。

Java 程序在主线程运行的同时，后台线程也在运行，例如：垃圾回收线程、GUI 相关线程等。

Java 程序的终止是指除守护线程（Daemon Thread）之外的线程所有终止。守护线程是执行后台做业的线程，例如垃圾回收线程。咱们能够经过 setDaemon() 方法把线程设置为守护线程。

多线程程序

由多个线程组成的程序称为多线程程序（Multithreaded Program）。多个线程运行时，各个线程的运行轨迹将会交织在一块儿，同一时间点执行的处理有多个。

多线程应用场景：

• GUI 应用程序：存在专门执行 GUI 操做的线程（UI Thread）
• 耗时任务：文件与网络的 I/O 处理
• 网络服务器同时处理多个客户端请求场景

P.S. 使用 java.nio 包中的类，有时即使不使用线程，也能够执行兼具性能和可扩展性的 I/O 处理。

并行（parallel）与并发（concurrent）的区别

程序运行存在顺序、并行与并发模式。

• 顺序（sequential）用于表示多个操做依次处理。
• 并行用于表示多个操做同时处理，取决于 CPU 的个数。
• 并发用于表示将一个操做分割成多个部分而且容许无序处理。

并发相对于顺序和并行来讲比较抽象。单个 CPU 并发处理即为顺序执行，多个 CPU 并发处理能够并行执行。

若是是单个 CPU，即使多个线程同时运行，并发处理也只能顺序执行，在线程之间不断切换。

并发处理包括：并发处理的顺序执行、并发处理的并行执行。

线程和进程的区别

• 线程之间共享内存
  进程和线程之间最大的区别就是内存是否共享。
  一般，每一个进程都拥有彼此独立的内存空间。一个进程不能够擅自读取、写入其余进程的内存。正由于每一个进程内存空间独立，无需担忧被其余进程破坏。
  线程之间共享内存，使得线程之间的通讯实现起来更加天然、简单。一个线程向实例中写入内容，其余线程就能够读取该实例的内容。当有多个线程能够访问同一个实例时，须要正确执行互斥处理。
• 线程的上下文切换快
  进程和线程之间的另外一个区别就是上下文切换的繁重程度。
  当运行中的进程进行切换时，进程要暂时保存自身的当前状态（上下文信息）。而接着开始运行的进程须要恢复以前保存的自身的上下文信息。
  当运行中的线程进行切换时，与进程同样，也会进行上下文切换。但因为线程管理的上下文信息比进程少，因此通常来讲，线程的上下文切换要比进程快。

当执行紧密关联的多项工做时，一般线程比进程更加适合。

多线程程序的优势和成本

优势：

• 充分利用硬件资源如多核 CPU、I/O 设备、网络设备并行工做。
• 提升 GUI 应用程序响应性，UI Thread 专一界面绘制、用户交互，额外开启线程执行后台任务。
• 网络应用程序简化建模，每一个客户端请求使用单独的线程进行处理。

缺点（成本）：

• 建立线程须要消耗系统资源和时间，准备线程私有的程序计数器和栈。
• 线程调度和切换一样须要成本，线程切换出去时须要保存上下文状态信息，以便再次切换回来时可以恢复以前的上下文状态。

相对而言，如果存在耗时任务须要放入子线程中实际执行，线程使用成本能够不计。

多线程编程的重要性

硬件条件知足多线程并行执行的条件以外，还须要程序逻辑可以保证多线程正确地运行，考虑到线程之间的互斥处理和同步处理。

Thread 类

线程的建立与启动

建立与启动线程的两种方法：

1. 利用 Thread 类的子类实例化，建立并启动线程。
2. 利用 Runnable 接口的实现类实例化，建立并启动线程。

线程的建立与启动步骤——方法一：

• 声明 Thread 的子类（extends Thread），并重写 run() 方法。
• 建立该类的实例
• 调用该实例的 start() 方法启动线程

Thread 实例和线程自己不是同一个东西，建立 Thread 实例，线程并未启动，直到 start() 方法调用，一样就算线程终止了，实例也不会消失。可是一个 Thread 实例只能建立一个线程，一旦调用 start() 方法，无论线程是否正常/异常结束，都没法再次经过调用 start() 方法建立新的线程。而且重复调用 start() 方法会抛出 IllegalThreadStateException 异常。

Thread run( ) 方法 和 start() 方法：

• run() 方法是能够重复调用的，可是不会启动新的线程，于当前线程中执行。run() 方法放置于 Runnable 接口旨在封装操做。
• start() 方法主要执行如下操做：启动新的线程，并在其中调用 run() 方法。

线程的建立与启动步骤——方法二：

• 声明类并实现 Runnable 接口（implements Runnable），要求必须实现 run() 方法。
• 建立该类的实例
• 以该实例做为参数建立 Thread 类的实例 Thread(Runnable target)
• 调用 Thread 类的实例的 start() 方法启动线程

无论是利用 Thread 类的子类实例化的方法（1），仍是利用 Runnable 接口的实现类实例化的方法（2），启动新线程的方法最终都是 Thread 类的 start() 方法。

Java 中存在单继承限制，若是类已经有一个父类，则不能再继承 Thread 类，这时能够经过实现 Runnable 接口来实现建立并启动新线程。

Thread 类自己实现了 Runnable 接口，并将 run() 方法的重写（override）交由子类来完成。

线程的属性

id 和 name

经过 Thread(String name) 构造方法或 void setName(String name)，给 Thread 设置一个友好的名字，能够方便调试。

优先级

Java 语言中，线程的优先级从1到10，默认为5。但因程序实际运行的操做系统不一样，优先级会被映射到操做系统中的取值，所以 Java 语言中的优先级主要是一种建议，多线程编程时不要过于依赖优先级。

线程的状态

Thread.State 枚举类型（Enum）包括：

• NEW
  线程实例化后，还没有调用 start() 方法启动。
• RUNNABLE
  可运行状态，正在运行或准备运行。
• BLOCKED
  阻塞状态，等待其余线程释放实例的锁。
• WAITING
  等待状态，无限等待其余线程执行特定操做。
• TIMED_WAITING
  时限等待状态，等待其余线程执行指定的有限时间的操做。
• TERMINATED
  线程运行结束

线程的方法

currentThread() 方法

Thread 类的静态方法 currentThread() 返回当前正在执行的线程对象。

sleep() 方法

Thread 类的静态方法 sleep() 可以暂停（休眠）当前线程（执行该语句的线程）运行，放弃占用 CPU。线程休眠期间能够被中断，中断将会抛出 InterruptedException 异常。sleep() 方法的参数以毫秒做为单位，不过一般状况下，JVM 没法精确控制时间。

sleep() 方法调用须要放在 try catch 语句中，可能抛出 InterruptedException 异常。InterruptedException 异常可以取消线程处理，可使用 interrupt() 方法在中途唤醒休眠状态的线程。

多线程示例程序中常用 sleep() 方法模拟耗时任务处理过程。

yield() 方法

Thread 类的静态方法 yield() 可以暂停当前线程（执行该语句的线程）运行，让出 CPU 给其余线程优先执行。若是没有正在等待的线程，或是线程的优先级不高，当前线程可能继续运行，即 yield() 方法没法确保暂停当前线程。yield() 方法相似 sleep() 方法，可是不能指定暂停时间。

join() 方法

Thread 类的实例方法，持有 Thread 实例的线程，将会等待调用 join() 方法的 Thread 实例表明的线程结束。等待期间能够被中断，中断将会抛出 InterruptedException 异常。

示例程序：

public class HelloThread extends Thread {
    @Override
    public void run() {
        System.out.println("hello");
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new HelloThread();
        thread.start();
        thread.join();
    }
}

main() 方法所在的主线程将会等待 HelloThread 子线程执行 run() 方法结束后再执行，退出程序。

并发编程特性

• 原子性
• 可见性
• 有序性

原子性操做问题

原子性概念来源于数据库系统，一个事务（Transaction）中的全部操做，要么所有完成，要么所有不完成，不会结束在中间某个环节。事务在执行过程当中发生错误，会被恢复（Rollback）到事务开始前的状态，就像这个事务历来没有执行过同样。

并发编程的原子性指对于共享变量的操做是不可分的，Java 基本类型除 long、double 外的赋值操做是原子操做。

非原子操做例如：

counter++;

1. 读取 counter 的当前值
2. 在当前值基础上加1
3. 将新值从新赋值给 counter

Java 语言的解决方式：

• 使用 synchronized 关键字
• 使用 java.util.concurrent.atomic 包

内存可见性问题

计算机结构中，CPU 负责执行指令，内存负责读写数据。CPU 执行速度远超内存读写速度，缓解二者速度不一致引入了高速缓存。 预先拷贝内存数据的副本到缓存中，便于 CPU 直接快速使用。

所以计算机中除内存以外，数据还有可能保存在 CPU 寄存器和各级缓存当中。这样一来，当访问一个变量时，可能优先从缓存中获取，而非内存；当修改一个变量时，可能先将修改写到缓存中，稍后才会同步更新到内存中。

对于单线程程序来讲没有太大问题，可是多线程程序并行执行时，内存中的数据将会不一致，最新修改可能还没有同步到内存中。须要提供一种机制保证多线程对应的多核 CPU 缓存中的共享变量的副本彼此一致——缓存一致性协议。

Java 语言的解决方式：

• 使用 volatile 关键字
• 使用 synchronized 关键字

若是只是解决内存可见性问题，使用 synchronized 关键字成本较高，考虑使用 volatile 关键字更轻量级的方式。

指令重排序问题

有序性：即程序执行的顺序严格按照代码的前后顺序执行。

Java 容许编译器和处理器为了提升效率对指令进行重排序，重排序过程不会影响到单线程程序的执行，却会可能影响到多线程程序并发执行时候的正确性。

volatile 关键字细节

Java 使用 volatile 关键字修饰变量，保证可见性、有序性。

• 保证变量的值一旦被修改后当即更新写入内存，同时默认从内存读取变量的值。（可见性）
• 禁止指令重排序（有序性）

可是 volatile 关键字没法保证对变量操做是原子性的。

线程的互斥处理（synchronized 关键字细节）

每一个线程拥有独立的程序计数器（指令执行行号）、栈（方法参数、局部变量等信息），多个线程共享堆（对象），这些区域对应 JVM 内存模型。当多个线程操做堆区的对象时候，可能出现多线程共享内存的问题。

竞态条件

银行取款问题
if(可用余额大于等于取款金额) {

可用余额减去取款金额

}
多个线程同时操做时，余额确认（可用余额大于等于取款金额）和取款（可用余额减去取款金额）两个操做可能穿插执行，没法保证线程之间执行顺序。

线程 A	线程 B
可用余额（1000）大于等于取款金额（1000）？是的	切换执行线程 B
线程 A 处于等待状态	可用余额（1000）大于等于取款金额（1000）？是的
线程 A 处于等待状态	可用余额减去取款金额（1000-1000 = 0）
切换执行线程 A	线程 B 结束
可用余额减去取款金额（0 - 1000 = -1000）	线程 B 结束

当有多个线程同时操做同一个对象时，可能出现竞态条件（race condition），没法预期最终执行结果，与执行操做的时序有关，须要“交通管制”——线程的互斥处理。

Java 使用 synchronized 关键字执行线程的互斥处理。synchronized 关键字能够修饰类的实例方法、静态方法和代码块。

锁

synchronized 关键字保护的是对象而非方法、代码块，使用锁来执行线程的互斥处理。

synchronized 修饰静态方法和实例方法时保护的是不一样的对象：

• synchronized 修饰实例方法是使用该类的实例对象 this。
• synchronized 修饰静态方法是使用该类的类对象 class。

每一个对象拥有一个独立的锁，同一对象内的全部 synchronized 方法共用。

synchronized 方法注意事项

基于 synchronized 关键字保护的是对象原则，有以下推论：

• 一个实例中的 synchronized 方法每次只能由一个线程运行，而非 synchronized 方法则能够同时由多线程运行。
• 一个实例中的多个 synchronized 方法一样没法多线程运行。
• 不一样实例中的 synchronized 方法能够同时由多线程运行。
• synchronized 修饰的静态方法（this 对象）和实例方法（class 对象）之间，能够同时被多线程执行。

synchronized 方法同步使用

synchronized 方法具备可重入性，即获取锁后能够在一个 synchronized 方法，调用其余须要一样锁的 synchronized 方法。

通常在保护实例变量时，将全部访问该变量的方法设置为 synchronized 同步方法。

若是只是想让方法中的某一部分由一个线程运行，而非整个方法，则可以使用 synchronized 代码块，精确控制互斥处理的执行范围。

synchronized 方法执行流程

1. 尝试获取对象锁，若是获取到锁进入2，未获取到锁则加入锁的等待队列进入阻塞状态等待被唤醒。
2. 执行 synchronized 方法
3. 释放对象锁，若是等待队列存在线程正在等待获取锁，将其唤醒，当有多个线程处于等待队列，没法明确唤醒某一个，由多个线程竞争获取。

死锁

死锁是指两个或两个以上的进程（线程）在执行过程当中，因争夺资源而形成的一种互相等待的现象，若无外力做用，它们都将没法推动下去。

死锁产生的四个必要条件

1. 互斥条件：指进程对所分配到的资源进行排它性使用，即在一段时间内某资源只由一个进程占用。若是此时还有其它进程请求资源，则请求者只能等待，直至占有资源的进程用毕释放。
2. 请求和保持条件：指进程已经保持至少一个资源，但又提出了新的资源请求，而该资源已被其它进程占有，此时请求进程阻塞，但又对本身已得到的其它资源保持不放。
3. 不剥夺条件：指进程已得到的资源，在未使用完以前，不能被剥夺，只能在使用完时由本身释放。
4. 循环等待条件：指在发生死锁时，必然存在一个进程——资源的环形链，即进程集合 {P0，P1，P2，···，Pn} 中的 P0 正在等待一个 P1 占用的资源；P1 正在等待 P2 占用的资源，……，Pn 正在等待已被 P0 占用的资源。

产生死锁必须同时知足上述四个条件，只要其中任一条件不成立，死锁可避免。

应该尽可能避免在持有一个锁的同时，申请另外一个锁。若是确实须要多个锁，应该按照相同的顺序获取锁。

线程的协做（wait()、notify() 方法细节）

多线程之间除了在竞争中作互斥处理，还须要相互协做。协做的前提是清楚共享的条件变量。

wait()、notify()、notifyAll() 都是 Object 类的实例方法，而不是 Thread 类中的方法。这三个方法与其说是针对线程的操做，倒不如说是针对实例的条件等待队列的操做。

操做 obj 条件等待队列中的线程（唤醒、等待）：

• obj.wait() 将当前线程放入 obj 的条件等待队列。
• obj.notify() 从 obj 的条件等待队列唤醒一个线程。
• obj.notifyAll() 唤醒 obj 条件等待队列中的全部线程。

wait() 等待方法

每一个对象拥有一个锁和锁的等待队列，另外还有一个表示条件的等待队列，用于线程间的协做。调用 wait() 方法会将当前线程放入条件队列等待，等待条件须要等待时间或者依靠其余线程改变（notify()/notifyAll() ）。等待期间一样能够被中断，中断将会抛出 InterruptedException 异常。

Object 类的 wait() 方法和 Thread 类的 sleep() 方法在控制线程上主要区别在于对象锁是否释放，从方法所属类能够看出 Object 类的 wait() 方法包含对象锁管理机制。

• wait() 实例方法用于线程间通讯协做
• sleep() 静态方法用于暂停当前线程
• 二者均会放弃占用 CPU

wait() 方法执行过程

• 将当前线程放入条件队列等待，释放对象锁。
• 当前线程进入 WAITING、TIMED_WAITING 状态。

• 等待时间或者被其余线程唤醒（notify()/notifyAll() ），从条件队列中移除等待线程。

  • 唤醒的线程得到对象锁，进入 RUNNABLE 状态，从 wait() 方法返回，从新执行等待条件检查。
  • 唤醒的线程没法得到对象锁，进入 BLOCKED 状态，加入对象锁的等待队列，继续等待。

notify() 唤醒方法

notify() 和 notifyAll() 方法的区别

• notify() 方法会唤醒等待队列中的一个线程。
• notifyAll() 方法会唤醒等待队列中全部线程。

一般使用 notifyAll() 方法，相比于 notify() 方法代码更具健壮性，可是唤醒多个线程速度慢些。

注意：调用 notify() 方法以后，唤醒条件队列中等待的线程，并将其移除队列。被唤醒的线程并不会当即运行，由于执行 notify() 方法的线程还持有着锁，等待 notify() 方法所处的同步（synchronized）代码块执行结束才释放锁。随后等待的线程得到锁从 wait() 方法返回，从新执行等待条件检查。

总结：

• 线程必须持有实例的锁才能执行上述方法（wait()、notify()、notifyAll()）
• wait()/notify() 方法只能在 synchronized 代码块内被调用，若是调用 wait()/notify() 方法时，当前线程没有持有对象锁，会抛出异常 java.lang.IllegalMonitorStateException。

生产者/消费者模式应用

• 生产者（Producer）生成数据的线程
• 消费者（Consumer）使用数据的线程

生产者线程和消费者线程经过共享队列进行协做，

生产者/消费者模式在生产者和消费者之间加入了一个桥梁角色，该桥梁角色用于消除线程间处理速度的差别。

Channel 角色持有共享队列 Data，对 Producer 角色和 Consumer 角色的访问执行互斥处理，并隐藏多线程实现。

线程的中断

线程正常结束于 run() 方法执行完毕，但在实际应用中多线程模式每每是死循环，考虑到存在特殊状况须要取消/关闭线程。Java 使用中断机制，经过协做方式传递信息，从而取消/关闭线程。

中断的方法

public static boolean interrupted()
public boolean isInterrupted()
public void interrupt()

• interrupt() 和 isInterrupted() 是实例方法，经过线程对象调用。
• interrupted() 是静态方法，由当前线程 Thread.currentThread() 实际执行。

线程存在 interrupted 中断状态标记，用于判断线程是否中断。

• isInterrupted() 实例方法返回对应线程的中断状态。
• interrupted() 静态方法返回当前线程的中断状态，存在反作用清空中断状态。

不一样线程状态的中断反应

• NEW、TERMINATED
  调用 interrupt() 方法不起任何做用
• RUNNABLE
  调用 interrupt() 方法，线程正在运行，且与 I/O 操做无关，设置线程中断状态标记而已。若是线程等待 I/O 操做，则会进行特殊处理。
• BLOCKED
  调用 interrupt() 方法没法中断正在 BLOCKED 状态的线程
• WAITING、TIMED_WAITING
  调用 interrupt() 方法设置线程中断状态标记，抛出 InterruptedException 异常。这是一个受检异常，线程必须进行处理。

中断的使用

对于提供线程服务的模块，应该封装取消/关闭线程方法对外提供接口，而不是交由调用者自行调用 interrupt() 方法。

线程状态转换综合图解

结合线程的方法（Thread 类 + Object 类）来看线程的状态转换：

注：

• Thread t = new Thread(); Thread 类调用静态方法，t 对象调用实例方法。
• Object o = new Object(); Object 类调用静态方法，o 对象调用实例方法。
• Running 表示运行中状态，并不是 Thread.State 枚举类型。

附录

Runnable 接口和 Callable 接口

• Runnable 接口提供的 run() 方法返回值为 void
• Callable 接口提供的 call() 方法返回值为泛型

Callable 接口经常使用与配合 Future、FutureTask 类获取异步执行结果。