多线程预备知识（二）----线程状态，调度算法及死锁

线程/进程的基本状态

和传统的进程一样，线程也拥有三种基本状态，分别是

• 执行状态：表示该线程获得了CPU的执行权正在运行
• 就绪状态：表示该线程已经具备了执行所需要的预备条件，等待CPU调度就可以立即执行，在Java中体现为调用了start（）方法，或者线程休眠时间完毕等等。但是此时还没有开始执行。需要等待cpu的调度
• 阻塞状态：表示该线程在执行过程中因为受阻，例如等待另一个资源而处于暂停状态。在Java中可以体现为调用了wait（）方法等，其中阻塞状态又分为三种
  • 同步阻塞：在获取一个对象的时候，发现这个对象被其他的线程上了锁，就会进入同步阻塞状态
  • 等待阻塞：例如调用了wait()方法时，会把该线程放进等待队列
  • 其他阻塞：调用了sleep()，或者线程发出了IO请求，就会进入到阻塞状态，当IO完毕或者休眠时间完毕则会到就绪状态

在原有的基础上，满足完整性，也会引入最常见的的两种状态：新建和终止状态

• 新建状态：可以理解成没有满足线程创建所需的资源所处的一个状态，在Java中可以体现为创建了一个线程，但是还没有调用start（）方法
• 终止状态：当线程运行完毕，或者抛出异常导致了线程的终止，结束了线程的生命周期

上图就说明了线程之间转化的五种状态

进程的调度算法

CPU的调度算法有非常多，由于是多线程系列的文章，就讲一下跟线程最相关的几种思想，一是抢占式调度，二是时间片轮转调度。现在很多的操作系统都是采用这两者结合的方式去进行调度的。

抢占式调度：

这种调度方式允许程序依据某种原则，去暂停某个正在执行的进程，将已经分配给该进程的处理机重新分配给另一个进程，现在的操作系统都普遍才用了这个方式，但是这个抢占也不是任意的，随随便便乱抢，也需要遵循一定的规则

• 优先权原则：对于优先级高的线程，允许优先级高的线程抢占优先级低线程的cpu执行权
• 短作业优先：执行时间短的线程允许抢占执行时间长线程的执行权
• 时间片原则：各进程按时间片轮流运行，当一个时间片用完后，便停止该进程的执行而重新进行调度

时间片轮转

每个线程都被分配相等的时间片，轮流在自己的时间片时间内使用cpu，当cpu用完之后，就丢失cpu的执行权，然后将执行权给拥有时间片的线程去调度，本身回到就绪队列等待下一次的调度。

死锁

死锁，可以理解成死局，顾名思义就是没有外力因素的情况下解不开的锁，在操作系统层面，死锁就是，由于资源竞争或者相互等待的情况下造成的一种阻塞现象。比如说这种情况进程A锁住了资源1想要资源2，而进程B锁住了进程2想要资源1，在这种情况下，他们俩都获取不到彼此想要的资源，然后就会一直处于等待状态，这个时候就造成了死锁

死锁产生的原因

对于有一定操作系统知识的朋友来说，应该知道，死锁产生的必须具备四个条件：

• 互斥条件：简单的理解就是，某个资源只能被一个线程使用，当该资源被使用了，就会拒绝其他线程的使用请求，其他线程就会进入阻塞状态

• 请求并持有条件：意思就是，A线程有一个或多个资源的时候，当他去请求另一个资源，但是那个资源被B线程占有了，此时A资源则会进入阻塞状态，但是即便进入阻塞状态也不会释放自己有的资源。可以理解成，自私条件，我得不到的我想要，并且不会放弃手上有的。

• 不可剥夺条件：意思就是线程拥有的资源，在没用完之前，不会释放

