Java并发-线程池

最新推荐文章于 2024-07-17 17:49:38 发布
最新推荐文章于 2024-07-17 17:49:38 发布
阅读量394 收藏
点赞数
分类专栏： 并发 Java基础 文章标签： java 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32760973/article/details/108758121
版权

Java线程池

线程池的作用

管理线程，防止线程频繁的创建或销毁带来的性能消耗

##核心类 ThreadPoolExecutor

源码分析（实现原理）

成员变量

	//控制线程池状态，前3位是状态，后29位是RUNNING状态的线程数
    private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
	//29
    private static final int COUNT_BITS = Integer.SIZE - 3;
    //容量
    private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

    /** 常量，运行状态
    SHUTDOWN = 0
    RUNNING < 0
    STOP、TIDYING、TERMINATED > 0
    */
    private static final int RUNNING    = -1 << COUNT_BITS;
    private static final int SHUTDOWN   =  0 << COUNT_BITS;
    private static final int STOP       =  1 << COUNT_BITS;
    private static final int TIDYING    =  2 << COUNT_BITS;
    private static final int TERMINATED =  3 << COUNT_BITS;

    // Packing and unpacking ctl
    private static int runStateOf(int c)     { return c & ~CAPACITY; }
    private static int workerCountOf(int c)  { return c & CAPACITY; }
    private static int ctlOf(int rs, int wc) { return rs | wc; }

    private static boolean runStateLessThan(int c, int s) {
        return c < s;
    }

    private static boolean runStateAtLeast(int c, int s) {
        return c >= s;
    }

    private static boolean isRunning(int c) {
        return c < SHUTDOWN;
    }
    
    private boolean compareAndIncrementWorkerCount(int expect) {
        return ctl.compareAndSet(expect, expect + 1);
    }

    private boolean compareAndDecrementWorkerCount(int expect) {
        return ctl.compareAndSet(expect, expect - 1);
    }

    private void decrementWorkerCount() {
        do {} while (! compareAndDecrementWorkerCount(ctl.get()));
    }
    
    //阻塞队列
    private final BlockingQueue<Runnable> workQueue;

	//锁
    private final ReentrantLock mainLock = new ReentrantLock();

	//存放worker
    private final HashSet<Worker> workers = new HashSet<Worker>();

    private final Condition termination = mainLock.newCondition();

    private int largestPoolSize;

    private long completedTaskCount;

    private volatile ThreadFactory threadFactory;

    private volatile RejectedExecutionHandler handler;

    private volatile long keepAliveTime;

    private volatile boolean allowCoreThreadTimeOut;

    private volatile int corePoolSize;

    private volatile int maximumPoolSize;

	//拒绝策略
    private static final RejectedExecutionHandler defaultHandler =
        new AbortPolicy();

    private static final RuntimePermission shutdownPerm =
        new RuntimePermission("modifyThread");

线程池状态

RUNNING：运行态，新建ThreadPoolExecutor实例后线程池就是此状态，可以添加新的任务，也可以对阻塞队列中的任务进行处理。

SHOWDOWN：关闭态，当调用showdown()方法后，线程池进入关闭态，不能接受新的任务，但是可以对阻塞队列中的任务进行处理。

STOP：停止态，调用shutdownNow()方法后，线程池进入停止状态，不能接受新任务，不能对阻塞队列中的任务进行处理。

TIDYING：整理态，所有任务已经终止，ctl的任务数量为0时，线程池进入整理态，会执行函数terminated()函数，如果用户想在TIDYING状态进行处理，可以重载terminated()函数来实现。

TERMINATED：终止态，线程池彻底终止，生命周期结束。

构造方法

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
    }
    
	public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             threadFactory, defaultHandler);
    }


    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler) {
        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), handler);
    }

    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 核心线程数

maximumPoolSize 最大线程数

keepAliveTime 线程没有执行任务时存活时间

unit 单位

workQueue 阻塞队列，对应排队策略，有以下三种选择
ArrayBlockingQueue;
LinkedBlockingQueue;
SynchronousQueue;

threadFactory 线程工厂

拒绝策略

handler 拒绝任务的策略，有以下选择
ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常，默认handler。

ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。

ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）

ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

execute()方法源码分析

    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();
            //recheck下线程池状态，如果非运行，移除刚添加的线程，执行拒绝策略
            if (! isRunning(recheck) && remove(command))
                reject(command);
            //如果线程池运行，创建worker执行任务（考虑到线程可能挂掉）
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        //直接创建Worker来执行任务
        else if (!addWorker(command, false))
            reject(command);
    }

