线程池

线程池

Java里面线程池的顶级接口是 java.util.concurrent.Executor ，
但是严格意义上讲 Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是java.util.concurrent.ExecutorService 。

要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在 java.util.concurrent.Executors 线程工厂类里面提供了一些静态工厂，生成一些常用的线程池。官方建议使用 Executors 工程类来创建线程池对象。
Executors类中有个创建线程池的方法如下：

• public static ExecutorService newFixedThreadPool(int nThreads)：返回线程池对 象。(创建的是有界线程池,也就是池中的线程个数可以指定最大数量)
• public Future<?> submit(Runnable task) :获取线程池中的某一个线程对象，并执行。

Future接口：用来记录线程任务执行完毕后产生的结果。

使用线程池中线程对象的步骤：

1. 创建线程池对象；
2. 定义类实现Runnable接口或Callable接口；
3. 重写run()方法或call()方法；
4. 创建Runnable或Callable实现类对象；
5. 使用线程池来提交任务；
6. 关闭线程池(一般不做)。

Runnable实现类代码：

public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("我要一个教练");
        try {
            Thread.sleep(2000);
       } catch (InterruptedException e) {
            e.printStackTrace();
       }
        System.out.println("教练来了： " +Thread.currentThread().getName());
        System.out.println("教我游泳,交完后，教练回到了游泳池");
   }
}

线程池测试类：

public class ThreadPoolDemo {
    public static void main(String[] args) {
        // 创建线程池对象
        ExecutorService service = Executors.newFixedThreadPool(2);//包含2个线程对象
        // 创建Runnable实例对象
        MyRunnable r = new MyRunnable();
        //自己创建线程对象的方式
        // Thread t = new Thread(r);
        // t.start(); ---> 调用MyRunnable中的run()
        // 从线程池中获取线程对象,然后调用MyRunnable中的run()
        service.submit(r);
        // 再获取个线程对象，调用MyRunnable中的run()
        service.submit(r);
        service.submit(r);
        // 注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。
         // 将使用完的线程又归还到了线程池中
        // 关闭线程池
        //service.shutdown();
   }
}

Callable 接口

Callable 接口其实和Runnable接口一样是用来放在子线程上执行的代码（任务）；
Callable 接口中也只有一个抽象方法 call()，这个抽象方法是有返回值的，返回值是泛型，而且可以抛出异常

ExecutorService 中的方法：

• Future submit(Callable task) : 获取线程池中的某一个线程对象，并执行.

Future :表示计算的结果.

Future中的方法：

• V get() : 获取计算完成的结果。

public class ThreadPoolDemo2 {
    public static void main(String[] args) throws Exception {
        // 创建线程池对象
      ExecutorService service = Executors.newFixedThreadPool(2);//包含2个线程对象
        // 创建Runnable实例对象
        Callable<Double> c = new Callable<Double>() {
            @Override
            public Double call() throws Exception {
                return Math.random();
           }
       };
        // 从线程池中获取线程对象,然后调用Callable中的call()
        Future<Double> f1 = service.submit(c);
        // Futur 调用get() 获取运算结果
        System.out.println(f1.get());
        Future<Double> f2 = service.submit(c);
        System.out.println(f2.get());
        Future<Double> f3 = service.submit(c);
        System.out.println(f3.get());
   }
}

线程池小案例：

需求: 使用线程池方式执行任务,返回1-n的和
分析: 因为需要返回求和结果,所以使用Callable方式的任务

代码：

public class Demo04 {
    public static void main(String[] args) throws ExecutionException,InterruptedException {
        ExecutorService pool = Executors.newFixedThreadPool(3);
        SumCallable sc = new SumCallable(100);
        Future<Integer> fu = pool.submit(sc);
        Integer integer = fu.get();
        System.out.println("结果: " + integer);
        
        SumCallable sc2 = new SumCallable(200);
        Future<Integer> fu2 = pool.submit(sc2);
        Integer integer2 = fu2.get();
        System.out.println("结果: " + integer2);
        pool.shutdown();
   }
}

SumCallable.java

public class SumCallable implements Callable<Integer> {
    private int n;
    public SumCallable(int n) {
        this.n = n;
   }
    @Override
    public Integer call() throws Exception {
        // 求1-n的和?
        int sum = 0;
        for (int i = 1; i <= n; i++) {
            sum += i;
       }
        return sum;
   }
}

小结：我们发现有了线程池后，线程的操作都是固定的步骤，我们的重点放在任务上.