java线程池

什么是线程池

线程池就是创建若干个可执行的线程放入一个池（容器）中，有任务需要处理时，会提交到线程池中的任务队列，处理完之后线程并不会被销毁，而是仍然在线程池中等待下一个任务

为什么要使用线程池

创建和销毁对象都是比较耗费时间的，使用线程就可以很好的避免频繁创建和销毁

可以用在哪些地方

线程池，数据库连接池
从JDK1.5起，提供了内置线程池

使用线程池的好处

1. 提高响应速度（减少了创建新线程的时间）
2. 降低资源消耗（重复利用线程池中线程，不需要每次都创 建）
3. 提高线程的可管理性：避免线程无限制创建、从而销毁系
   统资源，降低系统稳定性，甚至内存溢出或者 CPU 耗尽

举几个例子

使用线程池执行大量的Runnable命令

package pool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test1 {
    public static void main(String[] args) {
        //如何创建一个线程池
        //1.创建一个线程池，线程池内只有一个线程对象 -- 如果时间是一次两秒，一共有20个任务，那我们需要执行40秒
//        ExecutorService pool1 = Executors.newSingleThreadExecutor();
        //2.创建一个线程池，线程池内有线程的数量固定
        /**
         * 一共有10个线程，我们有20个任务，执行一次任务需要2秒
         * 也就是说，我们以前需要40秒，因为这里有10个线程，所以，
         * 需要4秒执行完毕
         */
 //      ExecutorService pool1 = Executors.newFixedThreadPool(10);
        //3. 创建一个线程池，线程池内的线程数量可以动态改变
        /**
         * 因为有20个任务，线程池会动态创建20个线程
         * 执行一个任务需要2秒，所以，这种运行2秒结束
         */
         ExecutorService pool1 = Executors.newCachedThreadPool();

        //使用线程执行大量的Runnable命令
        for (int i=0;i<20;i++){
            final int n=i;
            //使用匿名内部类  --- 这个是任务
            Runnable command = new Runnable() {
                @Override
                public void run() {
                    System.out.println("开始执行："+n);
                    try {
                        Thread.sleep(2000); //两秒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("执行结束："+n);
                }
            };  //-- 到这里时任务结束
            //将任务交给线程池内的线程去执行
            pool1.execute(command);
        }
        //关闭线程池
        pool1.shutdown();
    }
}

使用线程池执行大量的Callable命令

我们需要将其放到集合内，再去遍历集合，因为获取到的是返回值，如果按照上一个命令的想法去获取结果，第一种方式和第二种方式用的时间没有差距，都是一个一个输出的
所以我们先不输出值，先将其放到集合内，再去遍历集合去获取它的返回值

package pool;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

public class Test02 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //如何创建一个线程池
        //1.创建一个线程池，线程池内只有一个线程对象
        /**
         * 如果时间是一次两秒，一共有20个任务，那我们需要执行40秒
         */
//        ExecutorService pool1 = Executors.newSingleThreadExecutor();
        //2.创建一个线程池，线程池内有线程的数量固定
        /**
         * 一共有10个线程，我们有20个任务，执行一次任务需要2秒
         * 也就是说，我们以前需要40秒，因为这里有10个线程，所以，
         * 需要4秒执行完毕
         */
       ExecutorService pool1 = Executors.newFixedThreadPool(10);
        //创建一个集合
        List<Future> list = new ArrayList<Future>();

        //3. 创建一个线程池，线程池内的线程数量可以动态改变
        /**
         * 因为有20个任务，线程池会动态创建20个线程
         * 执行一个任务需要2秒，所以，这种运行2秒结束
         */
//        ExecutorService pool1 = Executors.newCachedThreadPool();

        //使用线程执行大量的Callable命令
        for (int i=0;i<20;i++){
            //使用匿名内部类
            //创建任务
            Callable<Integer> task = new Callable<Integer>() {
                @Override
                public Integer call() throws Exception {
                    Thread.sleep(2000);
                    return (int)(Math.random()*10)+1;
                }
            };//任务结束
            //将任务交给线程池内的线程去执行
            Future f = pool1.submit(task);
            list.add(f);
//            System.out.println(f.get());
        }
        //遍历集合
        for (Future ff:list){
            System.out.println(ff.get());
        }
        System.out.println("到此已经输出完毕");
        //关闭线程池
        pool1.shutdown();
    }
}