文章目录

• 什么是线程和进程
• • 进程
  • 线程
  • 为什么要使用多线程
  • 使用多线程可能带来的问题
• 线程的使用
• 线程的生命周期和状态
• 线程的基础机制
• • sleep()
  • yield()
  • 中断
  • • InterruptedException
    • interrupted()
    • shutdown，shutdownNow
  • 线程之间协作
  • • join()
    • wait() notify() notifyAll()
    • await() signal() signalAll()
• 线程池
• • 使用线程池的好处
• Java内存模型(JMM)
• ThreadLocal
• synchronized
• volatile
• Atomic
• AQS
• • 并发工具
• 堵塞队列

什么是线程和进程

进程

进程是程序的一次执行过程，是系统运行程序的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。

在 Java 中，当我们启动 main 函数时其实就是启动了一个 JVM 的进程，而 main 函数所在的线程就是这个进程中的一个线程，也称主线程。

线程

线程与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中可以产生多个线程。

与进程不同的是同类的多个线程共享进程的堆和方法区资源，但每个线程有自己的程序计数器、虚拟机栈和本地方法栈，所以系统在产生一个线程，或是在各个线程之间作切换工作时，负担要比进程小得多，也正因为如此，线程也被称为轻量级进程。

为什么要使用多线程

先从总体上来说：

从计算机底层来说： 线程可以比作是轻量级的进程，是程序执行的最小单位,线程间的切换和调度的成本远远小于进程。另外，多核 CPU 时代意味着多个线程可以同时运行，这减少了线程上下文切换的开销。利用好多线程机制可以大大提高系统整体的并发能力以及性能。

再深入到计算机底层来探讨：

单核时代： 在单核时代多线程主要是为了提高单进程利用 CPU 和 IO 系统的效率。 假设只运行了一个 Java 进程的情况，当我们请求 IO 的时候，如果 Java 进程中只有一个线程，此线程被 IO 阻塞则整个进程被阻塞。CPU 和 IO 设备只有一个在运行，那么可以简单地说系统整体效率只有 50%。当使用多线程的时候，一个线程被 IO 阻塞，其他线程还可以继续使用 CPU。从而提高了 Java 进程利用系统资源的整体效率。

多核时代: 多核时代多线程主要是为了提高进程利用多核 CPU 的能力。举个例子：假如我们要计算一个复杂的任务，我们只用一个线程的话，不论系统有几个 CPU 核心，都只会有一个 CPU 核心被利用到。而创建多个线程，这些线程可以被映射到底层多个 CPU 上执行，在任务中的多个线程没有资源竞争的情况下，任务执行的效率会有显著性的提高，约等于（单核时执行时间/CPU 核心数）。

使用多线程可能带来的问题

并发编程的目的就是为了能提高程序的执行效率提高程序运行速度，但是并发编程并不总是能提高程序运行速度的，而且并发编程可能会遇到很多问题，比如：内存泄漏、死锁、线程不安全等等。所以Java给出了针对这些问题的工具和方法。

线程的使用

有三种使用线程的方法（一个线程）：

• 实现 Runnable 接口；
• 实现 Callable 接口；
• 继承 Thread 类。

实现 Runnable 和 Callable 接口的类只能当做一个可以在线程中运行的任务，不是真正意义上的线程，因此最后还需要通过 Thread 来调用。可以理解为任务是通过线程驱动从而执行的。

1, 实现 Runnable 接口

如果任务不需要返回结果或抛出异常推荐使用 Runnable 接口 。

需要实现接口中的 run() 方法。

