java多线程笔记（1）

1.Java线程的生命周期和基本状态

---

关于Java线程的生命周期，有这样一张图可以作为参考

该图基本描绘了Java线程的生存周期。
主要包括五种基本状态：
- 新建状态（New）：当新建线程创建后，就进入了新建状态，比如Thread t=new Thread()；
- 就绪状态(Runnable)：线程的start()方法被调用时，线程即进入了就绪状态，进入了可运行线程池。进入了就绪状态的线程只是说明线程已经做好了获取CPU的准备，并非是指线程会立即执行。
- 运行状态（Running）：获得了CPU资源，线程开始真正地执行。
- 阻塞状态（Blocked）：处在运行状态的线程由于某些原因暂时放弃CPU的使用权，停止运行，此时出于阻塞状态，直至重新进入就绪状态。视不同原因阻塞状态也分为3种：
1. 等待阻塞，运行状态的线程执行wait()方法，使本线程进入阻塞状态，JVM会将其放入等待池中；
2. 同步阻塞，运行中的线程在获取某个对象的同步锁时，该锁被其他线程所占据，JVM会将其放入锁池中；
3. 其他阻塞状态，通过调用线程的sleep()或者join()或者请求IO。当sleep()状态超时、join()等待线程终止或者超时、IO处理结束，线程会重新进入就绪状态。
- 死亡状态（Dead）：线程执行结束或者异常，线程的生命周期结束。

2.线程的创建

---

线程的创建一般而言有两种方式：一是继承Thread类，二是实现Runnable接口，重写它们的run()方法。这里还有一种：实现Callable和Future接口，创建线程。具体是创建Callable接口的实现类，并实现call()方法，使用FutureTask来实现Callable实现类的对象，并以此FutureTask对象作为Thread的Target来创建线程。
前两种方式比较常见，不做讨论，对第三种稍加介绍。

class MyCallable implements Callable<Integer> {
     private int i = 0;

     // 与run()方法不同的是，call()方法具有返回值
     @Override
     public Integer call() {
         int sum = 0;
         for (; i < 100; i++) {
             System.out.println(Thread.currentThread().getName() + " " + i);
             sum += i;
         }
         return sum;
     }
    public class ThreadTest {

      public static void main(String[] args) {

          Callable<Integer> myCallable = new MyCallable();    // 创建MyCallable对象
          FutureTask<Integer> ft = new FutureTask<Integer>(myCallable); //使用FutureTask来包装MyCallable对象

         for (int i = 0; i < 100; i++) {
              System.out.println(Thread.currentThread().getName() + " " + i);
             if (i == 30) {
                 Thread thread = new Thread(ft);   //FutureTask对象作为Thread对象的target创建新的线程
                thread.start();                      //线程进入到就绪状态
             }
        }

         System.out.println("主线程for循环执行完毕..");

         try {
             int sum = ft.get();            //取得新创建的新线程中的call()方法返回的结果
             System.out.println("sum = " + sum);
         } catch (InterruptedException e) {
            e.printStackTrace();
         } catch (ExecutionException e) {
             e.printStackTrace();
         }

     }
 }

我们可以发现在Callable接口中，不是再重写run()方法，线程的执行体变成了call()方法，并且具有返回值，同时在创建线程时使用了FutureTask作为包装对象，并且作为了Thread的Target对象。我们有必要看一下FutureTask的实现。

 public class FutureTask<V> implements RunnableFuture<V> {

     //....

 }

至此，关于FutureTask为何作为target依然不够明朗，但是RunnableFuture接口十分可疑，所以我们再接着看一看这个接口

public interface RunnableFuture<V> extends Runnable, Future<V> {

 void run();

 }

所以RunbableFuture同时实现了Runnable和Future接口，这样就使得FutureTask具有了Runnable和Future的双重特性。通过Runnable使得它可以作为new Thread()的Target，而Future让它能够获得新建线程中call()方法的返回值。

3.线程调度

---

线程调度的优先级

Java线程有优先级，优先级高的线程会获得更多的运行机会。Java线程的优先级用正数表示，范围为1-10，Thread类有以下几个静态常量：
- static int MAX_PRIORITY:线程可以具有的最高优先级10
- static int MIN_PRIORITY:线程最低优先级1
- static int NORM_PRIORITY:默认优先级5
Thread类的setPriority()和getPriority()可以分别用来设置和获取线程的优先级。
线程的优先级具有继承关系，比如在线程A中创建了线程B，那么AB将具有相同的优先级。
JVM提供的10个优先级与常见的操作系统并不能十分准确地映射，因而，在实际的应用中，如果希望程序能够在各种操作系统中完美移植，应当尽量使用Thread类下提供的三个静态常量优先级，以保证相同优先级的线程能够采取同样的调度方式。

线程调度相关方法

Thread.sleep(long mills)：线程睡眠，使得线程进入到阻塞状态，睡眠结束后进入到就绪状态。sleep()拥有较好的平台移植性。
Object.wait()：线程等待，当前进入到阻塞状态，直到有其它线程调用此对象的notify()或者notifyAll()方法。
Thread.yiled()：线程让步，暂停当前线程，将CPU让给其他相同优先级线程或者更高优先级线程。
Thread.join()：线程加入，等待其它线程终止，例如，在当前线程中，调用其它线程的join()方法，则线程阻塞直到其它线程执行结束，再进入到就绪状态。
Object.notify()：线程唤醒，唤醒在此对象监视器上的某个线程，如果所有线程都在等待，那么就选择其中一个唤醒，选择是任意的，并在实现做出决定是发生。线程通过调用wait()方法，在对象的监视器上等待。直到当前线程放弃对象上的锁定，才能执行被唤醒的线程。被唤醒的线程将以常规的方式与该对象上主动同步的其它线程进行竞争。

以下做进一步说明。