Java_11_ThreadPoolExecutor_线程池核心参数_源码解析

最新推荐文章于 2024-09-28 21:07:14 发布
最新推荐文章于 2024-09-28 21:07:14 发布
阅读量158 收藏
点赞数
分类专栏： Java 文章标签： java 开发语言 jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/LXL2790/article/details/128667156
版权

Java构建线程的方式

Java中创建线程的方式：

  1. 继承Thread类并重写run方法，实现简单但不可以继承其他。
  2. 实现Runnable接口并重写run方法。避免了单继承局限性，编程更加灵活，实现解耦。
  3. 实现Callable接口并重写call方法。可以获取线程执行结果的返回值，并且可以抛出异常。
  4. 使用线程池创建（使用java.util.concurrent.Executor接口）。

非线程池创建线程

class ThreadOne extends Thread {
    @Override
    public void run() {
        System.out.println("Thread-One is Running");
    }
}

class ThreadTwo implements Runnable{
    @Override
    public void run() {
        System.out.println("Thread-Two is Running");
    }
}

class ThreadThree implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("Thread-Three is Running");
        return 100;
    }
}

public class ThreadCreateTest{
    public static void main(String[] args){
        ThreadOne threadOne = new ThreadOne();
        threadOne.start();

        ThreadTwo threadTwo = new ThreadTwo();
        Thread thread2 = new Thread(threadTwo);
        thread2.start();

        ThreadThree threadThree = new ThreadThree();
        FutureTask<Integer> integerFutureTask = new FutureTask<Integer>(threadThree);
        Thread thread3 = new Thread(integerFutureTask);
        thread3.start();
        Integer integer = integerFutureTask.get();
        System.out.println("Thread-Three's result is " + integer);
    }
}

Executors工具类

概述：线程池方式其实和上面没有区别，只不过上面需要频繁的创建和销毁线程，会造成一些不必要的额外资源消耗，所以在实际开发中肯定会采用线程池的方式，Java中的Executors自带了一些创建线程池的方式。

在这里插入图片描述

在构建好线程池ThreadPoolExecutor后就可以直接调用execute、submit方法执行线程任务：

  • execute适用于Runnable没有返回结果。
  • submit更适合Callable具有返回结果。

常见线程池类：

  1. newCachedThreadPool：创建一个可进行缓存重复利用的线程池。

  2. newFixedThreadPool：创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程，线程池中的线程处于一定的量，可以很好的控制线程的并发量。

  3. newSingleThreadExecutor：创建一个使用单个worker线程的Executor，以无界队列方式来运行该线程。线程池中最多执行一个线程，之后提交的线程将会排在队列中以此执行。

  4. newSingleThreadScheduledExecutor：创建一个单线程执行程序，它可安排在给定延迟后运行命令或者定期执行。

  5. newScheduledThreadPool：创建一个线程池，它可安排在给定延迟后运行命令或者定期的执行。

  6. newWorkStealingPool：创建一个带并行级别的线程池，并行级别决定了同一时刻最多有多少个线程在执行，如不传并行级别参数，将默认为当前系统的CPU核心数*2。

