《Java 高并发》03 线程的生命周期

相关概念

进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。

一个进程是一个独立的运行环境，它可以被看作一个程序或者一个应用。而线程是在进程中执行的一个任务。Java运行环境是一个包含了不同的类和程序的单一进程。线程可以被称为轻量级进程。线程需要较少的资源来创建和驻留在进程中，并且可以共享进程中的资源。

多线程程序中，多个线程被并发的执行以提高程序的效率，CPU不会因为某个线程需要等待资源而进入空闲状态。多个线程共享堆内存(heap memory)，因此创建多个线程去执行一些任务会比创建多个进程更好。举个例子，Servlets 比 CGI 更好，是因为 Servlets 支持多线程而 CGI 不支持。

这里所谓的多个线程“同时”执行是人的感觉，实际上，是多个线程轮换执行。

线程调度器(Thread Scheduler)是一个操作系统服务，它负责为Runnable状态的线程分配CPU时间。一旦我们创建一个线程并启动它，它的执行便依赖于线程调度器的实现。

时间片(Time Slicing)是指将可用的CPU时间分配给可用的Runnable线程的过程。分配CPU时间可以基于线程优先级或者线程等待的时间。线程调度并不受到Java虚拟机控制，所以由应用程序来控制它是更好的选择(也就是说不要让你的程序依赖于线程的优先级)。

线程的生命周期(六种状态)

public enum State {

    NEW,

    RUNNABLE,

    BLOCKED,

    WAITING,

    TIMED_WAITING,

    TERMINATED;
}

• NEW：只存在于线程刚创建，未调用start之前。

MyThread myThread = new MyThread();
        System.out.println(myThread.getState());

• RUNNABLE：正在 JVM 中执行，但是这个"执行"，不一定是真的在运行， 也有可能是在等待CPU资源。所以，在网上，有人把这个状态区分为READY和RUNNING两个，一个表示的start了，资源一到位随时可以执行，另一个表示真正的执行中,这取决于操作系统处理器。

MyThread myThread = new MyThread();
        myThread.start();
        System.out.println(myThread.getState());

• BLOCKED：线程等待获取一个锁，来继续执行下一步的操作，比较经典的就是synchronized关键字，这个关键字修饰的代码块或者方法，均需要获取到对应的锁，在未获取之前，其线程的状态就一直未BLOCKED，如果线程长时间处于这种状态下，我们就要当心是否会出现死锁的情况。

public class MyThreadTest {

    public static void main(String[] args) throws InterruptedException {
        byte[] lock = new byte[0];
        MyThread thread1 = new MyThread(lock);
        thread1.start();
        MyThread thread2 = new MyThread(lock);
        thread2.start();
        Thread.sleep(1000);//等一会再检查状态
        System.out.println(thread2.getState());
    }

}

class MyThread extends Thread {

    private byte[] lock = new byte[0];

    public MyThread(byte[] lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        synchronized (lock) {
            try {
                Thread.sleep(10000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("done");

        }
    }
}

• WAITING：等待状态。进入这个状态，一定是执行了如下的一些代码，例如

  • Object.wait()
  • Thread.join()
  • LockSupport.park()

  当一个线程执行了Object.wait()的时候，它一定在等待另一个线程执行Object.notify()或者Object.notifyAll()。或者一个线程thread，其在主线程中被执行了thread.join()的时候，主线程即会等待该线程执行完成。当一个线程执行了LockSupport.park()的时候，其在等待执行LockSupport.unpark(thread)。当该线程处于这种等待的时候，其状态即为WAITING。需要关注的是，这边的等待是没有时间限制的，当发现有这种状态的线程的时候，若其长时间处于这种状态，也需要关注下程序内部有无逻辑异常。

  LockSupport.park()

  public class MyThreadTest {
  
      public static void main(String[] args) throws InterruptedException {
          byte[] lock = new byte[0];
          MyThread thread1 = new MyThread(lock);
          thread1.start();
          Thread.sleep(100);
          System.out.println(thread1.getState());
          LockSupport.unpark(thread1);
          Thread.sleep(100);
          System.out.println(thread1.getState());
      }
  
  }
  
  class MyThread extends Thread {
  
      private byte[] lock = new byte[0];
  
      public MyThread(byte[] lock) {
          this.lock = lock;
      }
  
      @Override
      public void run() {
          LockSupport.park();
      }
  }

  Object.wait()

  public class MyThreadTest {
  
      public static void main(String[] args) throws InterruptedException {
          byte[] lock = new byte[0];
          MyThread thread1 = new MyThread(lock);
          thread1.start();
          Thread.sleep(100);
          System.out.println(thread1.getState()); //这时候线程状态应为WAITING
          synchronized (lock){
              lock.notify(); //notify通知wait的线程
          }
          Thread.sleep(100);
          System.out.println(thread1.getState());
      }
  
  }
  
  class MyThread extends Thread {
  
      private byte[] lock = new byte[0];
  
      public MyThread(byte[] lock) {
          this.lock = lock;
      }
  
      @Override
      public void run() {
          synchronized (lock){
              try {
                  lock.wait(); //wait并允许其他线程同步lock
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
          }
      }
  }

  Thread.join()

  public class MyThreadTest {
  
      public static void main(String[] args) throws InterruptedException {
              byte[] lock = new byte[0];
              MyThread1 thread1 = new MyThread1(lock);
              thread1.start();
              MyThread2 thread2 = new MyThread2(thread1);
              thread2.start();
              Thread.sleep(100);
              System.out.println(thread2.getState());
      }
  
  }
  
  class MyThread1 extends Thread {
  
      private byte[] lock = new byte[0];
  
      public MyThread1(byte[] lock) {
          this.lock = lock;
      }
  
      @Override
      public void run() {
          try {
              Thread.sleep(10000);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
      }
  }
  
  class MyThread2 extends Thread {
  
      Thread thread;
  
      public MyThread2(Thread thread) {
          this.thread = thread;
      }
  
      @Override
      public void run() {
          try {
              thread.join();
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
      }
  }

• TIMED_WAITING：这个状态和WAITING状态的区别就是，这个状态的等待是有一定时效的，即可以理解为WAITING状态等待的时间是永久的，即必须等到某个条件符合才能继续往下走，否则线程不会被唤醒。但是TIMED_WAITING，等待一段时间之后，会唤醒线程去重新获取锁。当执行如下代码的时候，对应的线程会进入到TIMED_WAITING状态。

  • Thread.sleep(long)
  • Object.wait(long)
  • Thread.join(long)
  • LockSupport.parkNanos()
  • LockSupport.parkUntil()

• TERMINATED：这个状态很好理解，即为线程执行结束之后的状态

线程的状态图