java线程池常见问题

最新推荐文章于 2024-07-17 13:55:08 发布

liyidaozhang

最新推荐文章于 2024-07-17 13:55:08 发布

阅读量1k

点赞数 1

分类专栏：杂项-各种原理文章标签： java 线程池线程

本文链接：https://blog.csdn.net/liyidaozhang/article/details/72860944

版权

杂项-各种原理专栏收录该内容

5 篇文章 0 订阅

订阅专栏

java线程池常见问题

常见的四种java线程池

Java通过Executors提供四种线程池，分别为：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。

newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

1. newCachedThreadPool

创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。示例代码如下：

package test;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
public class ThreadPoolExecutorTest {  
 public static void main(String[] args) {  
  ExecutorService cachedThreadPool = Executors.newCachedThreadPool();  
  for (int i = 0; i < 10; i++) {  
   final int index = i;  
   try {  
    Thread.sleep(index * 1000);  
   } catch (InterruptedException e) {  
    e.printStackTrace();  
   }  
   cachedThreadPool.execute(new Runnable() {  
    public void run() {  
     System.out.println(index);  
    }  
   });  
  }  
 }  
}

线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。

2. newFixedThreadPool

创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。示例代码如下：

package test;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
public class ThreadPoolExecutorTest {  
 public static void main(String[] args) {  
  ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);  
  for (int i = 0; i < 10; i++) {  
   final int index = i;  
   fixedThreadPool.execute(new Runnable() {  
    public void run() {  
     try {  
      System.out.println(index);  
      Thread.sleep(2000);  
     } catch (InterruptedException e) {  
      e.printStackTrace();  
     }  
    }  
   });  
  }  
 }  
}

因为线程池大小为3，每个任务输出index后sleep 2秒，所以每两秒打印3个数字。
定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()。

3. newScheduledThreadPool

创建一个定长线程池，支持定时及周期性任务执行。延迟执行示例代码如下

package test;  
import java.util.concurrent.Executors;  
import java.util.concurrent.ScheduledExecutorService;  
import java.util.concurrent.TimeUnit;  
public class ThreadPoolExecutorTest {  
 public static void main(String[] args) {  
  ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);  
  scheduledThreadPool.schedule(new Runnable() {  
   public void run() {  
    System.out.println("delay 3 seconds");  
   }  
  }, 3, TimeUnit.SECONDS);  
 }  
}

表示延迟3秒执行

package test;  
import java.util.concurrent.Executors;  
import java.util.concurrent.ScheduledExecutorService;  
import java.util.concurrent.TimeUnit;  
public class ThreadPoolExecutorTest {  
 public static void main(String[] args) {  
  ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);  
  scheduledThreadPool.scheduleAtFixedRate(new Runnable() {  
   public void run() {  
    System.out.println("delay 1 seconds, and excute every 3 seconds");  
   }  
  }, 1, 3, TimeUnit.SECONDS);  
 }  
}

表示延迟1秒后每3秒执行一次。

4. newSingleThreadExecutor

创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。示例代码如下：

package test;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
public class ThreadPoolExecutorTest {  
 public static void main(String[] args) {  
  ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();  
  for (int i = 0; i < 10; i++) {  
   final int index = i;  
   singleThreadExecutor.execute(new Runnable() {  
    public void run() {  
     try {  
      System.out.println(index);  
      Thread.sleep(2000);  
     } catch (InterruptedException e) {  
      e.printStackTrace();  
     }  
    }  
   });  
  }  
 }  
}

CountDownLatch的使用

CountDownLatch是一个同步工具类，它允许一个或多个线程一直等待，直到其他线程的操作执行完后再执行。例如，应用程序的主线程希望在负责启动框架服务的线程已经启动所有的框架服务之后再执行。

CountDownLatch是什么

CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量。每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。

CountDownLatch如何工作

CountDownLatch.java类中定义的构造函数：

//Constructs a CountDownLatch initialized with the given count.
public void CountDownLatch(int count) {...}

构造器中的计数值（count）实际上就是闭锁需要等待的线程数量。这个值只能被设置一次，而且CountDownLatch没有提供任何机制去重新设置这个计数值。

与CountDownLatch的第一次交互是主线程等待其他线程。主线程必须在启动其他线程后立即调用CountDownLatch.await()方法。这样主线程的操作就会在这个方法上阻塞，直到其他线程完成各自的任务。

其他N个线程必须引用闭锁对象，因为他们需要通知CountDownLatch对象，他们已经完成了各自的任务。这种通知机制是通过CountDownLatch.countDown()方法来完成的；每调用一次这个方法，在构造函数中初始化的count值就减1。所以当N个线程都调用了这个方法，count的值等于0，然后主线程就能通过await()方法，恢复执行自己的任务。

见下面例子