private boolean addWorker(Runnable firstTask, boolean core) {
        retry:
        //使用自旋+cas失败重试来保证线程竞争问题
        for (;;) {
            //先获取线程池的状态
            int c = ctl.get();
            int rs = runStateOf(c);

            // 如果线程池是关闭的,或者workQueue队列为空,就直接返回false,不做任何处理
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;

            for (;;) {
                int wc = workerCountOf(c);
                //根据入参core 来判断可以创建的worker数量是否达到上限,如果达到上限了就拒绝创建worker
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
                //没有的话就尝试修改ctl添加workerCount的值。这里用了cas操作,如果失败了下一个循环会继续重试,直到设置成功
                if (compareAndIncrementWorkerCount(c))
                    //如果设置成功了就跳出外层的那个for循环
                    break retry;
                //重读一次ctl,判断如果线程池的状态改变了,会再重新循环一次
                c = ctl.get();  // Re-read ctl
                if (runStateOf(c) != rs)
                    continue retry;
            }
        }

        boolean workerStarted = false;
        boolean workerAdded = false;
        Worker w = null;
        try {
            final ReentrantLock mainLock = this.mainLock;
            //创建一个worker,将提交上来的任务直接交给worker
            w = new Worker(firstTask);
            final Thread t = w.thread;
            if (t != null) {
                //加锁,防止竞争
                mainLock.lock();
                try {
                    int c = ctl.get();
                    int rs = runStateOf(c);
                    //还是判断线程池的状态
                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        //如果worker的线程已经启动了,会抛出异常
                        if (t.isAlive()) 
                              throw new IllegalThreadStateException();
                        //添加新建的worker到线程池中
                        workers.add(w);
                        int s = workers.size();
                        //更新历史worker数量的最大值
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                        //设置新增标志位
                        workerAdded = true;
                    }
                } finally {
                    mainLock.unlock();
                }
                //如果worker是新增的,就启动该线程
                if (workerAdded) {
                    t.start();
                     //成功启动了线程,设置对应的标志位
                    workerStarted = true;
                }
            }
        } finally {
            //如果启动失败了,会触发执行相应的方法
            if (! workerStarted)
                addWorkerFailed(w);
        }
        return workerStarted;
}

Executors提供的线程池及Demo

newFixedThreadPool()

	public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>(),
                                      threadFactory);
    }

使用

package concurrent;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolUsage {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 10; i++) {
            final int ii = i;
            pool.execute(() -> {
                System.out.println(Thread.currentThread().getName() + " " + ii);
            });
        }
    }
}

pool-1-thread-1 0
pool-1-thread-3 2
pool-1-thread-2 1
pool-1-thread-1 3
pool-1-thread-3 4
pool-1-thread-1 6
pool-1-thread-2 5
pool-1-thread-1 8
pool-1-thread-3 7
pool-1-thread-2 9

三个线程完成10个任务

newSingleThreadExecutor()

	public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }

使用

package concurrent;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ThreadPoolUsage {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int ii = i;
            pool.execute(() -> {
                System.out.println(Thread.currentThread().getName() + " " + ii);
            });
        }

    }
}

pool-1-thread-1 0
pool-1-thread-1 1
pool-1-thread-1 2
pool-1-thread-1 3
pool-1-thread-1 4
pool-1-thread-1 5
pool-1-thread-1 6
pool-1-thread-1 7
pool-1-thread-1 8
pool-1-thread-1 9

newCachedThreadPool()

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

使用

package concurrent;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ThreadPoolUsage {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            final int ii = i;
            pool.execute(() -> {
                System.out.println(Thread.currentThread().getName() + " " + ii);
            });
        }
    }
}

pool-1-thread-2 1
pool-1-thread-1 0
pool-1-thread-3 2
pool-1-thread-4 3
pool-1-thread-3 8
pool-1-thread-1 7
pool-1-thread-2 9
pool-1-thread-5 4
pool-1-thread-6 5
pool-1-thread-7 6

可以看出，线程池创建了7个线程来执行这10个任务

newScheduledThreadPool()

	public static ScheduledExecutorService newScheduledThreadPool(
            int corePoolSize, ThreadFactory threadFactory) {
        return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
    }

使用

package concurrent;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ThreadPoolUsage {
    public static void main(String[] args) {
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(5);
        pool.schedule(() -> {
            System.out.println("延时任务，延时2s");
        },2, TimeUnit.SECONDS);
        pool.scheduleAtFixedRate(() -> {
            System.out.println("延时任务，每两秒执行一次");
        }, 1, 2, TimeUnit.SECONDS);
        pool.execute(() -> {
            System.out.println("普通任务");
        });

    }
}

普通任务
延时任务，每两秒执行一次
延时任务，延时2s
延时任务，每两秒执行一次
...

除了jdk实现好的线程池，我们也可以根据需要自己创建线程池。另外，有些公司的规范不允许使用以上4种线程池。

Created by lcy on 2020-09-24
Update on 10-09