public class MyRunnable implements Runnable {    @Override    public void run() { // 需要运行的代码    }}//使用 Runnable 实例再创建一个 Thread 实例，然后调用 Thread 实例的 start() 方法来启动线程。public static void main(String[] args) {    MyRunnable instance = new MyRunnable();    Thread thread = new Thread(instance);    //开启线程    thread.start();}

2，实现 Callable 接口

与 Runnable 相比，Callable 可以有返回值，返回值通过 FutureTask 进行封装。

public class MyCallable implements Callable<Integer> {    public Integer call() { return 123;    }}//运行public static void main(String[] args) throws ExecutionException, InterruptedException {    MyCallable mc = new MyCallable();    FutureTask<Integer> ft = new FutureTask<>(mc);    Thread thread = new Thread(ft);    //开启线程    thread.start();    //调用f.get()会阻塞并等待子线程运行完毕    System.out.println(ft.get());}

Runnable接口和Callable接口的区别

Runnable接口中的run()方法的返回值是void，它做的事情只是纯粹地去执行run()方法中的代码而已。
Callable接口中的call()方法是有返回值的，是一个泛型，和Future、FutureTask配合可以用来获取异步执行的结果。

3, 继承 Thread 类
同样也是需要实现 run() 方法，因为 Thread 类也实现了 Runable 接口。

当调用 start() 方法启动一个线程时，虚拟机会将该线程放入就绪队列中等待被调度，当一个线程被调度时会执行该线程的 run() 方法。

//不推荐public class MyThread extends Thread {    public void run() { // ...    }}public static void main(String[] args) {    MyThread mt = new MyThread();    mt.start();}

实现接口 VS 继承 Thread

实现接口会更好一些，因为：

1，Java 不支持多重继承，因此继承了 Thread 类就无法继承其它类，但是可以实现多个接口；
2，类可能只要求可执行就行，继承整个 Thread 类开销过大。

线程的生命周期和状态

Java 线程在运行的生命周期中的指定时刻只可能处于下面 6 种不同状态的其中一个状态

线程在生命周期中并不是固定处于某一个状态而是随着代码的执行在不同状态之间切换。Java 线程状态变迁如下图所示（图源《Java 并发编程艺术》4.1.4 节）：

订正：原图中 wait 到 runnable 状态的转换中，join实际上是Thread类的方法，但这里写成了Object。

在操作系统中层面线程有 READY 和 RUNNING 状态，而在 JVM 层面只能看到 RUNNABLE 状态(如图),所以 Java 系统一般将这两个状态统称为 RUNNABLE（运行中） 状态 。

为什么 JVM 没有区分这两种状态呢？
现在的时分（time-sharing）多任务（multi-task）操作系统架构通常都是用所谓的“时间分片（time quantum or time slice）”方式进行抢占式（preemptive）轮转调度（round-robin式）。这个时间分片通常是很小的，一个线程一次最多只能在 CPU 上运行比如 10-20ms 的时间（此时处于 running 状态），也即大概只有 0.01 秒这一量级，时间片用后就要被切换下来放入调度队列的末尾等待再次调度。（也即回到 ready 状态）。线程切换的如此之快，JAVA再区分这两种状态就没什么意义了。

由上图可以看出：线程创建之后它将处于 NEW（新建） 状态，调用 start() 方法后开始运行，线程这时候处于 READY（可运行） 状态。可运行状态的线程获得了 CPU 时间片（timeslice）后就处于 RUNNING（运行） 状态。

当线程执行 wait()方法之后，线程进入 WAITING（等待） 状态。进入等待状态的线程需要依靠其他线程的通知才能够返回到运行状态，而 TIMED_WAITING(超时等待) 状态相当于在等待状态的基础上增加了超时限制，比如通过 sleep（long millis）方法或 wait（long millis）方法可以将 Java 线程置于 TIMED_WAITING 状态。当超时时间到达后 Java 线程将会返回到 RUNNABLE 状态。当线程调用同步方法时，在没有获取到锁的情况下，线程将会进入到 BLOCKED（阻塞） 状态。线程在执行 Runnable 的run()方法之后将会进入到 TERMINATED（终止） 状态。

线程的基础机制

我来看下 一起线程状态变化的一些方法的使用：

sleep()

Thread.sleep(millisec) 方法会休眠当前正在执行的线程，millisec 单位为毫秒。

sleep() 可能会抛出 InterruptedException，因为异常不能跨线程传播回 main() 中，因此必须在本地进行处理。线程中抛出的其它异常也同样需要在本地进行处理。

public void run() {    try { //可能会抛出异常 Thread.sleep(3000);    } catch (InterruptedException e) { e.printStackTrace();    }}

yield()

对静态方法 Thread.yield() 的调用声明了当前线程已经完成了生命周期中最重要的部分，可以切换给其它线程来执行。该方法只是对线程调度器的一个建议，而且也只是建议具有相同优先级的其它线程可以运行。

public void run() {    Thread.yield();}

中断

一个线程执行完毕之后会自动结束，如果在运行过程中发生异常也会提前结束。

InterruptedException

通过调用一个线程的 interrupt() 来中断该线程，如果该线程处于阻塞、限期等待或者无限期等待状态，那么就会抛出 InterruptedException，从而提前结束该线程。但是不能中断 I/O 阻塞和 synchronized 锁阻塞。

对于以下代码，在 main() 中启动一个线程之后再中断它，由于线程中调用了 Thread.sleep() 方法，因此会抛出一个 InterruptedException，从而提前结束线程，不执行之后的语句。

public class InterruptExample {    private static class MyThread1 extends Thread { @Override public void run() {     try {  Thread.sleep(2000);  System.out.println("Thread run");     } catch (InterruptedException e) {  e.printStackTrace();     } }    }}

public static void main(String[] args) throws InterruptedException {    Thread thread1 = new MyThread1();    thread1.start();    thread1.interrupt();    System.out.println("Main run");}

Main runjava.lang.InterruptedException: sleep interrupted    at java.lang.Thread.sleep(Native Method)    at InterruptExample.lambda$main$0(InterruptExample.java:5)    at InterruptExample$$Lambda$1/713338599.run(Unknown Source)    at java.lang.Thread.run(Thread.java:745)

interrupted()

如果一个线程的 run() 方法执行一个无限循环，并且没有执行 sleep() 等会抛出 InterruptedException 的操作，那么调用线程的 interrupt() 方法就无法使线程提前结束。

但是调用 interrupt() 方法会设置线程的中断标记，此时线程调用 interrupted() 方法会返回 true。因此可以在循环体中使用 interrupted() 方法来判断线程是否处于中断状态，从而提前结束线程。

public class InterruptExample {    private static class MyThread2 extends Thread { @Override public void run() {     while (!interrupted()) {  // ..     }     System.out.println("Thread end"); }    }}

public static void main(String[] args) throws InterruptedException {    Thread thread2 = new MyThread2();    thread2.start();    thread2.interrupt();}

Thread end

shutdown，shutdownNow

调用 Executor 的 shutdown() 方法会等待线程都执行完毕之后再关闭，但是如果调用的是 shutdownNow() 方法，则相当于调用每个线程的 interrupt() 方法。

以下使用 Lambda 创建线程，相当于创建了一个匿名内部线程。

public static void main(String[] args) {    ExecutorService executorService = Executors.newCachedThreadPool();    executorService.execute(() -> { try {     Thread.sleep(2000);     System.out.println("Thread run"); } catch (InterruptedException e) {     e.printStackTrace(); }    });    executorService.shutdownNow();    System.out.println("Main run");}

Main runjava.lang.InterruptedException: sleep interrupted    at java.lang.Thread.sleep(Native Method)    at ExecutorInterruptExample.lambda$main$0(ExecutorInterruptExample.java:9)    ..........

如果只想中断 Executor 中的一个线程，可以通过使用 submit() 方法来提交一个线程，它会返回一个 Future 对象，通过调用该对象的 cancel(true) 方法就可以中断线程。

Future<?> future = executorService.submit(() -> {    // ..});future.cancel(true);

线程之间协作

当多个线程可以一起工作去解决某个问题时，如果某些部分必须在其它部分之前完成，那么就需要对线程进行协调。

join()

在线程中调用另一个线程的 join() 方法，会将当前线程挂起，而不是忙等待，直到目标线程结束。

对于以下代码，虽然 b 线程先启动，但是因为在 b 线程中调用了 a 线程的 join() 方法，b 线程会等待 a 线程结束才继续执行，因此最后能够保证 a 线程的输出先于 b 线程的输出。

public class JoinExample {    private class A extends Thread { @Override public void run() {     System.out.println("A"); }    }    private class B extends Thread { private A a; B(A a) {     this.a = a; } @Override public void run() {     try {  a.join();     } catch (InterruptedException e) {  e.printStackTrace();     }     System.out.println("B"); }    }    public void test() { A a = new A(); B b = new B(a); b.start(); a.start();    }}

public static void main(String[] args) {    JoinExample example = new JoinExample();    example.test();}

AB

wait() notify() notifyAll()

调用 wait() 使得线程等待某个条件满足，线程在等待时会被挂起，当其他线程的运行使得这个条件满足时，其它线程会调用 notify() 或者 notifyAll() 来唤醒挂起的线程。

它们都属于 Object 的一部分，而不属于 Thread。

只能用在同步方法或者同步控制块中使用，否则会在运行时抛出 IllegalMonitorStateException。

使用 wait() 挂起期间，线程会释放锁。这是因为，如果没有释放锁，那么其它线程就无法进入对象的同步方法或者同步控制块中，那么就无法执行 notify() 或者 notifyAll() 来唤醒挂起的线程，造成死锁。

public class WaitNotifyExample {    public synchronized void before() { System.out.println("before"); notifyAll();    }    public synchronized void after() { try {     wait(); } catch (InterruptedException e) {     e.printStackTrace(); } System.out.println("after");    }}

public static void main(String[] args) {    ExecutorService executorService = Executors.newCachedThreadPool();    WaitNotifyExample example = new WaitNotifyExample();    executorService.execute(() -> example.after());    executorService.execute(() -> example.before());}

beforeafter

wait() 和 sleep() 的区别

wait() 是 Object 的方法，而 sleep() 是 Thread 的静态方法；
wait() 会释放锁，sleep() 不会。

await() signal() signalAll()

java.util.concurrent 类库中提供了 Condition 类来实现线程之间的协调，可以在 Condition 上调用 await() 方法使线程等待，其它线程调用 signal() 或 signalAll() 方法唤醒等待的线程。

相比于 wait() 这种等待方式，await() 可以指定等待的条件，因此更加灵活。

使用 Lock 来获取一个 Condition 对象。

public class AwaitSignalExample {    private Lock lock = new ReentrantLock();    private Condition condition = lock.newCondition();    public void before() { lock.lock(); try {     System.out.println("before");     condition.signalAll(); } finally {     lock.unlock(); }    }    public void after() { lock.lock(); try {     condition.await();     System.out.println("after"); } catch (InterruptedException e) {     e.printStackTrace(); } finally {     lock.unlock(); }    }}

public static void main(String[] args) {    ExecutorService executorService = Executors.newCachedThreadPool();    AwaitSignalExample example = new AwaitSignalExample();    executorService.execute(() -> example.after());    executorService.execute(() -> example.before());}

beforeafter

线程池

使用线程池的好处

线程池提供了一种限制和管理资源（包括执行一个任务）的方式。 每个线程池还维护一些基本统计信息，例如已完成任务的数量。

使用线程池的好处：

• 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
• 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
• 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

Java内存模型(JMM)

Java 内存模型试图屏蔽各种硬件和操作系统的内存访问差异，以实现让 Java 程序在各种平台下都能达到一致的内存访问效果。

ThreadLocal

synchronized

互斥同步：

Java 提供了两种锁机制来控制多个线程对共享资源的互斥访问，第一个是 JVM 实现的 synchronized，而另一个是 JDK 实现的 ReentrantLock。

volatile

Atomic

AQS

并发工具

堵塞队列