个人中心
gpt4 book ai didi

Java线程池使用与原理详解

转载 作者：qq735679552 更新时间：2022-09-28 22:32:09 26 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章Java线程池使用与原理详解由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

线程池是什么?

我们可以利用java很容易创建一个新线程，同时操作系统创建一个线程也是一笔不小的开销。所以基于线程的复用，就提出了线程池的概念，我们使用线程池创建出若干个线程，执行完一个任务后，该线程会存在一段时间（用户可以设定空闲线程的存活时间，后面会介绍），等到新任务来的时候就直接复用这个空闲线程，这样就省去了创建、销毁线程损耗。当然空闲线程也会是一种资源的浪费（所有才有空闲线程存活时间的限制），但总比频繁的创建销毁线程好太多。 下面是我的测试代码 。

  。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
/*
  * @TODO 线程池测试
  */
@Test
public void threadPool(){
 
   /*java提供的统计线程运行数，一开始设置其值为50000，每一个线程任务执行完
    * 调用CountDownLatch#coutDown()方法（其实就是自减1）
    * 当所有的线程都执行完其值就为0
   */
   CountDownLatch count = new CountDownLatch(50000);
   long start = System.currentTimeMillis();
   Executor pool = Executors.newFixedThreadPool(10);//开启线程池最多会创建10个线程
   for(int i=0;i<50000;i++){
     pool.execute(new Runnable() {
       @Override
       public void run() {
         System.out.println("hello");
         count.countDown();
       }
     });
   }
 
   while(count.getCount()!=0){//堵塞等待5w个线程运行完毕
 
   }
   long end = System.currentTimeMillis();
   System.out.println("50个线程都执行完了,共用时:"+(end-start)+"ms");
}
 
 
/**
  *@TODO 手动创建线程测试
  */
@Test
public void thread(){
   CountDownLatch count = new CountDownLatch( 50000 );
   long start = System.currentTimeMillis();
   for ( int i= 0 ;i< 50000 ;i++){
     Thread thread = new Thread( new Runnable() {
 
       @Override
       public void run() {
         System.out.println( "hello" );
         count.countDown();
       }
     });
     thread.start();
   }
 
   while (count.getCount()!= 0 ){ //堵塞等待5w个线程运行完毕
 
   }
   long end = System.currentTimeMillis();
   System.out.println( "50000个线程都执行完了,共用时:" +(end-start)+ "ms" );
 
 
}

使用线程池5w线程运行完大约为400ms，不使用线程池运行大约为4350ms左右，其效率可见一斑（读者可以自行测试，不过由于电脑配置不一样，跑出来的数据会有差别，但使用线程池绝对是比创建线程要快的）.

java如何使用线程池？

上面的测试代码中已经使用了线程池，下面正式介绍一下.

java所有的线程池最顶层是一个Executor接口，其只有一个execute方法，用于执行所有的任务，java又提供了ExecutorService接口继承自Executor并且扩充了一下方法，在往下就是AbstractExecutorService这个抽象类，其实现了ExecutorService,最后就是ThreadPoolExecutor其继承自上面的抽象类，我们常使用的java线程池就是创建的这个类的实例.

而上面我们使用Executors是一个工具类，它就是一个语法糖，为我们把各种不同的业务的线程池参数进行封装，进行new操作.

?
1
2
3
4
5
public static ExecutorService newFixedThreadPool( int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
                   0L, TimeUnit.MILLISECONDS,
                   new LinkedBlockingQueue<Runnable>());
  }

上面就是Executors.newFixedThreadPool(10)的源码.

下面重点来了，说一说ThreadPoolExecutor构造方法各参数的意思.

?
1
2
3
4
5
6
7
public ThreadPoolExecutor( int corePoolSize,
               int maximumPoolSize,
               long keepAliveTime,
               TimeUnit unit,
               BlockingQueue<Runnable> workQueue,
               ThreadFactory threadFactory,
               RejectedExecutionHandler handler)

上面这个构造方法是最全的.

下面我们根据源码来解释部分参数意思，这样更有说服力.

