Java 线程池

1 了解线程池

线程池:其实就是一个容纳多个线程的容器,其中的线程可以反复的使用，
省去了频繁创建和销毁线程对象的操作,无需反复创建线程而消耗过多资源。

为什么要用线程池：
合理利用线程池能够带来三个好处
1.降低资源消耗。
– 减少了创建和销毁线程的次数，每个工作线程都
可以被重复利用，可执行多个任务。

2.提高响应速度
– 不需要频繁的创建线程，如果有
线程可以直接用，不会出现系统僵死！

3.提高线程的可管理性（线程池可以约束系统最多只能有多少个线程，
不会因为线程过多而死机）

线程池的核心思想：线程复用，同一个线程可以被重复使用，来处理多个任务。

2 线程池的创建方式

2.1

/**
   目标：创建一个线程池。
   线程池在Java中的代表类：ExecutorService(接口)。
   Java在Executors类下提供了一个静态方法得到一个线程池的对象：
        1.public static ExecutorService newFixedThreadPool(int nThreads)：
           创建一个线程池返回。
   ExecutorService提交线程任务对象执行的方法：
        1.Future<?> submit(Runnable task):提交一个Runnable的任务对象给线程池执行。
*/
public class ThreadPoolsDemo02 {
   public static void main(String[] args) {
       // 1.创建一个Java自带的固定线程数据量的线程池
       ExecutorService pools = Executors.newFixedThreadPool(3);

       // 2.创建线程任务对象
       Runnable target = new MyRunnable();
       pools.submit(target); // 创建新线程，执行此任务，自动触发执行线程！
       pools.submit(target); // 创建新线程，执行此任务，自动触发执行线程！
       pools.submit(target); // 创建新线程，执行此任务，自动触发执行线程！
       pools.submit(target); // 复用之前线程，执行此任务，自动触发执行线程！

       pools.shutdown();
       //pools.shutdownNow(); // 立即关闭线程池的代码，无论任务是否执行完毕！
   }
}
//定义runnbale的线程任务类。
class MyRunnable implements Runnable{
   @Override
   public void run() {
       for(int i = 0 ; i < 5  ; i++ ) {
           System.out.println(Thread.currentThread().getName()+" ==> " + i );
       }
   }
}

2.2

/**
    目标：创建一个线程池。

    线程池在Java中的代表类：ExecutorService(接口)。

    Java在Executors类下提供了一个静态方法得到一个线程池的对象：
         1.public static ExecutorService newFixedThreadPool(int nThreads)：
            创建一个线程池返回。

    ExecutorService提交线程任务对象执行的方法：
         1.Future<?> submit(Runnable task):提交一个Runnable的任务对象给线程池执行。
         2.Future<?> submit(Callable task):提交一个Callable的任务对象给线程池执行。
    小结：
         pools.shutdown(); // 等待任务执行完毕以后才会关闭线程池
         pools.shutdownNow(); // 立即关闭线程池的代码，无论任务是否执行完毕！
         线程池中的线程可以被复用，线程用完以后可以继续去执行其他任务。
 */
public class ThreadPoolsDemo03 {
    public static void main(String[] args) {
        // 1.创建一个线程池
        ExecutorService pools = Executors.newFixedThreadPool(3);
        // 2.提交线程任务对象：Callable对象。
        Future<String> f1 = pools.submit(new MyCallable(10));  // 创建新线程，执行任务，自动触发执行
        Future<String> f2 = pools.submit(new MyCallable(20));  // 创建新线程，执行任务，自动触发执行
        Future<String> f3 = pools.submit(new MyCallable(30));  // 创建新线程，执行任务，自动触发执行
        Future<String> f4 = pools.submit(new MyCallable(40));  // 复用线程，执行任务，自动触发执行
        Future<String> f5 = pools.submit(new MyCallable(50));  // 复用线程，执行任务，自动触发执行

        pools.shutdown(); // 等待任务执行完毕以后才会关闭线程池
        // pools.shutdownNow(); // 立即关闭线程池的代码，无论任务是否执行完毕！ 在Callable中用这个会出问题！
        try{
            String rs1 = f1.get();
            String rs2 = f2.get();
            String rs3 = f3.get();
            String rs4 = f4.get();
            String rs5 = f5.get();
            System.out.println(rs1);
            System.out.println(rs2);
            System.out.println(rs3);
            System.out.println(rs4);
            System.out.println(rs5);

        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

class MyCallable implements Callable<String>{
    private int n ;
    public MyCallable(int n){
        this.n = n;
    }
    @Override
    public String call() throws Exception {
        int sum = 0 ;
        for(int i = 1 ; i <= n ; i++ ) {
            sum+=i;
        }
        return Thread.currentThread().getName()+":1-"+n+"的和:"+sum;
    }
}