public class ThreadPoolTest {
    public static void main(String[] args) {
        AtomicInteger total = new AtomicInteger(0);
        CountDownLatch latch = new CountDownLatch(1000);
        ThreadPoolExecutor executor = new ThreadPoolExecutor(10, 100, 10000, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
        Task task = new Task(total, latch);

        for (int i = 0; i < 1000; i++) {
            executor.execute(task); 
        }

        try {
            latch.await(); //主线程进入wait状态。
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(total.get());
    }
}

class Task implements Runnable {
    AtomicInteger cnt;
    CountDownLatch latch;

    public Task(AtomicInteger cnt, CountDownLatch latch) {
        this.cnt = cnt;
        this.latch = latch;
    }

    @Override
    public void run() {
        cnt.incrementAndGet();
        latch.countDown();
    }
}

上面的例子定义了一个AtomicInteger变量，并在一个Task里把它自增1，并把这个任务循环提交到线程池1000次，也就是这个任务要被线程池中的线程执行1000次，当然，这并不表示线程池中要有1000个线程，事实上，上面代码我们定义了线程池中最多只能有000个线程，而且只有线程池中线程数少于10个时并且有新的任务添加进来时才创建新的线程。

然后，我们再来关注 ThreadPoolExecutor 的创建

   /**
     * Creates a new {@code ThreadPoolExecutor} with the given initial
     * parameters.
     *
     * @param corePoolSize the number of threads to keep in the pool, even
     *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
     * @param maximumPoolSize the maximum number of threads to allow in the
     *        pool
     * @param keepAliveTime when the number of threads is greater than
     *        the core, this is the maximum time that excess idle threads
     *        will wait for new tasks before terminating.
     * @param unit the time unit for the {@code keepAliveTime} argument
     * @param workQueue the queue to use for holding tasks before they are
     *        executed.  This queue will hold only the {@code Runnable}
     *        tasks submitted by the {@code execute} method.
     * @param threadFactory the factory to use when the executor
     *        creates a new thread
     * @param handler the handler to use when execution is blocked
     *        because the thread bounds and queue capacities are reached
     * @throws IllegalArgumentException if one of the following holds:<br>
     *         {@code corePoolSize < 0}<br>
     *         {@code keepAliveTime < 0}<br>
     *         {@code maximumPoolSize <= 0}<br>
     *         {@code maximumPoolSize < corePoolSize}
     * @throws NullPointerException if {@code workQueue}
     *         or {@code threadFactory} or {@code handler} is null
     */
    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

corePoolSize，线程池的基本大小，当提交一个任务到线程池时，线程池就会创建一个新的线程来执行任务，即使线程池中还有其他 idle 线程。直到线程池中的线程数达到了corePoolSize，就会优先使用 idle 线程。
maximumPoolSize，线程池中允许创建的最大线程数。如果线程数达到了这个数目，即使有更多的任务在排除等待被执行，线程池也不会再去创建新的线程了。
keepAliveTime，如果线程数比corePoolSize多，并且有线程是idle的，这些线程不会立即销毁，而是会等待keepAliveTime这么长时间以后才销毁。
unit，是keepAliveTime的单位。可以是天，小时，分钟，豪秒，微秒和纳秒。我们上面的例子，就是使用了秒。
workQueue，任务的排队队列。当线程池中running状态的线程已经达到线程池中的maximumPoolSize设定的值时，如果又有新的任务添加进来，则任务进入workQueue。

这里有个问题，workQueue容量也是有限的，如果workQueue中等待任务也满了，此时还有任务加入进来怎么办?

事实上，只要你多运行几次上面的代码，就有几率抛出java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution异常。而如果你改动代码，尝试让Task的run方法运行时间长一点或者将添加任务循环的次数从1000改为10000或者更高，那么几乎每次都会抛出异常。

下面的代码不能正常运行。

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;


public class ThreadPoolTest {

    public static void main(String[] args){
        AtomicInteger start = new AtomicInteger(0);
        CountDownLatch countDownLatch = new CountDownLatch(1000);
        ThreadPoolExecutor executorService = new ThreadPoolExecutor(10, 100, 1000, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));

        //ExecutorService executorService = Executors.newSingleThreadExecutor();
        class Task implements Runnable{

            private AtomicInteger index;
            private CountDownLatch count;

            public Task(AtomicInteger index,CountDownLatch count){
                this.index = index;
                this.count = count;
            }


            @Override
            public void run() {
                index.incrementAndGet();
                count.countDown();
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }

        }
        Task task = new Task(start,countDownLatch);
        for(int i=0;i<1000;i++){
            executorService.execute(task);
        }
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("main thread end with:"+start.get());
        executorService.shutdown();

    }


}

定义拒绝任务

拒绝任务是指当线程池里面的线程数量达到 maximumPoolSize 且 workQueue 队列已满的情况下被尝试添加进来的任务。

当出现拒绝任务时，由ThreadPoolExecutor参数中的handler来处理。

在 ThreadPoolExecutor 里面定义了 4 种 handler 策略，分别是
1. CallerRunsPolicy ：这个策略重试添加当前的任务，他会自动重复调用 execute() 方法，直到成功。
2. AbortPolicy ：对拒绝任务抛弃处理，并且抛出异常。也是默认的handler。
3. DiscardPolicy ：对拒绝任务直接无声抛弃，没有异常信息。
4. DiscardOldestPolicy ：对拒绝任务不抛弃，而是抛弃队列里面等待最久的一个线程，然后把拒绝任务加到队列。

所以上面问题的解决方法可以是在ThreadPoolExecutor构造方法中使用callerRunsPolicy的handler，也可以简单粗暴的增加线程池的容量，使容量大于要添加到线程池任务数，那么也就永远都不会出现拒绝任务。

同时根据源码也可以看出， Executors 类里面有 newFixedThreadPool(),newCachedThreadPool() 等几个方法，实际上也是间接调用了 ThreadPoolExocutor ，不过是传的不同的构造参数。
例如

    public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }