最近工作中遇到了一个需要将main job拆分成多个sub job并发跑的需求，想想自己之前Java里面零零散散看的多线程也基本上忘光了，于是顺手拿了本手边上厚得和砖头一样的《Java编程思想》开始从线程开始看。为了防止自己又变成小金鱼，还是记下一点吧。

定义任务

1. 实现Runnable接口
   需要实现该接口的run()方法。

public class Liftoff implements Runnable {
  private int countDown = 10;
  private static int taskCount = 0;
  private final int id = taskCount++;

  public Liftoff() {}
  public Liftoff(int countDown) {
    this.countDown = countDown;
  }
  private void status() {
    System.out.println("#" + id + "(" + (countDown > 0? countDown : "LiftOff") + ")");
  }
  @Override
  public void run() {
    while (countDown-- > 0) {
      status();
      Thread.yield();
    }
  }

上述代码中，run()方法通常会有某种形式的循环。一般会写成无限循环的模式知道满足某个条件使run()终止。
这里只是定义了任务，还未最终执行。

public static void main(String[] args) {
    LiftOff launch = new LiftOff();
    launch.run();
}

这段代码并未启动一个新的线程，它只是在main线程中调用了LiftOff类的run()方法。要实现线程行为，需要将该任务显示地附着在线程之上。

Thread.yield() 该方法的意思是建议线程调度器切换至另一线程执行，只是建议，并不能保证该线程会被切换。

2. Thread类
   我们改变main()方法。

  public static void main(String[] args) {
    for (int i = 0; i < 2; i++) {
      Thread thread = new Thread(new Liftoff());
      thread.start();
    }
    System.out.println("This should appear first");
}

可能出现的output如下

#0(9)  #1(9)  This should appear first
#0(8)  #1(8)  #0(7)  #1(7)  #0(6)  #1(6)  #1(5)  #0(5)  #1(4)  #0(4)  #1(3)  #0(3)  #1(2)  #0(2)  #1(1)  #0(1)  #1(LiftOff)  #0(LiftOff)  

可以看出main thread 和 new 出来的threads『并发』地执行了。并且new出来的两个threads之间也是『并发』执行的。不同任务的执行在线程换进换出时混在了一起。

Thread中的run()和start()
在上面的代码中，我们使用了start()方法。start()方法会创建新的线程，然后调用任务中的run()方法。而Thread()中的run()方法并不会创建新的线程，只是简单地调用任务中的run()方法。

3. Executor
   Executor可以管理Thread对象，从而简化了并发编程。
   (1) FixedThreadPool

  public static void main(String[] args) {
    ExecutorService executorService = Executors.newFixedThreadPool(2);
    for (int i = 0; i < 5; i++) {
      executorService.execute(new Liftoff());
    }
    executorService.shutdown();
  }

始终固定地只有n个线程，如果已经有了n个线程在执行，则别的任务需要等待。
如上代码的输出可能为

#0(9)  #1(9)  #0(8)  #1(8)  #0(7)  #1(7)  #0(6)  #1(6)  #0(5)  #1(5)  #0(4)  #1(4)  #0(3)  #1(3)  #0(2)  #1(2)  #0(1)  #1(1)  #0(LiftOff)  #1(LiftOff)  #2(9)  #3(9)  #2(8)  #3(8)  #2(7)  #3(7)  #2(6)  #3(6)  #2(5)  #3(5)  #2(4)  #3(4)  #2(3)  #3(3)  #2(2)  #3(2)  #2(1)  #3(1)  #2(LiftOff)  #3(LiftOff)  #4(9)  #4(8)  #4(7)  #4(6)  #4(5)  #4(4)  #4(3)  #4(2)  #4(1)  #4(LiftOff)  

可以看出始终只有两个线程在「并发」地跑。0和1之间，2和3之间在不停切换。
(2) CachedThreadPool

  public static void main(String[] args) {
    ExecutorService executorService = Executors.newCachedThreadPool();
    for (int i = 0; i < 5; i++) {
      executorService.execute(new Liftoff());
    }
    executorService.shutdown();
  }

CacheThreadPool为每个任务都创建一个线程，如果正好某个线程空闲，则任务会利用之前的线程。
上述代码的输出可能如下。

#0(9)  #1(9)  #2(9)  #3(9)  #4(9)  #0(8)  #1(8)  #2(8)  #3(8)  #4(8)  #0(7)  #1(7)  #2(7)  #3(7)  #4(7)  #0(6)  #1(6)  #2(6)  #3(6)  #4(6)  #0(5)  #1(5)  #2(5)  #3(5)  #4(5)  #0(4)  #1(4)  #2(4)  #3(4)  #4(4)  #0(3)  #1(3)  #2(3)  #3(3)  #4(3)  #0(2)  #1(2)  #2(2)  #3(2)  #4(2)  #0(1)  #1(1)  #2(1)  #3(1)  #4(1)  #0(LiftOff)  #1(LiftOff)  #2(LiftOff)  #3(LiftOff)  #4(LiftOff)  

可以看出5个线程之间在不停地来回切换。
(3) SingleThreadPool
与名字的意思一致。