线程池自定义参数

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

  1. corePoolSize线程池核心线程大小。线程池中会维护一个最小的线程数量，即使这些线程处理空闲状态，他们也不会被销毁，除非设置了allowCoreThreadTimeOut。这里的最小线程数量即是corePoolSize。

  2. maximumPoolSize线程池最大线程数量。一个任务被提交到线程池以后，首先会找有没有空闲存活线程，如果有则直接将任务交给这个空闲线程来执行，如果没有则会缓存到工作队列中，如果工作队列满了，才会创建一个新线程，然后从工作队列的头部取出一个任务交由新线程来处理，而将刚提交的任务放入工作队列尾部。线程池不会无限制的去创建新线程，它会有一个最大线程数量的限制，这个数量即由maximunPoolSize指定。

  3. keepAliveTime空闲线程存活时间。一个线程如果处于空闲状态，并且当前的线程数量大于corePoolSize，那么在指定时间后，这个空闲线程会被销毁，这里的指定时间由keepAliveTime来设定。

  4. unit空闲线程存活时间单位，keepAliveTime的计量单位。

  5. workQueue工作队列。新任务被提交后，会先进入到此工作队列中，任务调度时再从队列中取出任务。jdk中提供了四种工作队列：

    • ArrayBlockingQueue基于数组的有界阻塞队列，按FIFO排序。新任务进来后，会放到该队列的队尾，有界的数组可以防止资源耗尽问题。当线程池中线程数量达到corePoolSize后，再有新任务进来，则会将任务放入该队列的队尾，等待被调度。如果队列已经是满的，则创建一个新线程，如果线程数量已经达到maxPoolSize，则会执行拒绝策略。
    • LinkedBlockingQueue基于链表的无界阻塞队列（其实最大容量为Interger.MAX），按照FIFO排序。由于该队列的近似无界性，当线程池中线程数量达到corePoolSize后，再有新任务进来，会一直存入该队列，而不会去创建新线程直到maxPoolSize，因此使用该工作队列时，参数maxPoolSize其实是不起作用的。
    • SynchronousQueue一个不缓存任务的阻塞队列，生产者放入一个任务必须等到消费者取出这个任务。也就是说新任务进来时，不会缓存，而是直接被调度执行该任务，如果没有可用线程，则创建新线程，如果线程数量达到maxPoolSize，则执行拒绝策略。
    • PriorityBlockingQueue具有优先级的无界阻塞队列，优先级通过参数Comparator实现。

  6. threadFactory线程工厂。创建一个新线程时使用的工厂，可以用来设定线程名、是否为daemon线程等等。

  7. handler拒绝策略。当工作队列中的任务已到达最大限制，并且线程池中的线程数量也达到最大限制，这时如果有新任务提交进来，该如何处理呢。这里的拒绝策略就是解决这个问题的，jdk中提供了4中拒绝策略：

    在这里插入图片描述

线程池的执行流程

在这里插入图片描述

线程池状态

在这里插入图片描述

ThreadPoolExecutor源码

类主要成员
public class ThreadPoolExecutor extends AbstractExecutorService {
	// ctl初始化了线程的状态和线程数量，初始状态为RUNNING并且线程数量为0
	// Integer既包含了状态也包含了数量，其中int类型一共32位，高3位标识状态，低29位标识数量
	private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
    
	// 这里指定了Integer.SIZE - 3，也就是32 - 3 = 29，表示线程数量最大取值长度
	private static final int COUNT_BITS = Integer.SIZE - 3;
    
	// 这里标识线程池容量，也就是将1向左位移上面的29长度
    // 并且 减去1 代表最大取值，二进制就是 000111..111
	private static final int CAPACITY = (1 << COUNT_BITS) - 1;
    
	// 这里是高三位的状态表示
	private static final int RUNNING = -1 << COUNT_BITS;   // 111
	private static final int SHUTDOWN = 0 << COUNT_BITS;   // 000
	private static final int STOP = 1 << COUNT_BITS; 	   // 001
	private static final int TIDYING = 2 << COUNT_BITS;    // 010
	private static final int TERMINATED = 3 << COUNT_BITS; // 011
    