下面是ThreadPoolExecutor#execute方法，就是我们上面接口调用的execute实际执行者.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public void execute(Runnable command) {
    if (command == null )
      throw new NullPointerException();
 
    int c = ctl.get();
    if (workerCountOf(c) < corePoolSize) {
      if (addWorker(command, true ))
        return ;
      c = ctl.get();
    }
    if (isRunning(c) && workQueue.offer(command)) {
      int recheck = ctl.get();
      if (! isRunning(recheck) && remove(command))
        reject(command);
      else if (workerCountOf(recheck) == 0 )
        addWorker( null , false );
    }
    else if (!addWorker(command, false ))
      reject(command);
  }

ctl是一个AtomicInteger实例，是一个提供了原子语句的CAS操作的类，它用来记录线程池中当前运行的线程数量加上-2^29，workCountOf方法就取得其绝对值（可以去看源码如何实现），当其小于corePoolSize时，会调用addWorker方法（是用来创建一个新Workder，Workder会创建一个Thread，所以就是创建线程的方法），addWorkd创建线程过程中会跟corePoolSize或者maxnumPoolSize的值比较（当传入true会根corePoolSize比较，false会根据maxnumPoolSize比较，大于等于其值会创建失败）。可见如何当前运行中的线程数量小于corePoolSize就是创建并且也会创建成功( 只简单的讨论线程池Running状态下).

如果当运行中线程数大于等于corePoolSize时，进入第二个if，isRunning是跟SHUTDOWN（其值=0）比较，之前说过c等于当前运行的线程数量加上-2^29，如果当前当前运行的线程数据达到2^29时其值就=0，isRunning返回false，else中在执行addWorkd也会返回false(addWorkd也对其进行了检验)，所以这表示线程池最多能支持2^29个线程同时运行（足够用了）.

workQueue.offer(command)就是将runnable加入等待队列，加入等待队列后runWorker方法会从队列中获取任务执行的。如果当前队列采用的是有界队列（ArrayBlockingQueue）当队列满了offer就会返回false，这是就进入else if，看!这里传入了false，说明这里要跟maxnumPoolSize比较了，如果这里运行的线程数大于等于maxnumPoolSize，那么这个线程任务就要被线程池拒绝了，执行reject(command),拒绝方法中使用了我们ThreadPoolExecutor构造方法中的RejectedExecutionHandler（拒绝策略），后面再详细解释.

经过上面的结合源码的介绍，下面对们ThreadPoolExecutor的参数介绍就好理解了.

线程池中线程创建和拒绝策略 。

corePoolSize，maxnumPoolSize,BlockingQueue这三个要一块说 。

当线程池运行的线程小于corePoolSize时，来一个新线程任务总是会新建一个线程来执行；当大于corePoolSize就会把任务加入到等待队列blockingQueue中，如果你传入的BlockingQueue是一个无界队列（LinkedBlockingQueue）这是队列可以存放“无穷多”的任务，所有总是会加入队列成功，跟maxnumPoolSize就没关系了，这也表示线程池中线程数最多为corePoolSize个；但是如果你传入的是有界队列（ArrayBlockingQueue,SynchronousQueue），当队列满时，并且线程数小于maxmunPoolSize就是创建新的线程直至线程数大于maxnumPoolSize;如果当线程数量大于maxnumPoolSize时，在加入任务就会被线程池拒绝.

RejectedExecutionHandler拒绝策略java给实现了4个AbortPolicy，CallerRunsPolicy，DiscardOldestPolicy，DiscardPolicy用户也可以自己实现该接口实现自己的拒绝策略；第一个就是直接抛出异常，我们可以进行trycatch处理；第二个就是该新任务直接运行；第三个是取消队列中最老的；第四个是取消当前任务.

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我.

原文链接：http://blog.csdn.net/u013592964/article/details/78082243 。

最后此篇关于Java线程池使用与原理详解的文章就讲到这里了,如果你想了解更多关于Java线程池使用与原理详解的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

26 4 0
文章推荐： 神角技巧风雪王国隐藏宝箱在哪 风雪王国隐藏宝箱位置大全
文章推荐： numpy中矩阵合并的实例
文章推荐： 神角技巧村庄隐藏宝箱在哪 村庄隐藏宝箱位置介绍
文章推荐： 对numpy中shape的深入理解
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com