Java多线程ThreadPoolExecutor

2016-07-11 本文已影响332人 zyhuttp

作用

一、使用简单
二、方便管理多线程
三、可重复利用线程

一个例子

通过下面这个例子，可以看出线程池使用起来非常简单、方便

public class StartProvider {
    public static void main(String[] args) {
        ExecutorService threadPoolExecutor = Executors.newFixedThreadPool(2);
        for (int i = 1; i < 7; ++i) {
            threadPoolExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("test");
                }
            });
        }
    }
}

Executors的newFixedThreadPool是创建一个大小固定，其它参数默认的线程池，然后执行Runnable任务，使用起来简单，下面是线程池的参数：

public ThreadPoolExecutor(int corePoolSize,  int maximumPoolSize, 
  long keepAliveTime,  TimeUnit unit,   BlockingQueue<Runnable> workQueue, 
  ThreadFactory threadFactory, RejectedExecutionHandler handler)

corePoolSize: 核心线程数（常驻线程池的线程数）
maximumPoolSize: 线程池中最大线程数目
keepAliveTime: 池中线程数多于核心线程并且idle时，多于核心线程的其它线程存活时间
unit: keepAliveTime时间单位
workQueue: 存放任务的队列（核心线程满了之后，任务先进队列）
threadFactory: 创建线程的线程工厂
handler: 线程池处理抛弃任务策略

参数设置

根据任务和运行的环境情况（cpu型，io型，cpu核数等），设置参数的值，提高硬件的利用率
corePoolSize
核心线程数的大小，在线程池初始化完成后，池中的线程个数为0，每添加一个任务，线程池就增加一个线程直到线程个数等于corePoolSize。对CPU繁忙型任务线程池大小(CPU核数为N)

线程池大小 = N + 1

对IO繁忙型任务线程池大小为

线程池大小 = (IO操作时间 + CPU运行时间)/CPU运行时间× N 或 2×N +１

maximumPoolSize
最大线程数，当workQueue已满且线程池中的线程数少于maximumPoolSize时，如有新任务，就会创建新的线程，一直到线程池中的线程大小为maximumPoolSize。
keepAliveTime
idle线程(线程数大于corePoolSize且为idle)的存活时间，线程需要占用资源，多余线程需要消亡，这些多余线程在将来很短时间内也可能需要用到，keepAliveTime × unit是这些线程的存活时间。当任务数呈峰谷周期变化时，keepAliveTime × unit设置为半周期，可以减少线程的创建和销毁开销。idle线程是存活keepAliveTime时间是通过取阻塞队列里面的任务延时来实现的：

Runnable r = timed ? 
workQueue.poll(keepAliveTime,TimeUnit.NANOSECONDS) : workQueue.take();

和keepAliveTime相对应的是allowCoreThreadTimeOut，表示线程池中的核心线程是否销毁，线程池中的核心线程空闲较多时，通过设置allowCoreThreadTimeOut的值来表示是否销毁idle的核心线程。通过线程池的getActiveCount可以获取线程池中正在执行的线程数
workQueue
阻塞队列，用于存储任务。常用的阻塞队列有LinkedBlockingQueue、PriorityBlockingQueue和SynchronousQueue，它们分别用于不同的场景。LinkedBlockingQueue可以设置为有界阻塞队列和无界阻塞队列，按先进先出的顺序执行任务；PriorityBlockingQueue优先级队列，根据Compatator比较器可以设置不同任务的执行顺序；SynchronousQueue同步队列，在插入一个任务进入队列以后，需要取出这个任务才能继续插入。
threadFactory
线程工厂，继承ThreadFactory可定制线程工厂
handler
任务队列满，且线程池中的线程数达到最大值(maximumPoolSize)，有新任务到来时，线程池用handler策略处理新任务。通过继承RejectedExecutionHandler类可以定制处理策略，默认提供了三种处理策略：

CallerRunsPolicy: 在当前线程中执行任务

public class Main {
    public static void main(String[] args){
        final ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2,
                0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>(1),
                Executors.defaultThreadFactory(), new ThreadPoolExecutor.CallerRunsPolicy());

        for (int i = 1; i <= 5; ++i) {
            final int index = i;
            threadPoolExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        if(!"main".equals(Thread.currentThread().getName())) {
                            Thread.sleep(1000);
                        }
                    } catch (InterruptedException e) {
                        System.out.println("nothing");
                    }
                    System.out.println("threadPoolInfo:poolSize = " + threadPoolExecutor.getPoolSize() + " queue size =" +  threadPoolExecutor.getQueue().size() +
                            ", currentTime:"  + System.currentTimeMillis() +  ", index = " + index + ", current thread name:" + Thread.currentThread().getName());
                }
            });
        }

        System.out.println("end");
    }
}

执行结果

线程池任务超出负载时，任务由线程池所在的线程执行，例子中的为main线程

AbortPolicy：不执行任务（默认策略），并抛出RejectedExecutionException

public class Main {
    public static void main(String[] args){
        final ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(1, 2,
                0L, TimeUnit.MILLISECONDS,
                new LinkedBlockingQueue<Runnable>(1),
                Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());

        for (int i = 1; i <= 12; ++i) {
            final int index = i;
            try {
                threadPoolExecutor.execute(new Runnable() {
                    @Override
                    public void run() {
                        System.out.println("threadPoolInfo:poolSize = " + threadPoolExecutor.getPoolSize() + " queue size =" + threadPoolExecutor.getQueue().size() +
                                ", currentTime:" + System.currentTimeMillis() + ", index = " + index + ", current thread name:" + Thread.currentThread().getName());
                    }
                });
            } catch (RejectedExecutionException e) {
                System.out.println("message : " + e.getMessage());
                try {
                    Thread.sleep(1000);
                } catch(InterruptedException e1) {
                    System.out.println("interrupted");
                }
            }
        }
        System.out.println("end");
    }
}

执行结果

线程池任务超出负载时，没有执行任务，并抛出RejectExecutionException。抛出异常时，需要捕获异常，不然无法使用线程池。

DiscardPolicy：不执行任务，不抛出异常（静默策略）
DiscardOldestPolicy ：抛弃阻塞队列中最久的任务

一个问题

线程池是如何重复多次利用线程的？通过阻塞队列，阻塞队列中没有任务时阻塞线程，有任务则取出任务执行，其原理和下面片段类似，但是复杂很多

public class Main {
    public static void main(String[] args) {
        final BlockingQueue<Runnable> blockingQueue = new LinkedBlockingQueue<Runnable>();
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        Runnable runnable = blockingQueue.take();
                        runnable.run();
                        System.out.println("blocking........");
                    } catch (InterruptedException e) {
                        System.out.println("interrupted");
                    }
                }
            }
        }).start();

        blockingQueue.add(new Runnable() {
            @Override
            public void run() {
                System.out.println("execute task!");
            }
        });
    }
}

线程池中线程线程需要销毁则调用阻塞队列的poll方法，设置阻塞超时时间；否则调用take方法阻塞

关闭

shutdown和shutdownNow未关闭线程池的两个操作，shutdown关闭idle线程，线程池里面的任务继续执行；shutdownNow不等待线程执行完毕，直接关闭线程。

Java多线程ThreadPoolExecutor

作用

一个例子

参数设置

一个问题

关闭

猜你喜欢

热点阅读