	// 获取线程数量、状态等方式
	// 通过传入的c，获取最高三位的值，拿到线程状态吗
    // 最终就是拿1110 000……和c做&运算得到高3位结果
	private static int runStateOf(int c) { return c & ~CAPACITY; }
	// 获取当前线程数量，最终得到现在线程数量，就是拿c 和 0001 111……做&运算，得到低29位结果
	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; }
	// 判断当前线程池状态是否是Running。
	private static boolean isRunning(int c) { return c < SHUTDOWN; }
}
线程池的execute方法执行
public void execute(Runnable command) {
	// 首先是健壮性判断
	if (command == null)
		throw new NullPointerException();
    
	// 这里是获取核心线程数
	int c = ctl.get();
    
	// 判断工作线程是否少于核心线程数
	if (workerCountOf(c) < corePoolSize) {
		// 如果少于，需要创建新的任务线程
        // 如果addWorker返回false，证明核心线程初始化过了，返回true就直接结束
		if (addWorker(command, true))
			return;
		c = ctl.get();
	}
    
	// 如果线程池属于RUNNING状态，那就添加到任务队列，如果添加成功，进入
	if (isRunning(c) && workQueue.offer(command)) {
		// 重新获取ctl属性
		int recheck = ctl.get();
		// 再次判断是否是RUNNING状态，如果不是了，就执行remove删掉添加到阻塞队列的任务
		if (!isRunning(recheck) && remove(command))
			// 拒绝任务
			reject(command);
		// 如果线程数为0
		else if (workerCountOf(recheck) == 0)
			// 添加一个线程，避免出现队列任务没有线程执行的情况
			addWorker(null, false);
	}
    
	// 如果不能入队列，就尝试创建最大线程数
	else if (!addWorker(command, false))
		// 如果创建最大线程数失败，直接拒绝任务
		reject(command);
}
线程池的addWorker方法
private boolean addWorker(Runnable firstTask, boolean core) {
    // 判断是否可以添加线程
	retry:
	for (;;) {
		int c = ctl.get();
		int rs = runStateOf(c);
        
		// 查看是否可以不去构建新的工作线程.
		if (rs >= SHUTDOWN // 如果线程状态不是RUNNING
		&&
		!(rs == SHUTDOWN && firstTask == null && !workQueue.isEmpty()))
		// 线程不是SHUTDOWN状态（那也就是STOP，TIDYING，TERMINATED三者之一）
		// 任务不为空，且工作等待队列为null -> 这里对应上述的addWorker(null,false)
			return false;	// 这时直接return false，不去构建新的工作线程
		for (;;) {
			// 获取工作线程数
			int wc = workerCountOf(c);
			if (wc >= CAPACITY || // 如果工作线程大于最大线程容量
			wc >= (core ? corePoolSize : maximumPoolSize)) 
            // 或者当前线程数达到核心/最大线程数的要求
				return false; // 直接结束，添加Worker失败。
			if (compareAndIncrementWorkerCount(c)) // CAS的方式比较线程数量
				break retry; // 如果成功，跳出最外层循环
			c = ctl.get(); // 再次读取ctl的值
			if (runStateOf(c) != rs) 
            // 如果运行状态不等于最开始查询到的rs，那就从头循环一波。
				continue retry;
				// else CAS failed due to workerCount change; retry inner loop
		}
	}
    
	// 开始添加工作线程
	boolean workerStarted = false;
	boolean workerAdded = false;
	Worker w = null;
	try {
		w = new Worker(firstTask); // 构建Worker对象传入任务
		final Thread t = w.thread; // 将worker线程取出
		if (t != null) {
            // 拿到全局锁，避免我在添加任务时，其他线程干掉线程池，因为干掉线程池需要获取到这个锁
            final ReentrantLock mainLock = this.mainLock;
            // 加锁
            mainLock.lock();
        	try {
            	// 获取线程池状态
            	int rs = runStateOf(ctl.get());
            	// 两种情况允许添加工作线程
            	if (rs < SHUTDOWN || // 判断线程池是否是RUNNING状态
            		(rs == SHUTDOWN && firstTask == null)) { 
                    // 如果线程池状态为SHUTDOWN并且任务为空
                    
            		if (t.isAlive()) // 如果线程正在运行，直接抛出异常
            			throw new IllegalThreadStateException();
            		// 添加任务线程到workers中
            		workers.add(w);
            		// 获取任务线程个数
            		int s = workers.size();
            		// 如果任务线程大于记录的当前出现过的最大线程数，替换一下。
            		if (s > largestPoolSize)
            			largestPoolSize = s;
            		workerAdded = true; // 任务添加的标识设置为true
            	}
        	} finally {
        	    mainLock.unlock(); //任务添加成功，退出锁资源
        	}
			if (workerAdded) { // 如果添加成功
				t.start(); // 启动线程
				workerStarted = true; // 标识启动标识为true
			}
		}
	} finally {
		if (!workerStarted) // 如果线程启动失败
			addWorkerFailed(w); // 移除掉刚刚添加的任务
	}
	return workerStarted;
}
Worker内部包装类
private final class Worker extends AbstractQueuedSynchronizer implements Runnable{ 
// 实现了Runnable，意味着是一个线程
	// 线程对象
	final Thread thread;
	// 具体任务
	Runnable firstTask;
	// 有参构造
	Worker(Runnable firstTask) {
		setState(-1); // 添加标识，worker运行前，禁止中断（AQS）
		this.firstTask = firstTask;
		this.thread = getThreadFactory().newThread(this); 
        // 创建了一个新的线程，并且线程指向了当前对象，引入就是Worker
        // 所以在调用start方法时，调用的是Worker中的run方法
	}
        
