Java线程基础

本文章已授权微信公众号郭霖（guolin_blog）转载。

本文章讲解的内容是Java线程，建议对着示例项目阅读文章，示例项目链接如下：

ThreadDemo

本文章分析的相关的源码基于Java Development Kit（JDK） 13。

概述

在说线程的概念之前，先说下进程的概念，进程是代码在数据集合上的一次运行活动，它是系统进行资源分配和调度的基本单位。一个进程至少有一个线程，线程是进程中的实体，线程本身是不会独立存在的，进程中的多个线程可以共享进程的资源（例如：内存地址、文件I/O等），也可以独立调度。

有以下三种方式实现线程：

• 使用内核线程实现
• 使用用户线程实现
• 使用用户线程和轻量级线程混合实现

Java语言统一处理了不同硬件和操作系统平台的线程操作，一个线程是一个已经执行start()方法而且还没结束的java.lang.Thread类的实例，其中Thread类的所有关键方法都是本地方法（Native Method）来的，这意味着这些方法没有使用或者无法使用平台相关的手段来实现。

线程状态切换

Java语言定义了六种线程状态，要注意的是，在任意一个时间点，一个线程有且只有五种线程状态的其中一种，这五种线程状态如下所示：

• 新建（New）：线程创建后尚未启动的状态。
• 运行（Runable）：线程正在等待着CPU为它分配执行时间，进入就绪（Ready）状态，等到CPU分配执行时间后，线程才真正执行，进入正在运行（Running）状态。
• 无限期等待（Waiting）：这种状态下的线程不会被CPU分配执行时间，它们需要其他线程显示地唤醒。以下方法会让线程进入这种状态：
  • 没有设置参数Timeout的Object.wait()方法
  • 没有设置参数Timeout的Thread.join()方法
  • LockSupport.park方法
• 限期等待（Timed Waiting）：这种状态下的线程不会被CPU分配执行时间，但是它无需其他线程显示地唤醒，会在一定时间内由系统自动唤醒。以下方法会让线程进入这种状态：
  • Thread.sleep()方法
  • 有设置参数Timeout的Object.wait()方法
  • 有设置参数Timeout的Thread.join()方法
  • LockSupport.parkNanos()方法
  • LockSupport.parkUntil()方法
• 阻塞（Block）：线程被阻塞的状态，在等待着一个排他锁。
• 结束（Terminated）：线程已终止，并且已经结束执行的状态。

线程创建和运行

Java语言提供了三种创建线程的方式，如下所示：

继承Thead类并且重写run方法

代码如下所示：

/**
 * Created by TanJiaJun on 2020/8/30.
 */
class TanJiaJunThreadTest {

    private static class TanJiaJunThread extends Thread {

        @Override
        public void run() {
            super.run();
            System.out.println("谭嘉俊");
        }

    }

    public static void main(String[] args) {
        // 创建线程
        TanJiaJunThread thread = new TanJiaJunThread();
        // 启动线程
        thread.start();
    }

}

这种方式的优点是在run方法内可以使用this获取当前线程，无须使用Thread.currentThread方法；缺点是因为Java的类只能继承一个类，所以继承Thread类之后，就不能继承其他类了，而且因为任务和代码没有分离，如果多个线程执行相同的任务时，需要多份任务代码。

要注意的是，调用了start方法后，线程正在等待着CPU为它分配执行时间，进入就绪（Ready）状态，等到CPU分配执行时间后，线程才真正执行，进入正在运行（Running）状态。

实现Runnable接口的run方法

代码如下所示：

/**
 * Created by TanJiaJun on 2020/8/30.
 */
class TanJiaJunRunnableTest {

    private static class TanJiaJunRunnable implements Runnable {

        @Override
        public void run() {
            System.out.println("谭嘉俊");
        }

    }

    public static void main(String[] args) {
        // 创建TanJiaJunRunnable对象
        TanJiaJunRunnable runnable = new TanJiaJunRunnable();
        // 创建线程
        Thread thread = new Thread(runnable);
        // 启动线程
        thread.start();
    }

}

这种方式的优点是因为Java的类可以实现多个接口，所以这个类就可以继承自己需要的类了，而且任务和代码分离，如果多个线程执行相同的任务时，可以公用同一个任务的代码，如果需要对它们区分，可以添加参数进行区分。

使用FutureTask类

代码如下所示：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * Created by TanJiaJun on 2020/8/30.
 */
class TanJiaJunFutureTaskTest {

    private static class TanJiaJunCallable implements Callable {

        @Override
        public String call() {
            return "谭嘉俊";
        }

    }

