线程相关知识点

Executors类，提供了一系列工厂方法用于创先线程池，返回的线程池都实现了ExecutorService接口。
public static ExecutorService newFixedThreadPool(int nThreads)
创建固定数目线程的线程池。
public static ExecutorService newCachedThreadPool()
创建一个可缓存的线程池，调用execute 将重用以前构造的线程（如果线程可用）。
如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。
public static ExecutorService newSingleThreadExecutor()
创建一个单线程化的Executor。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代Timer类。

ExecutorService扩展了Executor并添加了一些生命周期管理的方法。一个Executor的生命周期有三种状态，运行 ，关闭 ，终止 。
Executor创建时处于运行状态。当调用ExecutorService.shutdown()后，处于关闭状态，isShutdown()方法返回true。
这时，不应该再想Executor中添加任务，所有已添加的任务执行完毕后，Executor处于终止状态，isTerminated()返回true。
如果Executor处于关闭状态，往Executor提交任务会抛出unchecked exception RejectedExecutionException

   ExecutorService service = Executors.newFixedThreadPool(5);
   for(int i=0;i<10;i++){
    final int count = i;
    Runnable runnable = new Runnable(){
     public void run(){
      System.out.println(Thread.currentThread().getName()+":"+count);
      try {
       Thread.sleep(2000);
      } catch (InterruptedException e) {
       e.printStackTrace();
      }
     }
    
    };
    service.submit(runnable);
   }
   service.shutdown();

Daemon线程
   Thread thread = new Thread(new Runnable() {
    public void run() {
     while (true) {
      System.out.println("hello world");
     }
    }
   });
   //不加这句主线程运行完之后,thread 将会继续执行,加上这句,当主线程结束时,thread也会结束
   thread.setDaemon(true);
   thread.start();
线程join
   System.out.println("thread a run");
   Thread threadB = new Thread(new Runnable(){
    public void run(){
     System.out.println("thread b begin");
     try {
      for(int i =0 ;i<5;i++){
       Thread.sleep(1000);
       System.out.println("thread b run");
      }
     } catch (InterruptedException e) {
      e.printStackTrace();
     }
     System.out.println("thread b end");
    }
   });
   threadB.start();
   //当线程使用join()加入至另一个线程时，另一个线程会等待这个被加入的线程工作完毕，然后再继续它的动作
   try {
    threadB.join();
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   System.out.println("thread a end");

   将 try join catch这块注释执行结果为:
   thread a run
   thread a end
   thread b begin
   thread b run
   thread b run
   thread b run
   thread b run
   thread b run
   thread b end
   放开后执行结果为:
   thread a run
   thread b begin
   thread b run
   thread b run
   thread b run
   thread b run
   thread b run
   thread b end
   thread a end
Callable与Future
java.util.concurrent.Callable与java.util.concurrent.Future类可以协助您完成Future模式。
Future模式在请求发生时，会先产生一个Future对象给发出请求的客户。它的作用类似于代理(Proxy)对象，
而同时所代理的真正目标对象的生成是由一个新的线程持续进行。真正的目标对象生成之后，将之设置到Future之中
，而当客户端真正需要目标对象时，目标对象也已经准备好，可以让客户提取使用。

下面是一个简单的例子,Callable完成某个费时的工作，工作结束后传回结果对象,我假定返回字符串很费时.当数据还没有到达时显示not get real data
public class MyCallable implements Callable<String>{
private String init;
public MyCallable(String init){
   this.init = init;
}

@Override
public String call() throws Exception {
   try {
    Thread.sleep(5000);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   return init+" hello world";
}

public static void main(String[] args) {
   Callable<String> mycallable = new MyCallable("davide");
   FutureTask<String> task = new FutureTask<String>(mycallable);
   Thread t = new Thread(task);
   t.start();
   try {
    while(true){
     if(task.isDone()){
      System.out.println(task.get());
      break;
     }else{
      System.out.println("not get real data");
     }
    }
   } catch (InterruptedException e) {
    e.printStackTrace();
   } catch (ExecutionException e) {
    e.printStackTrace();
   }
}
}