	// run方法，线程的工作内容
	public void run() {
		runWorker(this); // 核心内容
	}
	// …… 省略部分代码
}
线程池的runWorker方法
final void runWorker(Worker w) {
	// 获取当前线程
	Thread wt = Thread.currentThread();
	// 拿到任务
	Runnable task = w.firstTask;
	w.firstTask = null;
	w.unlock(); // allow interrupts
	boolean completedAbruptly = true;
	try {
		// 任务不为null，就一致循环，否则调用getTask尝试从阻塞队列获取任务
		while (task != null || (task = getTask()) != null) {
		// 加锁的目的是表示当前任务正在执行，你shutdown任务也不会中断
			w.lock();
			if ((runStateAtLeast(ctl.get(), STOP) || // 判断线程池是否处于STOP状态
				(Thread.interrupted() && runStateAtLeast(ctl.get(), STOP)))
				&& !wt.isInterrupted() // 判断线程池是否中断
            )
				// 只要线程池STOP了，工作线程没有被中断，就中断线程
				wt.interrupt();
			try {
				// 任务执行的前置处理
				beforeExecute(wt, task);
				Throwable thrown = null;
				try {
					// 任务走起
					task.run();
				} catch (RuntimeException x) {
					thrown = x; throw x;
				} catch (Error x) {
					thrown = x; throw x;
				} catch (Throwable x) {
					thrown = x; throw new Error(x);
				} finally {
					// 任务执行的后置处理
					afterExecute(task, thrown);
				}
			} finally {
				task = null;
				w.completedTasks++;
				w.unlock();
			}
		}
		completedAbruptly = false;
	} finally {
		processWorkerExit(w, completedAbruptly);	
	}
}
线程池的getTask方法
private Runnable getTask() {
    boolean timedOut = false; // Did the last poll() time out?

    for (;;) {
        int c = ctl.get();
        int rs = runStateOf(c);

        // 如果状态大于0，代表线程池凉凉，
        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
            decrementWorkerCount(); // 如果是STOP状态，或者阻塞队列为空
            return null;
        }
		// 获取工作线程数
        int wc = workerCountOf(c);

        // 查看是否允许
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

        // 当前工作线程数大于最大线程数 ，后面判断表示是否是允许核心线程超时并且真的超时
        if ((wc > maximumPoolSize || (timed && timedOut))
            && (wc > 1 || workQueue.isEmpty())) {   //工作线程 > 1 或者 阻塞队列为空
            if (compareAndDecrementWorkerCount(c))
            // 干掉当前工作线程并返回null，CAS的方式，如果失败，重新从头走一遍
                return null;
            continue;
        }

        try {
            Runnable r = timed ?
                // 这里是可能出现超时情况并且允许回收线程，那就阻塞这么久拿阻塞队列的任务
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
            	// 这里是线程阻塞在这，等待任务，不参与回收的情况，直到触发signal方法被唤醒，走catch继续下次循环
                workQueue.take();
            if (r != null)
                return r;
            timedOut = true;
        } catch (InterruptedException retry) {
            timedOut = false;
        }
    }
}
线程池的processWorkerExit方法
private void processWorkerExit(Worker w, boolean completedAbruptly) {
    // 判断是否是认为停止，如果是要减掉一个工作线程数
    if (completedAbruptly) // If abrupt, then workerCount wasn't adjusted
        decrementWorkerCount();

    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    // 加锁移除工作线程
    try {
        // 记录当前线程处理的任务数
        completedTaskCount += w.completedTasks;
        // 将worker从Set中移除
        workers.remove(w);
    } finally {
        mainLock.unlock();
    }
	// 尝试干掉线程池
    tryTerminate();

    int c = ctl.get();
    // 判断线程状态是否小于STOP。
    if (runStateLessThan(c, STOP)) {
        // 如果不是认为停止，需要判断线程是否需要追加一个线程处理任务
        if (!completedAbruptly) {
            // 查看核心线程是否允许超时
            int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
            if (min == 0 && ! workQueue.isEmpty())
                // 如果允许超时，并且工作队列不是空，就将min设置为1
                min = 1;
            if (workerCountOf(c) >= min)// 如果工作线程数量大于核心线程数，就直接结束
                return; // replacement not needed
        }
        addWorker(null, false);
    }
}
Java从零开始学多线程——11.线程池及Executor框架 LinkedBlockingQueue ThreadPoolExecutor Future Callable FutureTask
JAVA求生之路——博主406766467
01-08 294
为什么要使用线程池？ 诸如 Web 服务器、数据库服务器、文件服务器或邮件服务器之类的许多服务器应用程序都面向处理来自某些远程来源的大量短小的任务。请求以某种方式到达服务器，这种方式可能是通过网络协议（例如 HTTP、FTP ）、通过 JMS队列或者可能通过轮询数据库。不管请求如何到达，服务器应用程序中经常出现的情况是：单个任务处理的时间很短而请求的数目却是巨大的。每当一个请求到达就创建一个新线程，然后在新线程中为请求服务，但是频繁的创建线程，销毁线程所带来的系统开销其实是非常大的。 线程池为线程生命周期开
JDK ThreadPoolExecutor核心原理与实践
mxy2404830的博客
12-18 572
一、内容概括 本文内容主要围绕JDK中的ThreadPoolExecutor展开，首先描述了ThreadPoolExecutor的构造流程以及内部状态管理的机理，随后用大量篇幅深入源码探究了ThreadPoolExecutor线程分配、任务处理、拒绝策略、启动停止等过程，其中对Worker内置类进行重点分析，内容不仅包含其工作原理，更对其设计思路进行了一定分析。文章内容既包含了源码流程分析，还具有设计思路探讨和二次开发实践。 二、构造ThreadPoolExecutor 2.1线程池参数列表 .
Java多线程技术11——ThreadPoolExecutor类的使用1
geminigoth的博客
01-07 1035
ThreadPoolExecutor类可以非常方便的创建线程池对象，而不需要程序员设计大量的new实例化Thread相关的代码。
JAVA多线程进阶篇 11、JUC线程池之ThreadPoolExecutor
EndlessProcess的专栏
03-14 3569
为了更好的对线程进行管理，实现线程的统一分配，调优和监控，降低资源消耗，JUC设计了线程池。Executors实现了多个静态方法来创建各种线程池，在正式工作中，我们应当实现自定义的ThreadPoolExecutor 。
面试官：ThreadPoolExecutor 都有哪些核心参数？
爱琴孩的博客
01-08 235
所以 Tomcat并没有使用 JUC 原生线程池，利用 TaskQueue 的 offer() 方法巧妙的修改了 JUC 线程池的执行流程，改写后 Tomcat 线程池执行流程如下。然后再说下线程池的 Worker 线程模型，继承 AQS 实现了锁机制。线程启动后执行 runWorker() 方法，runWorker() 方法中调用 getTask() 方法从阻塞队列中获取任务，获取到任务后先执行 beforeExecute() 钩子函数，再执行任务，然后再执行 afterExecute() 钩子函数。
Java线程池ThreadPoolExecutor背后的秘密与实践
热门推荐
张彦峰的博客
05-12 169万+
本文深入分析了Java线程池ThreadPoolExecutor的工作原理、核心参数以及配置策略。通过详细讲解线程池的创建、任务调度和线程管理机制，帮助开发者理解如何高效使用线程池来处理并发任务。文章还探讨了常见的性能瓶颈和优化方法，如合理配置线程池参数、选择适当的拒绝策略等，旨在提升应用的并发处理能力和稳定性。最终，读者将能够根据不同场景灵活调整线程池配置，从而有效提升系统性能。
【Java】线程池技术（三）ThreadPoolExecutor 状态与运行源码解析
Ulrich蚊子Blog
06-21 867
ThreadPoolExecutor 继承了 `AbstractExecutorService`，并实现了 ExecutorService 接口，用于管理线程。内部使用了原子整型 `AtomicInteger ctl` 来表示线程池状态和 Worker 数量。前 3 位表示线程池状态，后 29 位表示 Worker 数量。
Java线程池源码深度解析
知识分享官
10-23 1244
本文主要从源码层面分析了线程池的运行机理，总算知道了execute方法背后是如何运转的。
「超详细」Java线程池源码解析
m0_67698950的博客
04-08 6253
绕不开的线程池 只看ThreadPoolExecutor的英文语义就能知道这是一个与线程池有关的类。 关于线程池，搞过开发的肯定都知道，也都能或多或少讲出相关知识；尽管如此，作者在还是想要不厌其烦的给大家加深加深记忆 线程池是一种池化技术，Java中类似的池化技术有很多， 常见的有： 数据库连接池 redis连接池 http连接池 内存池 线程池 池化技术的作用：把一些能够复用的东西（比如说连接、线程）放到初始化好的池中，便于资源统一管理。 这样做的好处： 避免重复创建、销毁、调度的开销
Java线程池源码分析，深度解读
最新发布
wswpomos的博客
09-28 3979
在传统的多线程编程中，每次需要执行任务时都会创建一个新的线程，任务执行完毕后再销毁该线程。这种方式存在一些问题，例如频繁创建和销毁线程会带来较大的开销，线程数量的不可控会导致系统资源的浪费和性能下降，所以可以采用池化技术来避免这样的性能开销。线程池管理一组线程，这些线程可以被任务复用，而不是每次都创建新的线程。线程池接收任务，并将任务分配给空闲的线程来执行。线程池可以根据需要动态调整线程的数量，以适应不同的负载情况。线程池提供了任务队列，用于存储尚未执行的任务，并根据需要进行排队和调度。
java线程池--ThreadPoolExecutor
Duncan_dsf的博客
08-23 369
java线程池核心类 ThreadPoolExecutor详解以及如何使用
JDK之ThreadPoolExecutor（一）
Find me
02-18 200
文章目录1. 概述2. 工作模式2. 线程池状态+工作线程数=ctl？3. worker是怎么自己从任务队列里面获取任务的？4. 拒绝策略是怎么执行的？5. worker是如何被辞退的？ 1. 概述 本文首先对Java线程池的整个工作流程做一个概述，之后再对其中一些值得思考的地方做一些源码解读 2. 工作模式 Java的线程池是一个worker thread模式，这个模式非常简单，大概就是这么...
java single executor_廖雪峰Java11多线程编程-3高级concurrent包-6ExecutorService
weixin_29911569的博客
02-24 109
());```3. ScheduledThreadPoolJDK还提供了ScheduledThreadPool，使一个任务可以定期反复执行。执行模式：Fixed Rate：在固定的间隔，任务就会执行。例如每隔3秒任务就会启动，而不管这个任务已执行了多长时间、是否结束Fixed Delay：当任务执行完毕以后，等待1秒钟再继续执行。无论任务执行多久，只有在任务结束以后，等待1秒钟才会开始执行下一次的...
11 java 线程池 使用实例
cj_to_niu
07-30 508
转载出处：https://www.cnblogs.com/wihainan/p/4765862.html 在前面的文章中，我们使用线程的时候就去创建一个线程，这样实现起来非常简便，但是就会有一个问题： 如果并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，这样频繁创建线程就会大大降低系统的效率，因为频繁创建线程和销毁线程需要时间。 那么有没有一种办法使得线程可以复用，就是执...
11 Java线程池详解
qq_38007019的博客
02-09 449
线程池使用及优势 线程池做的工作主要是控制运行的线程的数量，处理过程中将任务放入队列，然后在创建后启动这些任务，如果线程数据超过了最大数量，超出数量的线程排队等候，等其他线程执行完毕，再从队列中取出任务来执行 他的主要特点为：线程复用 控制最大并发数 管理线程 第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁的消耗 第二：提高响应速度。当任务到达时任务可以不需要的等到线程创建就能立即执行。 第三：提高线程的可管理性。线程时稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使
JDK 正经操作 之 ThreadPoolExecutor 状态
man
02-06 467
大家好，线程池不知道大家常不常用，反正在面试中你很常用且6的飞起 今天讲一下线程池的状态，注意，是线程池的状态，不是线程的状态，有可能大家平时忽略了这个点 无所谓，今天直接???? 先上一波源码看一看 /** * The main pool control state, ctl, is an atomic integer packing * two conceptual fields * workerCount, indicating the effective number of threads
JAVA11_22学习总结(线程池)
weixin_53118395的博客
11-22 173
11_22学习Java,线程池,后面就是io流了
ThreadPoolExecutor线程池中线程不能超过核心线程数量的问题
qq_28050861的博客
10-09 2485
　　　　 int arg1=2;//核心线程 int arg2=40;//最大线程数量 int arg3=100;//空余保留时间 ThreadPoolExecutor pool=new ThreadPoolExecutor(arg1, arg2, arg3,TimeUnit.MILLISECONDS, // 时间单位 　　...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值