java 线程池《一》

package com;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
 * java线程池
 * @author yushen
 *
 */
public class testThreadPool {
  
  public static void main(String[] args) {
     //runCahed();
     runFixed();
     //runScheduled();
     //runExecutor();
  }
  
  //执行方法
  public static void runTest(int i){
    System.out.println("任务"+i+"运行中");
  }
  
  //缓存线程池如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程
  public static void runCahed(){
    //实力和线程类
    ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
    for (int i = 0; i < 6; i++) {
      final int index = i;
      try {
        Thread.sleep(index * 1000);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
      //执行
      cachedThreadPool.execute(new Runnable() {
        public void run() {
          //执行方法
          System.out.println(index);
          runTest(index);
        }
      });
    }
  }
  
  //定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
  public static void runFixed() {
    //设置最大线程三个
    ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
    for (int i = 0; i < 10; i++) {
      final int index = i;
      fixedThreadPool.execute(new Runnable() {
        public void run() {
          try {
            System.out.println(index);
            runTest(index);
            Thread.sleep(2000);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
      });
    }
  }
  
  // 定长线程池，支持定时及周期性任务执行。等带到一定时间执行，一次
  public static void runScheduled() {
    ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
    scheduledThreadPool.schedule(new Runnable() {
      public void run() {
        System.out.println("delay 3 seconds");
      }
    }, 3, TimeUnit.SECONDS);// 没三秒执行一层
  }

  // 定长线程池，支持定时及周期性任务执行。延迟一秒后每三秒在执行一层
  public static void runScheduledRepeat() {
    ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
    scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
      public void run() {
        System.out.println("sssssss");
      }
    }, 1, 3, TimeUnit.SECONDS); // 一秒后每三秒执行一次
  }
  
  //单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行
  public static void runExecutor() {
    ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
    for (int i = 0; i < 10; i++) {
      final int index = i;
      singleThreadExecutor.execute(new Runnable() {
        public void run() {
          try {
            System.out.println(index);//要执行的内容
            Thread.sleep(2000);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
      });
    }
  }
  
  
}