lcyyyyy_
关注
专栏目录
Java 并发
风雪夜不眠人的博客
07-25 201
1简介 要想充分发挥处理器系统的强大计算能力，最简单的方式就是使用线程。 使用进程的原因：资源利用率；公平性；便利性 不同的程序在单独的进程中运行 线程允许在同一个进程中存在多个程序控制流，线程会共享进程范围内的资源。但每个线程都有各自的程序计数器、栈以及局部变量 线程也被称为轻量级进程，大多数的操作系统都是以进程为基本的调度单位。 线程可以有效地降低程序的开发和维护等成本，同时提升复杂应用程序的性能 ...
Java并发-线程池API
幸遇三杯酒好，况逢一朵花新
11-09 389
  今天小咸儿继续来分享对线程池的认知，这里介绍的是四种线程池： newFixedThreadPool：该方法返回一个固定数量的线程池，线程数不变，当有一个任务提交时，若线程池中空闲，则立即执行，若没有，则会被暂缓在一个任务队列中，等待有空闲的线程去执行。 newSingleThreadExecutor：创建一个线程的线程池，若空闲则执行，若没有空闲线程则暂缓在任务队列中。 newCachedT...
Java 并发从入门到精通
热门推荐
Umbrella Corporation
10-12 1万+
一、线程状态转换 新建（New） 可运行（Runnable） 阻塞（Blocking） 无限期等待（Waiting） 限期等待（Timed Waiting） 死亡（Terminated） 二、使用线程 实现 Runnable 接口 实现 Callable 接口 继承 Thread 类 实现接口 VS 继承 Thread 三、基础线程机制 Executor Daemon sleep...
java并发编程和多线程总结
最新发布
卓越之识论道，平常之识论事，狭隘之识论人
07-17 1493
java并发编程和多线程总结
java并发
lhhhwudi的博客
05-18 338
一.java语言特性 1、跨平台/可移植性 这是Java的核心优势。Java在设计时就很注重移植和跨平台性。比如：Java的int永远都是32位。不像C++可能是16，32，可能是根据编译器厂商规定的变化。这样的话程序的移植就会非常麻烦。 2、安全性 Java适合于网络/分布式环境，为了达到这个目标，在安全性方面投入了很大的精力，使Java可以很容易构建防病毒，防篡改的系统。 3、面向对象 面向对象是一种程序设计技术，非常适合大型软件的设计和开发。由于C++为了照顾大量C语言使用者而兼容了C，使
Java并发
windyjcy的博客
07-14 199
Java并发 牛客的课 基础 栈是线程私有的，有多少线程就有多少栈 这个意思就是说，操作系统执行指令是原子的，但是高级语言中的指令不一定是原子的，例如n++这个指令，在操作系统中会被拆成多条指令执行 如果不加锁的话，两个结果可能都是1，所以n++不是原子的 两个线程同步对变量X进行更改，因为一个线程更改以后另一个不会立刻看到，会造成可见性问题 CPU操作系统的机制会对程序的运行顺序进行重排，原则是保证单线程的正常运行，但是如这个例子，正常是先创建单例对象再赋值，但是这里CPU调整成先赋值，再创
JAVA并发编程实践-线程池-学习笔记
07-22
Java并发编程实践中的线程池是一个关键的概念，它在多线程编程中扮演着至关重要的角色，有效地管理和调度线程资源，以提高系统的性能和效率。线程池通过复用已存在的线程来减少线程的创建和销毁开销，避免了频繁的上...
并发－线程池和阻塞队列
10-18
在Java编程中，"并发-线程池和...总之，理解和掌握线程池与阻塞队列的原理和使用方法，是提升Java并发编程能力的重要一步。它们为开发人员提供了一种强大而灵活的工具，能够在处理并发问题时保证系统的稳定性和性能。
并发－线程池和阻塞队列.pdf
10-17
线程池和阻塞队列是实现并发的关键组件之一。本文将详细介绍线程池原理、使用场景及注意事项，以及阻塞队列的相关知识。 首先，线程池是一种基于池化思想管理线程的技术，它可以重用一组线程执行多个任务。线程池的...
Java学习----线程池
hanxuya的博客
09-09 1252
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收重用时则新建线程。}工作线程的创建数量几乎没有限制(其实也有限制的,数目为Interger.MAX_VALUE), 这样可灵活的往线程池中添加线程。如果长时间没有往线程池中提交任务，即如果工作线程空闲了指定的时间(默认为1分钟)，则该工作线程将自动终止。终止后，如果你又提交了新的任务，则线程池重新创建一个工作线程。
《JAVA并发编程实践-线程池高级选项及任务执行框架注意事项学习笔记》
本文是关于《JAVA并发编程实践-线程池-学习笔记》中配置和调整线程池时使用的高级选项的总结，重点讲述了在任务执行框架的过程中需要注意的危险。其中包括线程复用原理、线程池的实现原理以及线程池的组成等内容。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值