1 线程就绪、运行和死亡状态转换

  1. 就绪状态转换为运行状态：此线程得到CPU资源；
  2. 运行状态转换为就绪状态：此线程主动调用yield()方法或在运行过程中失去CPU资源。
  3. 运行状态转换为死亡状态：此线程执行执行完毕或者发生了异常；

注意：

当调用线程中的yield()方法时，线程从运行状态转换为就绪状态，但接下来CPU调度就绪状态中的那个线程具有一定的随机性，因此，可能会出现A线程调用了yield()方法后，接下来CPU仍然调度了A线程的情况。

2 run & start

通过调用start启动线程，线程执行时会执行run方法中的代码。

  1. start()：线程的启动；
  2. run()：线程的执行体；

3 sleep & yield

sleep()：通过sleep(millis)使线程进入休眠一段时间，该方法在指定的时间内无法被唤醒，同时也不会释放对象锁；
比如，我们想要使主线程每休眠100毫秒，然后再打印出数字：

  1. /**
  2.  * 可以明显看到打印的数字在时间上有些许的间隔
  3.  */
  4. public class Test1 {  
  5.     public static void main(String[] args) throws InterruptedException {  
  6.         for(int i=0;i<100;i++){  
  7.             System.out.println("main"+i);  
  8.             Thread.sleep(100);  
  9.         }  
  10.     }  
  11. }

注意如下几点问题：

  1. sleep是静态方法，最好不要用Thread的实例对象调用它，因为它睡眠的始终是当前正在运行的线程，而不是调用它的线程对象，它只对正在运行状态的线程对象有效。看下面的例子： ```java public class Test1 {
    public static void main(String[] args) throws InterruptedException { 
    1.  System.out.println(Thread.currentThread().getName());  
    2.  MyThread myThread=new MyThread();  
    3.  myThread.start();  
    4.  // 这里sleep的就是main线程，而非myThread线程 
    5.  myThread.sleep(1000); 
    6.  Thread.sleep(10);  
    7.  for(int i=0;i<100;i++){  
    8.      System.out.println("main"+i);  
    9.  }
    }
    } 
  2. 2. Java线程调度是Java多线程的核心，只有良好的调度，才能充分发挥系统的性能，提高程序的执行效率。但是不管程序员怎么编写调度，只能最大限度的影响线程执行的次序，而不能做到精准控制。**因为使用sleep方法之后，线程是进入阻塞状态的，只有当睡眠的时间结束，才会重新进入到就绪状态，而就绪状态进入到运行状态，是由系统控制的，我们不可能精准的去干涉它**，所以如果调用Thread.sleep(1000)使得线程睡眠1秒，可能结果会大于1秒。
  3. ```java
  4. public class Test1 {  
  5.     public static void main(String[] args) throws InterruptedException {  
  6.         new MyThread().start();  
  7.         new MyThread().start();  
  8.     }  
  9. }  
  11. class MyThread extends Thread {  
  12.     @Override  
  13.     public void run() {  
  14.         for (int i = 0; i < 3; i++) {  
  15.             System.out.println(this.getName()+"线程" + i + "次执行！");  
  16.             try {  
  17.                 Thread.sleep(50);  
  18.             } catch (InterruptedException e) {  
  19.                 e.printStackTrace();  
  20.             }  
  21.         }  
  22.     }  
  23. }

看某一次的运行结果：可以发现，线程0首先执行，然后线程1执行一次，又了执行一次。发现并不是按照sleep的顺序执行的。

  1. Thread-0线程0次执行！  
  2. Thread-1线程0次执行！  
  3. Thread-1线程1次执行！  
  4. Thread-0线程1次执行！  
  5. Thread-0线程2次执行！  
  6. Thread-1线程2次执行！