    public static void main(String[] args) {
        // 创建FutureTask对象
        FutureTask futureTask = new FutureTask<>(new TanJiaJunCallable());
        // 创建线程
        Thread thread = new Thread(futureTask);
        thread.start();
        try {
            // 等待任务执行完毕，并且得到返回值
            String result = futureTask.get();
            System.out.println(result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }

}

前面两种方式都没有返回值，FutureTask可以有返回值。

wait系列方法和notify系列方法——线程等待和通知

wait()方法、wait(long timeoutMillis)方法、wait(long timeoutMillis, int nanos)方法、notify()方法和notifyAll()方法都是Object类的方法。

wait系列方法

当一个线程调用共享变量的wait系列方法时，这个线程进入等待状态，直到使用下面两种方式才会被唤醒：

• 其他线程调用该共享变量的notify系列方法（notify()方法或者notifyAll()方法）。
• 其他线程调用该共享变量所在的线程的interrupt()方法后，该线程抛出InterruptedException异常返回。

要注意的是，需要获取到该共享变量的监视器锁才能调用wait方法，否则会抛出IllegalMonitorStateException异常，可以使用以下两种方式获得对象的监视器锁：

• 调用被关键字synchronized修饰的方法，代码如下所示：

  Object object = new Object();
  
  private synchronized void test() {
      try {
          // 调用变量object的wait()方法
          object.wait();
      } catch(InterruptedException e) {
           e.printStackTrace();
      }
  }
  

• 执行同步代码块，代码如下所示：

  Object object = new Object();
  
  synchronized(object) {
      try {
          // 调用变量object的wait()方法
          object.wait();
      } catch(InterruptedException e) {
           e.printStackTrace();
      }
  }
  

wait()

源码如下所示：

// Object.java
public final void wait() throws InterruptedException {
    wait(0L);
}

这个方法实际上调用了wait(long timeoutMillis)方法，参数timeoutMillis的值是0L。它的行为和调用wait(0L, 0)方法是一致的。

wait(long timeoutMillis)

源码如下所示：

// Object.java
public final native void wait(long timeoutMillis) throws InterruptedException;

参数timeoutMillis是等待的最大时间，也就是超时时间，单位是毫秒。它的行为和调用wait(timeoutMillis, 0)方法是一致的。

要注意的是，如果传入了负数的timeoutMillis，就会抛出IllegalArgumentException异常。

wait(long timeoutMillis, int nanos)

源码如下所示：

// Object.java
public final void wait(long timeoutMillis, int nanos) throws InterruptedException {
    if (timeoutMillis < 0) {
        throw new IllegalArgumentException("timeoutMillis value is negative");
    }

    if (nanos < 0 || nanos > 999999) {
        throw new IllegalArgumentException(
                            "nanosecond timeout value out of range");
    }

    if (nanos > 0 && timeoutMillis < Long.MAX_VALUE) {
        timeoutMillis++;
    }

    wait(timeoutMillis);
}

这个方法实际上调用了wait(long timeoutMillis)方法；参数timeoutMillis是等待的最大时间，也就是超时时间，单位是毫秒；参数nanos是额外的时间，单位是纳秒，范围是0~999999（包括999999）。

只有在参数nanos大于0的时候，参数timeoutMillis才会自增。

notify系列方法

在一个线程上调用共享变量的notify方法后，会唤醒这个共享变量上调用wait系列方法后进入等待状态的线程。要注意的是，一个共享变量可能有多个线程在等待，具体唤醒哪个等待的线程是随机的。

被唤醒的线程不能立即从wait系列方法返回后继续执行，它需要获取到该共享变量的监视器锁才能返回，也就是说，唤醒它的线程释放了该共享变量的监视器锁，被唤醒的线程不一定能获取到该共享变量的监视器锁，因为该线程还需要和其他线程去竞争这个监视器锁，只有竞争到这个监视器锁后才能继续执行。

只有当前线程获取到该共享变量的监视器锁后，才能调用该共享变量的notify系列方法，否则会抛出IllegalMonitorStateException异常。

notify()方法

源码如下所示：

// Object.java
@HotSpotIntrinsicCandidate
public final native void notify();

notifyAll()方法

源码如下所示：

// Object.java
@HotSpotIntrinsicCandidate
public final native void notifyAll();

notifyAll()方法可以唤醒所有在该共享变量上因为调用wait系列方法而进入等待状态的线程。

sleep()方法——让线程睡眠

sleep()方法是Thread类的一个静态方法。当一个正在执行的线程调用了这个方法后，调用线程会暂时让出指定睡眠时间的执行权，不参与CPU的调度，但是不会让出该线程所拥有的监视器锁。指定的睡眠时间到了后，sleep()方法会正常返回，线程处于就绪状态，然后参与CPU调度，获取到CPU资源后继续运行。

要注意的是，如果在睡眠期间其他线程调用了该线程的interrupt()方法中断了该线程，就会在调用sleep方法的地方抛出InterruptedException异常而返回。

源码如下所示：

// Thread.java
public static native void sleep(long millis) throws InterruptedException;

下面来看一个生产者消费者问题（Producer-Consumer Problem）的例子：

Repository类是一个存储库，存放产品，代码如下所示：

package producerconsumerproblem;

import java.util.LinkedList;
import java.util.Queue;

/**
 * Created by TanJiaJun on 2020/8/30.
 */
class Repository {

    // 队列的最大容量是10
    private static final int MAX_SIZE = 10;
    // 创建队列
    private final Queue