• 环路等待条件：就是死锁的一个等待链的意思。例如T1线程等待T2的资源，T2等待T3的......以此类推

  下面举一个死锁的例子

  /**
   * 产生死锁的情况
   */
  public class DeadLockTest2 {
      private  static  Object resourceA = new Object();
      private  static  Object resourceB = new Object();
  
      public static void main(String[] args) {
          Thread thread1 = new Thread(new Runnable() {
              @Override
              public void run() {
                  synchronized (resourceA) {
                      System.out.println(Thread.currentThread() + "获取资源A");
                      try {
                          //休眠一秒 保证线程2可以获取资源B的锁
                          Thread.sleep(1000);
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                      System.out.println("等待获取资源B");
                      synchronized (resourceB) {
                          System.out.println(Thread.currentThread() + "获取资源B");
                      }
                  }
              }
          });
  
         Thread thread2 =  new Thread(new Runnable() {
              @Override
              public void run() {
                  synchronized (resourceB) {
                      System.out.println(Thread.currentThread() + "获取资源B");
                      try {
                          //休眠一秒,保证线程1去获取资源B 虽然会被阻塞
                          Thread.sleep(1000);
                      } catch (InterruptedException e) {
                          e.printStackTrace();
                      }
                      System.out.println("等待获取资源A");
                      synchronized (resourceA) {
                          System.out.println(Thread.currentThread() + "获取资源A");
                      }
                  }
              }
          });
         thread1.start();
         thread2.start();
      }
  }
  
  

  分析一下上面的代码，首先线程1拿到资源A的锁，然后线程1休眠一秒，保证线程2可以获取资源B的锁，之后线程2休眠1秒，此时线程1执行获取资源B的代码，但是资源B被线程2锁住了，因此线程1阻塞进入等待状态，这时线程2休眠结束，想要获取资源A，但是此时资源A被线程1锁住，因此也进入了阻塞等待状态。现在两个线程的状态就是这样：线程1锁住资源A想要B，线程2锁住线程B想要A，就陷入了相互等待的状态，造成了死锁。这段代码是如何满足线程死锁的四个条件呢？

  • 首先在这段代码里面，只有当线程1释放了资源A或者线程2释放了资源B才能被其他线程使用，否则就会阻塞，就满足了资源互斥条件
  • 请求并保持条件：线程1在执行完成之前，或者说获取到B资源之前，都不会释放资源A的锁。对于线程2来说也是同理，因此满足了请求并保持条件
  • 不可剥夺条件：线程1在获取了资源A的锁之后，在线程A主动释放，或者说获取到B资源之前，A资源都不会被线程2剥夺，这就满足了不可剥夺条件
  • 循环等待条件：线程1锁住资源A想要B，线程2锁住线程B想要A，就陷入了相互等待的状态，形成了一个环路，满足了循环等待的条件

  由于满足了以上四个条件，所以线程就有可能会进入到死锁状态，可能会造成死锁的状态在操作系统中被称为，不安全状态

如何避免死锁

想要避免死锁，只需要破坏其中一个条件必要条件就可以了，互斥条件由于资源的限制性，有一些资源是被限制了只能被一个线程使用，不然会乱套，例如打印机在打印的时候，只能被一台电脑使用么，不然就会出现问题。不可剥夺条件也是同理，也可以用打印机来解释，打印的时候不能给其他电脑，不然会出问题。因此唯一能破坏的只有请求并持有条件和环路等待条件。

最常用的避免死锁的方法就是保证资源申请的有序性。只需要把上面的死锁代码稍微改一下就ok，把任意一个线程的申请资源的顺序跟另一个线程一致。例如，此时我把线程2的资源改成了和线程1的顺序相同

/**
 * 保证两个线程获取资源的顺序一致就可以避免死锁 因为此时任意一个线程获取资源A的时候,另一个线程都会阻塞不会去获取资源B
 */
public class DeadLockTest3 {
    private  static  Object resourceA = new Object();
    private  static  Object resourceB = new Object();

    public static void main(String[] args) {
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (resourceA) {
                    System.out.println(Thread.currentThread() + "获取资源A");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread()+"等待获取资源B");
                    synchronized (resourceB) {
                        System.out.println(Thread.currentThread() + "获取资源B");
                    }
                }
            }
        });
        //修改了这个线程的获取顺序，和线程1一致
        Thread thread2 =  new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (resourceA) {
                    System.out.println(Thread.currentThread() + "获取资源A");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println( Thread.currentThread()+"等待获取资源B");
                    synchronized (resourceB) {
                        System.out.println(Thread.currentThread() + "获取资源B");
                    }
                }
            }
        });
        thread1.start();
        thread2.start();
    }
}

再回过头来分析新的安全代码，一开始线程1获取资源A，然后休眠1秒，到线程2执行，线程2首先想要获取资源A但是发现被锁住了，因此线程2阻塞，然后线程1休眠完毕，执行获取资源B的代码，获取到资源B，线程1执行完毕，释放资源A和B的锁。然后线程2获取资源A，再获取资源B，执行完毕，释放A和B的锁。代码执行完毕。可以发现，只要资源的申请顺序合理就可以打破请求持有条件和环路等待条件，就不会造成死锁