ThreadPoolExecutor의 코어 풀 크기 대 최대 풀 크기
코어 풀 사이즈와 최대 풀 사이즈의 차이는 정확히 무엇입니까?ThreadPoolExecutor
를를들 들명 ?? ????
이 블로그 투고 내용:
예를 들어 보겠습니다.최소 스레드 풀사이즈는 1, 코어 풀사이즈는 5, 최대 풀사이즈는 10, 큐는 100입니다.
요청이 들어오면 스레드가 최대 5개까지 생성되고 작업이 100에 도달할 때까지 큐에 추가됩니다.가 꽉 새 가 최대까지 됩니다.
maxPoolSize모든 스레드가 사용되고 큐가 가득 차면 작업은 거부됩니다.큐가 줄면 액티브스레드의 수도 줄어듭니다.
threads > corePoolSize 및 < maxPoolSize 를 실행하고 있는 경우 Total 태스크큐가 꽉 차서 새로운 스레드가 도착하면 새로운 스레드를 만듭니다.
From doc: (core Pool Size보다 많고 실행 중인 maximum Pool Size 스레드가 적은 경우 큐가 꽉 찬 경우에만 새 스레드가 생성됩니다.)
자, 간단한 예를 들어보죠.
ThreadPoolExecutor executorPool = new ThreadPoolExecutor(5, 10, 3, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(50));
여기서 5는 corePoolSize입니다.이것은 Jvm이 처음 5개의 태스크에 대해 새로운 스레드를 작성하는 것을 의미합니다.다른 태스크는 큐가 가득 찰 때까지 큐에 추가됩니다(50개의 태스크).
10은 max Pool Size입니다.JVM은 최대 10개의 스레드를 작성할 수 있습니다.즉, 이미 5개의 작업/태스크가 실행 중이며 대기 중인 50개의 작업으로 대기열이 가득 차 있고 대기열에 새로운 요청/태스크가 하나 더 도착하면 JVM은 최대 10개의 새 스레드를 생성합니다(총 스레드 수= 이전 5 + new 5).
new ArrayBlockingQueue(50) =는 총 대기열 크기이며 50개의 작업을 대기열에 넣을 수 있습니다.
10개의 스레드가 모두 실행되고 새로운 태스크가 도착하면 그 새로운 태스크는 거부됩니다.
SUN에 의한 스레드 내부 작성 규칙:
스레드 수가 corePoolSize보다 적은 경우 새 스레드를 생성하여 새 태스크를 실행합니다.
스레드 수가 corePoolSize와 같거나 그보다 클 경우 작업을 큐에 넣습니다.
큐가 꽉 차서 스레드 수가 maxPoolSize보다 적을 경우 태스크를 실행할 새 스레드를 만듭니다.
큐가 꽉 찼고 스레드 수가 maxPoolSize 이상일 경우 작업을 거부합니다.
Hope, 이것은 도움이 됩니다.제가 틀렸다면 정정해 주세요
ThreadPoolExecutor 풀 크기 규칙
「 「 」의 룰.ThreadPoolExecutor's풀은 일반적으로 잘못 이해됩니다. 왜냐하면 풀은 사용자가 생각하는 방식이나 원하는 방식으로 작동하지 않기 때문입니다.
예를 들어 보겠습니다.최소 스레드 풀사이즈는 1, 코어 풀사이즈는 5, 최대 풀사이즈는 10, 큐는 100입니다.
Sun의 방법: 스레드로 들어오는 요청은 최대 5개까지 생성되며 태스크는 100에 도달할 때까지 큐에 추가됩니다.가 꽉 새 가 최대까지 됩니다.maxPoolSize모든 스레드가 사용되고 큐가 가득 차면 작업은 거부됩니다.큐가 줄어들면 액티브스레드의 수도 줄어듭니다.
사용자가 예상하는 방법: 스레드로 들어오는 요청이 최대 10개까지 생성되면 작업이 100개에 도달할 때까지 큐에 추가되어 거부됩니다.스레드 수는 큐가 비워질 때까지 최대값으로 이름이 변경됩니다..corePoolSizeleftdevel..devel.devel.
차이점은 사용자가 풀 크기를 더 일찍 늘리기 시작하고 큐를 더 작게 만들려는 것입니다. Sun 방식은 풀 크기를 작게 유지하고 부하가 커지면 늘립니다.
스레드 작성에 관한 Sun의 규칙은 다음과 같습니다.
corePoolSize새 작업을 수행하기 위한 새 스레드를 만듭니다.- 경우(그 일 )
corePoolSize작업을 큐에 넣습니다. - 가 큐 the the the the the the the 보다 적은
maxPoolSize작업을 실행할 새 스레드를 만듭니다. - 가 " " " 일 "
maxPoolSize, 작업을 거부합니다.꽉만 새로운 는 큐를 넘지 .corePoolSize.
의 입에서:ThreadPoolExecutorAPI 뉴 api
이 있어요.이 게시글을 '아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 아, 네.ThreadPoolExecutor는 코드 예시와 함께 동작합니다.http://forums.sun.com/thread.jspa?threadID=5401400&tstart=0
상세정보 : http://forums.sun.com/thread.jspa?threadID=5224557&tstart=450
문서에서:
새로운 작업이 메서드로 전송되면 execute(java.lang)가 실행됩니다.실행 가능) 및 실행 중인 corePoolSize 스레드 수보다 적으면 다른 워커 스레드가 아이돌 상태일 경우에도 요청을 처리하기 위해 새 스레드가 생성됩니다.corePoolSize보다 크고 실행 중인 maximumPoolSize 스레드 수가 적을 경우 큐가 꽉 찬 경우에만 새 스레드가 생성됩니다.
더 나아가:
corePoolSize와 maximumPoolSize를 동일하게 설정하면 고정 크기의 스레드 풀이 생성됩니다.maximum Pool Size를 Integer와 같은 기본적으로 제한되지 않은 값으로 설정합니다.MAX_VALUE, 임의의 수의 동시 작업을 풀에 수용할 수 있습니다.일반적으로 코어 풀사이즈와 최대 풀사이즈는 구축시에만 설정되지만 setCorePoolSize(int) 및 setMaximumPoolSize(int)를 사용하여 동적으로 변경할 수도 있습니다.
를 작성하기로 ThreadPoolExecutor를 사용하지 않고 으로 실행한다.Executors팩토리 클래스에서는 컨스트럭터 중 하나를 사용하여 팩토리 클래스를 만들고 구성해야 합니다.의 가장 과 같습니다
public ThreadPoolExecutor(
int corePoolSize,
int maxPoolSize,
long keepAlive,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler
);
다음과 같이 설정할 수 있습니다.
- 코어 풀 크기(스레드 풀에서 고정하려고 하는 크기).
- 최대 풀 크기입니다.
- 킵얼라이브 시간 아이돌스레드가 해체될 때까지의 시간
- 실행 대기 중인 작업을 보류하는 작업 대기열입니다.
- 작업 제출이 거부될 때 적용할 정책입니다.
큐잉된 작업 수 제한
실행 중인 동시 태스크의 수를 제한하고 스레드 풀을 사이징하면 예측 가능성과 안정성 측면에서 애플리케이션과 그 실행 환경에 큰 이점이 있습니다.무제한 스레드를 생성하면 런타임 리소스가 소진되고 결과적으로 애플리케이션이 심각한 성능을 발휘할 수 있습니다.e 어플리케이션의 불안정성을 초래할 수 있는 문제
이는 문제의 일부에 대한 해결책일 뿐입니다.실행되는 태스크의 수는 제한되지만 나중에 실행할 수 있도록 제출 및 큐잉할 수 있는 작업의 수는 제한되지 않습니다.응용 프로그램은 나중에 리소스 부족을 겪게 되지만, 제출 속도가 실행 속도를 지속적으로 초과하면 결국 이를 경험하게 됩니다.
이 문제의 해결 방법은 대기 중인 작업을 유지하기 위해 실행자에게 차단 큐를 제공하는 것입니다.'무엇을 하다'RejectedExecutionHandler작업 제출이 거부될 때 호출되기 때문에 거부된 동사가 이전 항목에서 인용된 것입니다.고유한 거부 정책을 구현하거나 프레임워크에서 제공하는 기본 제공 정책 중 하나를 사용할 수 있습니다.
에서는 실행자는 "Default Reject 를 "Default Reject Policy"로 합니다.RejectedExecutionException그러나 다른 기본 제공 정책에서는 다음을 수행할 수 있습니다.
- 작업을 사일런트하게 파기합니다.
- 가장 오래된 작업을 삭제하고 마지막 작업을 다시 제출해 보십시오.
- 호출자의 스레드에서 거부된 작업을 실행합니다.
그림에서는 태스크 추가만 고려합니다.
corepool size 및 maxpool size 용어의 정의는 javadoc에서 확인할 수 있습니다.http://docs.oracle.com/javase/6/docs/api/java/util/concurrent/ThreadPoolExecutor.html
위의 링크에는 질문에 대한 답변이 나와 있습니다.하지만, 확실히 하기 위해.애플리케이션은 corePoolSize에 도달할 때까지 스레드를 계속 만듭니다.이 많은 스레드만으로도 작업 유입을 충분히 처리할 수 있다고 생각합니다.corePoolSize 스레드가 생성된 후 새 작업이 발생하면 작업이 대기열에 들어갑니다.큐가 꽉 차면 실행자는 새 스레드 작성을 시작합니다.그것은 일종의 균형이다.기본적으로 작업 유입이 처리 능력 이상이라는 것을 의미합니다.따라서 실행자는 최대 스레드 수에 도달할 때까지 새 스레드 작성을 다시 시작합니다.다시 큐가 꽉 찬 경우에만 새 스레드가 생성됩니다.
이 블로그의 좋은 설명:
public class ThreadPoolExecutorExample {
public static void main (String[] args) {
createAndRunPoolForQueue(new ArrayBlockingQueue<Runnable>(3), "Bounded");
createAndRunPoolForQueue(new LinkedBlockingDeque<>(), "Unbounded");
createAndRunPoolForQueue(new SynchronousQueue<Runnable>(), "Direct hand-off");
}
private static void createAndRunPoolForQueue (BlockingQueue<Runnable> queue,
String msg) {
System.out.println("---- " + msg + " queue instance = " +
queue.getClass()+ " -------------");
ThreadPoolExecutor e = new ThreadPoolExecutor(2, 5, Long.MAX_VALUE,
TimeUnit.NANOSECONDS, queue);
for (int i = 0; i < 10; i++) {
try {
e.execute(new Task());
} catch (RejectedExecutionException ex) {
System.out.println("Task rejected = " + (i + 1));
}
printStatus(i + 1, e);
}
e.shutdownNow();
System.out.println("--------------------\n");
}
private static void printStatus (int taskSubmitted, ThreadPoolExecutor e) {
StringBuilder s = new StringBuilder();
s.append("poolSize = ")
.append(e.getPoolSize())
.append(", corePoolSize = ")
.append(e.getCorePoolSize())
.append(", queueSize = ")
.append(e.getQueue()
.size())
.append(", queueRemainingCapacity = ")
.append(e.getQueue()
.remainingCapacity())
.append(", maximumPoolSize = ")
.append(e.getMaximumPoolSize())
.append(", totalTasksSubmitted = ")
.append(taskSubmitted);
System.out.println(s.toString());
}
private static class Task implements Runnable {
@Override
public void run () {
while (true) {
try {
Thread.sleep(1000000);
} catch (InterruptedException e) {
break;
}
}
}
}
}
출력:
---- Bounded queue instance = class java.util.concurrent.ArrayBlockingQueue -------------
poolSize = 1, corePoolSize = 2, queueSize = 0, queueRemainingCapacity = 3, maximumPoolSize = 5, totalTasksSubmitted = 1
poolSize = 2, corePoolSize = 2, queueSize = 0, queueRemainingCapacity = 3, maximumPoolSize = 5, totalTasksSubmitted = 2
poolSize = 2, corePoolSize = 2, queueSize = 1, queueRemainingCapacity = 2, maximumPoolSize = 5, totalTasksSubmitted = 3
poolSize = 2, corePoolSize = 2, queueSize = 2, queueCapacity = 1, maximumPoolSize = 5, totalTasksSubmitted = 4
poolSize = 2, corePoolSize = 2, queueSize = 3, queueRemainingCapacity = 0, maximumPoolSize = 5, totalTasksSubmitted = 5
poolSize = 3, corePoolSize = 2, queueSize = 3, queueRemainingCapacity = 0, maximumPoolSize = 5, totalTasksSubmitted = 6
poolSize = 4, corePoolSize = 2, queueSize = 3, queueRemainingCapacity = 0, maximumPoolSize = 5, totalTasksSubmitted = 7
poolSize = 5, corePoolSize = 2, queueSize = 3, queueRemainingCapacity = 0, maximumPoolSize = 5, totalTasksSubmitted = 8
Task rejected = 9
poolSize = 5, corePoolSize = 2, queueSize = 3, queueRemainingCapacity = 0, maximumPoolSize = 5, totalTasksSubmitted = 9
Task rejected = 10
poolSize = 5, corePoolSize = 2, queueSize = 3, queueRemainingCapacity = 0, maximumPoolSize = 5, totalTasksSubmitted = 10
--------------------
---- Unbounded queue instance = class java.util.concurrent.LinkedBlockingDeque -------------
poolSize = 1, corePoolSize = 2, queueSize = 0, queueRemainingCapacity = 2147483647, maximumPoolSize = 5, totalTasksSubmitted = 1
poolSize = 2, corePoolSize = 2, queueSize = 0, queueRemainingCapacity = 2147483647, maximumPoolSize = 5, totalTasksSubmitted = 2
poolSize = 2, corePoolSize = 2, queueSize = 1, queueRemainingCapacity = 2147483646, maximumPoolSize = 5, totalTasksSubmitted = 3
poolSize = 2, corePoolSize = 2, queueSize = 2, queueRemainingCapacity = 2147483645, maximumPoolSize = 5, totalTasksSubmitted = 4
poolSize = 2, corePoolSize = 2, queueSize = 3, queueRemainingCapacity = 2147483644, maximumPoolSize = 5, totalTasksSubmitted = 5
poolSize = 2, corePoolSize = 2, queueSize = 4, queueRemainingCapacity = 2147483643, maximumPoolSize = 5, totalTasksSubmitted = 6
poolSize = 2, corePoolSize = 2, queueSize = 5, queueRemainingCapacity = 2147483642, maximumPoolSize = 5, totalTasksSubmitted = 7
poolSize = 2, corePoolSize = 2, queueSize = 6, queueRemainingCapacity = 2147483641, maximumPoolSize = 5, totalTasksSubmitted = 8
poolSize = 2, corePoolSize = 2, queueSize = 7, queueRemainingCapacity = 2147483640, maximumPoolSize = 5, totalTasksSubmitted = 9
poolSize = 2, corePoolSize = 2, queueSize = 8, queueRemainingCapacity = 2147483639, maximumPoolSize = 5, totalTasksSubmitted = 10
--------------------
---- Direct hand-off queue instance = class java.util.concurrent.SynchronousQueue -------------
poolSize = 1, corePoolSize = 2, queueSize = 0, queueRemainingCapacity = 0, maximumPoolSize = 5, totalTasksSubmitted = 1
poolSize = 2, corePoolSize = 2, queueSize = 0, queueRemainingCapacity = 0, maximumPoolSize = 5, totalTasksSubmitted = 2
poolSize = 3, corePoolSize = 2, queueSize = 0, queueRemainingCapacity = 0, maximumPoolSize = 5, totalTasksSubmitted = 3
poolSize = 4, corePoolSize = 2, queueSize = 0, queueRemainingCapacity = 0, maximumPoolSize = 5, totalTasksSubmitted = 4
poolSize = 5, corePoolSize = 2, queueSize = 0, queueRemainingCapacity = 0, maximumPoolSize = 5, totalTasksSubmitted = 5
Task rejected = 6
poolSize = 5, corePoolSize = 2, queueSize = 0, queueRemainingCapacity = 0, maximumPoolSize = 5, totalTasksSubmitted = 6
Task rejected = 7
poolSize = 5, corePoolSize = 2, queueSize = 0, queueRemainingCapacity = 0, maximumPoolSize = 5, totalTasksSubmitted = 7
Task rejected = 8
poolSize = 5, corePoolSize = 2, queueSize = 0, queueRemainingCapacity = 0, maximumPoolSize = 5, totalTasksSubmitted = 8
Task rejected = 9
poolSize = 5, corePoolSize = 2, queueSize = 0, queueRemainingCapacity = 0, maximumPoolSize = 5, totalTasksSubmitted = 9
Task rejected = 10
poolSize = 5, corePoolSize = 2, queueSize = 0, queueRemainingCapacity = 0, maximumPoolSize = 5, totalTasksSubmitted = 10
--------------------
Process finished with exit code 0
Java Concurency Essentials라는 책에서 :
코어 풀 사이즈:ThreadPoolExecutor에는 큐가 꽉 찼을 때만 새 스레드가 시작될 때까지 시작할 스레드 수를 결정하는 corePoolSize 속성이 있습니다.
Maximum Pool Size(최대 풀 사이즈):이 속성은 최대 시작 스레드 수를 결정합니다.이 값을 Integer로 설정할 수 있습니다.MAX_VALUE 상한을 가지지 않도록 합니다.
java.discurrent.concurrent.동시ThreadPoolExecutor
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
/*
* Proceed in 3 steps:
*
* 1. If fewer than corePoolSize threads are running, try to
* start a new thread with the given command as its first
* task. The call to addWorker atomically checks runState and
* workerCount, and so prevents false alarms that would add
* threads when it shouldn't, by returning false.
*
* 2. If a task can be successfully queued, then we still need
* to double-check whether we should have added a thread
* (because existing ones died since last checking) or that
* the pool shut down since entry into this method. So we
* recheck state and if necessary roll back the enqueuing if
* stopped, or start a new thread if there are none.
*
* 3. If we cannot queue task, then we try to add a new
* thread. If it fails, we know we are shut down or saturated
* and so reject the task.
*/
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);
}
「」의 내부 의 에 대해서ThreadPoolExecutor때, 저는 해야 하는지 이 되었습니다.corePoolSize ★★★★★★★★★★★★★★★★★」maximumPoolSize하다
다음 중 하나를 선택해주세요.
N이다.getPoolSize(). 스레드 + 스레드 '+' ' + ' ' ' ' ' ' ''T실행자/풀에 제출된 작업의 양입니다.C코어 풀의 크기가 됩니다.getCorePoolSize(). 새 작업이 큐로 전송되기 전에 수신 작업에 대해 풀당 최대 몇 개의 스레드를 생성할 수 있습니까?M의 최대인 대대 be be be be be be be be be be be be be be.getMaximumPoolSize(). 할 수 풀에서 할당할 수 있는 최대 스레드 양입니다.
의 ThreadPoolExecutor에서 새 될 때: Java를 사용합니다.
- ★★★의
N <= C아이돌 스레드에는 새로운 착신 태스크가 할당되지 않고 새로운 스레드가 생성됩니다. - ★★★의
N > C유휴 스레드가 있는 경우 새 작업이 할당됩니다. - ★★★의
N > C유휴 스레드가 없는 경우 새 태스크가 대기열에 추가됩니다.여기에 새로운 스레드가 작성되지 않았습니다. - 큐가 꽉 차면 새로운 스레드를 만듭니다.
M.M이치노여기서 중요한 것은 큐가 가득 찰 때까지 새로운 스레드를 작성하지 않는 것입니다.
출처:
예
「 」의 corePoolSize = 0 ★★★★★★★★★★★★★★★★★」maximumPoolSize = 10 ''의50.
그러면 큐에 50개의 항목이 포함될 때까지 풀 내에 하나의 활성 스레드가 생성됩니다.
executor.execute(task #1):
before task #1 submitted to executor: java.util.concurrent.ThreadPoolExecutor@c52dafe[Running, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 0]
after task #1 submitted to executor: java.util.concurrent.ThreadPoolExecutor@c52dafe[Running, pool size = 1, active threads = 1, queued tasks = 1, completed tasks = 0]
[task #1 immediately queued and kicked in b/c the very first thread is created when `workerCountOf(recheck) == 0`]
execute(task #2):
before task #2 submitted to executor: java.util.concurrent.ThreadPoolExecutor@c52dafe[Running, pool size = 1, active threads = 1, queued tasks = 0, completed tasks = 0]
after task #2 submitted to executor: java.util.concurrent.ThreadPoolExecutor@c52dafe[Running, pool size = 1, active threads = 1, queued tasks = 1, completed tasks = 0]
[task #2 not starting before #1 is done]
... executed a few tasks...
execute(task #19)
before task #19 submitted to executor: java.util.concurrent.ThreadPoolExecutor@735afe38[Running, pool size = 1, active threads = 1, queued tasks = 17, completed tasks = 0]
after task #19 submitted to executor: java.util.concurrent.ThreadPoolExecutor@735afe38[Running, pool size = 1, active threads = 1, queued tasks = 18, completed tasks = 0]
...
execute(task #51)
before task submitted to executor: java.util.concurrent.ThreadPoolExecutor@735afe38[Running, pool size = 1, active threads = 1, queued tasks = 50, completed tasks = 0]
after task submitted to executor: java.util.concurrent.ThreadPoolExecutor@735afe38[Running, pool size = 2, active threads = 2, queued tasks = 50, completed tasks = 0]
Queue is full.
A new thread was created as the queue was full.
「 」의 corePoolSize = 10 ★★★★★★★★★★★★★★★★★」maximumPoolSize = 10 ''의50.
그러면 풀에 10개의 활성 스레드가 생성됩니다.큐에 50개의 항목이 있을 경우 태스크는 거부됩니다.
execute(task #1)
before task #1 submitted to executor: java.util.concurrent.ThreadPoolExecutor@32d9e072[Running, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 0]
after task #1 submitted to executor: java.util.concurrent.ThreadPoolExecutor@32d9e072[Running, pool size = 1, active threads = 1, queued tasks = 0, completed tasks = 0]
execute(task #2)
before task #2 submitted to executor: java.util.concurrent.ThreadPoolExecutor@32d9e072[Running, pool size = 1, active threads = 1, queued tasks = 0, completed tasks = 0]
after task #2 submitted to executor: java.util.concurrent.ThreadPoolExecutor@32d9e072[Running, pool size = 2, active threads = 2, queued tasks = 0, completed tasks = 0]
execute(task #3)
before task #3 submitted to executor: java.util.concurrent.ThreadPoolExecutor@32d9e072[Running, pool size = 2, active threads = 2, queued tasks = 0, completed tasks = 0]
after task #3 submitted to executor: java.util.concurrent.ThreadPoolExecutor@32d9e072[Running, pool size = 3, active threads = 3, queued tasks = 0, completed tasks = 0]
... executed a few tasks...
execute(task #11)
before task #11 submitted to executor: java.util.concurrent.ThreadPoolExecutor@32d9e072[Running, pool size = 10, active threads = 10, queued tasks = 0, completed tasks = 0]
after task #11 submitted to executor: java.util.concurrent.ThreadPoolExecutor@32d9e072[Running, pool size = 10, active threads = 10, queued tasks = 1, completed tasks = 0]
... executed a few tasks...
execute(task #51)
before task #51 submitted to executor: java.util.concurrent.ThreadPoolExecutor@32d9e072[Running, pool size = 10, active threads = 10, queued tasks = 50, completed tasks = 0]
Task was rejected as we have reached `maximumPoolSize`.
매뉴얼에 따라 다음 절차를 따릅니다.
임의의 BlockingQueue를 사용하여 제출된 작업을 전송하고 유지할 수 있습니다.이 큐를 사용하면 풀 사이징과 상호 작용합니다.실행 중인 코어 풀사이즈 스레드 수가 적을 경우 실행자는 큐잉보다 항상 새 스레드를 추가하는 것을 선호합니다.코어 풀 크기 또는 더 많은 스레드가 실행 중인 경우 실행자는 항상 새 스레드를 추가하는 것보다 요청 대기열을 선호합니다.요청을 큐잉할 수 없는 경우 maximumPoolSize를 초과하지 않는 한 새 스레드가 생성됩니다.이 경우 작업은 거부됩니다.
즉, 코어 풀 사이즈가 임계값임을 의미합니다.이 임계값을 넘으면 실행자 서비스는 새로운 스레드를 생성하는 것보다 작업을 큐잉하는 것을 선호합니다.태스크를 수신할 때 스레드 수가 코어 풀 크기보다 작을 경우 새 스레드가 생성되므로 활성 스레드가 증가합니다.
언급URL : https://stackoverflow.com/questions/17659510/core-pool-size-vs-maximum-pool-size-in-threadpoolexecutor
'source' 카테고리의 다른 글
| sqlalchemy ORM 쿼리에서 NOT IN 절을 사용하는 방법 (0) | 2022.09.05 |
|---|---|
| C 콘솔에 바이너리 트리를 그리는 방법 (0) | 2022.09.05 |
| 히스토그램 그림에 대한 데이터 가져오기 (0) | 2022.09.05 |
| MySQL 8에서 동면 사투리를 사용하시겠습니까? (0) | 2022.09.05 |
| 데이터베이스 샤딩과 파티셔닝 (0) | 2022.09.05 |