//線程工廠
public class TaskThreadFactory implements ThreadFactory {

 private final AtomicInteger mThreadNumber = new AtomicInteger(1);



 private final String mNamePrefix;

 TaskThreadFactory(String name) {
  mNamePrefix = name + "#";
 }

 public Thread newThread(Runnable r) {
  Thread t = new Thread(r,mNamePrefix + mThreadNumber.getAndIncrement());

//  if (t.isDaemon())
//   t.setDaemon(false);
//
//  if (t.getPriority() != Thread.NORM_PRIORITY)
//   t.setPriority(Thread.NORM_PRIORITY);

  return t;
 }
}

//重寫runnable
public class PRunnable implements Runnable {

 public static final int HIGH = 1;//優先級高
 public static final int NORMAL = 2;//優先級中等
 public static final int LOW = 3;//優先級低
 @IntDef({HIGH,NORMAL,LOW})
 @Retention(RetentionPolicy.SOURCE)
 public @interface Priority{}

 public final int priority;
 private final Runnable runnable;
 public int serial;

 public PRunnable(Runnable runnable){
  this(NORMAL,runnable);
 }

 public PRunnable(@Priority int priority,Runnable runnable){
  this.priority = priority;
  this.runnable = runnable;
 }

 @Override
 public void run() {
  if (runnable != null) {
   runnable.run();
  }
 }

 /**
  * 線程隊列方式 先進先出
  * @param r1
  * @param r2
  * @return
  */
 public static final int compareFIFO(PRunnable r1, PRunnable r2) {
  int result = r1.priority-r2.priority;
  return result==0?r1.serial-r2.serial:result;
 }

 /**
  * 線程隊列方式 后進先出
  * @param r1
  * @param r2
  * @return
  */
 public static final int compareLIFO(PRunnable r1, PRunnable r2) {
  int result = r1.priority-r2.priority;
  return result==0?r2.serial-r1.serial:result;
 }
}

//線程池實現
public class TaskExecutor implements Executor {

 private final static int QUEUE_INIT_CAPACITY = 20;

 private static final int CORE = 3;

 private static final int MAX = 5;

 private static final int TIMEOUT = 30 * 1000;

 private AtomicInteger SERIAL = new AtomicInteger(0);//主要獲取添加任務

 public static class Config {
  public int core;

  public int max;

  public int timeout;

  public boolean allowCoreTimeOut;

  public boolean fifo;

  public Config(int core, int max, int timeout, boolean allowCoreTimeOut,boolean fifo) {
   this.core = core;
   this.max = max;
   this.timeout = timeout;
   this.allowCoreTimeOut = allowCoreTimeOut;
   this.fifo = fifo;
  }
 }

 public static Config defaultConfig = new Config(CORE, MAX, TIMEOUT, true,true);


 private final String name;

 private final Config config;

 private ExecutorService service;

 public TaskExecutor(String name) {
  this(name, defaultConfig);
 }

 public TaskExecutor(String name, Config config) {
  this(name, config, true);
 }

 public TaskExecutor(String name, Config config, boolean startup) {
  this.name = name;
  this.config = config;

  if (startup) {
   startup();
  }
 }

 public void startup() {
  synchronized (this) {
   if (service != null && !service.isShutdown()) {
    return;
   }

   service = createExecutor(config);
  }
 }

 public void shutdown() {
  ExecutorService executor = null;

  synchronized (this) {
   // 交換變量
   if (service != null) {
    executor = service;
    service = null;
   }
  }

  if (executor != null) {
   // 停止線程
   if (!executor.isShutdown()) {
    executor.shutdown();
   }

   // 回收變量
   executor = null;
  }
 }

 private void executeRunnable(PRunnable runnable) {
  synchronized (this) {
   if (service == null || service.isShutdown()) {
    return;
   }
   runnable.serial = SERIAL.getAndIncrement();
   service.execute(runnable);
  }
 }

 @Override
 public void execute(Runnable runnable) {
  if (runnable instanceof PRunnable) {
   executeRunnable((PRunnable) runnable);
  }else{
   executeRunnable(new PRunnable(runnable));
  }
 }

 public Future<?> submit(Runnable runnable) {
  synchronized (this) {
   if (service == null || service.isShutdown()) {
    return null;
   }
   if (runnable instanceof PRunnable) {
    ((PRunnable) runnable).serial = SERIAL.getAndIncrement();
    return service.submit(runnable);
   }else{
    PRunnable pRunnable = new PRunnable(runnable);
    pRunnable.serial = SERIAL.getAndIncrement();
    return service.submit(pRunnable);
   }
  }
 }

 public void execute(Runnable runnable, @PRunnable.Priority int priority) {
  executeRunnable(new PRunnable(priority,runnable));
 }

 private ExecutorService createExecutor(Config config) {
  ThreadPoolExecutor service = new ThreadPoolExecutor(config.core, config.max, config.timeout,
    TimeUnit.MILLISECONDS, new PriorityBlockingQueue<Runnable>(QUEUE_INIT_CAPACITY, config.fifo ? mQueueFIFOComparator : mQueueLIFOComparator),
    new TaskThreadFactory(name), new ThreadPoolExecutor.DiscardPolicy());

  allowCoreThreadTimeOut(service, config.allowCoreTimeOut);

  return service;
 }

 public boolean isBusy() {
  synchronized (this) {
   if (service == null || service.isShutdown()) {
    return false;
   }
   if(service instanceof ThreadPoolExecutor){
    ThreadPoolExecutor tService = (ThreadPoolExecutor) service;
    return tService.getActiveCount() >= tService.getCorePoolSize();
   }
   return false;
  }
 }

 private static final void allowCoreThreadTimeOut(ThreadPoolExecutor service, boolean value) {
  if (Build.VERSION.SDK_INT >= 9) {
   allowCoreThreadTimeOut9(service, value);
  }
 }

 @TargetApi(9)
 private static final void allowCoreThreadTimeOut9(ThreadPoolExecutor service, boolean value) {
  service.allowCoreThreadTimeOut(value);
 }


 Comparator<Runnable> mQueueFIFOComparator = new Comparator<Runnable>() {

  @Override
  public int compare(Runnable lhs, Runnable rhs) {
   PRunnable r1 = (PRunnable) lhs;
   PRunnable r2 = (PRunnable) rhs;

   return PRunnable.compareFIFO(r1, r2);
  }
 };

 Comparator<Runnable> mQueueLIFOComparator = new Comparator<Runnable>() {

  @Override
  public int compare(Runnable lhs, Runnable rhs) {
   PRunnable r1 = (PRunnable) lhs;
   PRunnable r2 = (PRunnable) rhs;

   return PRunnable.compareLIFO(r1, r2);
  }
 };

}