CH03-线程基础-1

线程状态

New：新建，创建后尚未启动。
Runnable：可运行，可能正在运行，也可能在等待 CPU 时间片。
- 包含操作系统线程状态的 Running 和 Ready。
Blocking：等待获取一个排它锁，如果其他线程释放了锁就会结束该状态。
Waiting：无限期等待，需要其他线程唤醒，否则不会分配 CPU 时间片。
- 未设置 Timeout 参数的 Object.wait 方法，需要 Object.notify 或 Object.notifyAll 唤醒
- 未设置 Timeout 参数的 Thread.join 方法，被调用的线程执行完毕
- LockSupport.park 调用
Timed Waiting：限时等待，在一定时间后自动唤醒。
- 调用 Thread.sleep 方法，线程睡眠
- 设置了 Timeout 参数调用 Object.wait 进入限期等待，挂起线程
  - 睡眠和挂起用于表述行为，阻塞和等待用于描述状态
  - 阻塞和等待的区别在于，阻塞是被动的，等待的是一个排它锁，锁的释放由其他线程决定。
  - 等待是祖东的，等待的是一个时间点，是线程自身通过 Thread.sleep 或 Object.wait 主动触发的等待。
- 设置了 Timeout 参数调用 Thread.join 方法
- LockSupport.parkNanos
- LockSupport.parkUntil
Terminated：死亡，线程结束任务之后自然死亡，或异常导致任务终止而死亡

应用方式

实现 Runnable 接口：无返回值
实现 Callable 接口：有返回值
继承 Thread 类

实现 Runnable 后 Callable 接口的类只能被当做是一个可以在线程中执行的任务，并不是真正意义上的线程实例，因此最后还是需要通过 Thread 类来调用。即任务是通过线程来执行的。

线程机制

Executor

Executor 管理多个异步任务的执行，而无需开发者显式管理线程的生命周期。这里的异步是指多个任务的执行互不干扰，不需要执行同步操作。

CachedThreadPool：每个任务创建一个线程
FixedThreadPool：所有任务共用固定数量的线程
SingleThreadExecutor：仅有一个线程的 FixedThreadPool

Daemon

守护线程是程序运行时在后台提供服务的线程，不属于程序中必要的部分，非必须。

当所有非守护线程结束时，程序即终止，同时会杀死所有守护线程。
main 属于非守护线程。
通过 setDaemon 方法将一个线程设置为守护线程。

sleep

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

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

yield

对静态方法 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");
  }

  // 在线程 sleep 期间中断，“Thread run” 将不会被打印
  Main run
    java.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
}

Executor 中断操作

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

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

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");

// 在线程 sleep 期间被中断，不会打印 "Thread run"
Main run
java.lang.InterruptedException: sleep interrupted

如果想要中断 Executor 中的一个线程，可以通过 submit 方法提交一个任务，然后返回一个 Future 对象，调用该 Future 对象的 cancel 方法即可中断对应线程：

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

线程同步：互斥

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

synchronized

同步代码块
- 只作用于同一个对象实例，比如 new Object()，如果调用两个对象上的同步代码块，就不会进行同步。
同步方法
- 它和同步代码块一样，作用于同一个对象。只是作用在了该方法所属的实例。
同步类
- 作用于整个类，也就是说两个线程调用同一个类的不同对象上的这种同步语句，也会进行同步。
同步静态方法
- 作用于整个类。

ReentrantLock

ReentrantLock 是 java.util.concurrent(J.U.C)包中的锁。

private Lock lock = new ReentrantLock();

public void func() {
    lock.lock();
    try {
        for (int i = 0; i < 10; i++) {
            System.out.print(i + " ");
        }
    } finally {
        lock.unlock(); // 确保释放锁，从而避免发生死锁。
    }
}

基本对比

实现层次：
- synchronized 是 JVM 实现的，而 ReentrantLock 是 JDK 实现的。
性能：
- 新版本 Java 对 synchronized 进行了很多优化，例如自旋锁等，synchronized 与 ReentrantLock 大致相同。
等待可中断：
- 当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情。
- ReentrantLock 可中断，而 synchronized 不行。
公平锁
- 公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁。
- synchronized 中的锁是非公平的，ReentrantLock 默认情况下也是非公平的，但是也可以是公平的。
锁绑定多个条件
- 一个 ReentrantLock 可以同时绑定多个 Condition 对象。

应用选择

除非需要使用 ReentrantLock 的高级功能，否则优先使用 synchronized。这是因为 synchronized 是 JVM 实现的一种锁机制，JVM 原生地支持它，而 ReentrantLock 不是所有的 JDK 版本都支持。并且使用 synchronized 不用担心没有释放锁而导致死锁问题，因为 JVM 会确保锁的释放。

线程协作

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

join

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

wait、notify、notifyAll

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

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

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

使用 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());
  }

  // before
	// after
}

wait() 和 sleep() 的区别

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

await() signal() signalAll()

JUC 类库中提供了 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());
  }

  // before
	// after
}

Feedback

Was this page helpful?

Glad to hear it! Please tell us how we can improve.

Sorry to hear that. Please tell us how we can improve.