线程池

迈不过友情╰ 2022-03-06 14:34 401阅读 0赞

# 线程池 #

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;
       }
    }

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