java线程池

文中会介绍多线程池中类的用法，最后会有一个代码编程实现了，使用普通方法与构造线程池方式来完成一个任务的性能对比。新建同数量的线程，添加相同的数据量，并销毁同数量的线程。

1.概述

从别人博客看到一张图，图就是讲ThreadPoolExecutor类怎么运行流程，图过程与源码注释一样

!

下图是从java的类关系图中截取下来的（使用idea的diagram查看）

​ 上图是线程池自顶向下的接口与类的继承与实现关系

接下来我们就从下到上讲一讲这些类或接口的定义，功能与方法。

2.讲一下java.util.concurrent.*的接口类，与实现类

1.ThreadPoolExecutor

ThreadPoolExecutor是Java线程池框架中最重要的类之一了，许多接口与虚类都依靠它来实例化，所以推荐去看源码。ThreadPoolExecutor的是一个实现构建线程池和众多方法的类，因为是实现类，所以可以满足各种线程池的需求。如果我们对线程池的要求不高，我们就可以使用Executors快速的创建线程池。

ThreadPoolExecutor构造方法如下：（参数比较多，构造起来比较麻烦）

ThreadPoolExecutor实现接口的所有方法，方法的功能会在以下的接口类中讲到，所以就不展示了，可以自己去看源码。

2.AbstractExecutorService

AbstractExecutorService虚类的方法如下：

?，因为newTask（*）方法在我的例子中也用不到，我也不讲了，自己看吧。

3.ExecutorService

ExecutorService的功能能对线程池线程进行管理，添加新任务，获取线程池信息，关闭线程池任务。

我们是使用java.util.concurrent.Executors 快速建立线程池并返回实例给ExecutorService。

接下来看一下ExecutorService的方法及其功能吧：

2.java.util.concurrent.Executors

Executors是一个能够帮助开发者快速建立线程池的工具类，有许多的构造线程池的方法，返回值为ExecutorService与ScheduledExecutorService。

ScheduledExecutorService

其中ScheduledExecutorService是继承ExecutorService的接口，扩展时间周期性执行的方法。

Executors建立线程池的实现方式

如上图所示，Executor能十分快的建立线程池并返回ExecutorService进行线程管理，但实际上Executors的建造线程池实际上就是调用ThreadPoolExecutor类的构造函数，因为Excutors封装了ThreadPoolExecutor方法，让开发者不需要输入许多参数就能创建线程池。

1.使用newFixedThreadPool(int i) 定义一个固定数量的线程池 ，

2.使用newCachedThreadPool（）定义一个没有上线的线程池，核心线程数为零，最大线程数没有界限只要资源足够。

3.编程，普通线程与线程池的方法实现性能对比

通过改变main函数中的注释来调整创建线程的方式。

package club.yzren.executor_;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

public class MainTest {
    public static final int maxnum=1000;
    public  static int  page=0;
    private  static boolean condition=true;
        public static void  main(String args[]){
            //使用普通的创建线程的方法,往List中添加数据到maxnum
           // threadNormal();

            //使用线程池数往List中添加数据到maxnum
         threadPool();

        }
        
        //普通的创建线程的方法
 public static void threadNormal() {
            long timeTemp = System.currentTimeMillis();
            List array = new ArrayList();
            for (int i = 0; i < maxnum; i++) {
                final int j = i;
                Thread thread = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        array.add(j);
                    }
                });
                thread.start();//普通线程启动
                try {
                    thread.join();//等待普通线程关闭，后才能执行主线程
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("threadNormal using:" + (System.currentTimeMillis() -timeTemp));

        }
        
        
        //使用线程池的方法
 public static void threadPool(){
            long timeTemp=System.currentTimeMillis();

            //使用Executors.newFixedThreadPool()的方法来构造线程池
            ExecutorService executorService=  Executors.newFixedThreadPool(1);
            List list=new ArrayList();
        for (int i=0;i<maxnum;i++){
            final int j=i;
           executorService.execute(new Runnable() {
               @Override
               public void run() {
                    list.add(j);
               }
           });
        }
                executorService.shutdown();//进行关闭线程池线程
            try {
                executorService.awaitTermination(1,TimeUnit.DAYS);//等待线程全部关闭
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("ThreadPool using:"+(System.currentTimeMillis()-timeTemp));

        }
}

性能对比结果图：