어떻게 ThreadPoolExecutor 를 기반 으로 스 레 드 풀 을 만 들 고 조작 합 니까?
1.사용 하 는 guava 좌표
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>18.0</version>
</dependency>
2.매 거 진 보증 스 레 드 풀 을 만 드 는 것 은 하나의 예 입 니 다.
package com.hao.service;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import com.google.common.util.concurrent.ThreadFactoryBuilder;
public enum ExecutorManager {
INSTANCE;
private ExecutorManager() {
}
private static int AVAILABLEPROCESSORS = Runtime.getRuntime().availableProcessors();
public static final ThreadPoolExecutor threadPoolExecutor =
new ThreadPoolExecutor(AVAILABLEPROCESSORS * 50, AVAILABLEPROCESSORS * 80, 0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>(AVAILABLEPROCESSORS * 2000),
new ThreadFactoryBuilder().setNameFormat("ExecutorManager-pool-Thread-%d").build());
}
3.방법 클래스 만 들 기
package com.hao.service;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import javax.annotation.PostConstruct;
import org.springframework.stereotype.Service;
import com.google.common.base.Preconditions;
@Service
public class ExecutorContext {
public ExecutorService executorService;
private int DEFAULT_WAIT_SECONDS = 2;
@PostConstruct
public void init() {
executorService = ExecutorManager.threadPoolExecutor;
}
public <T> List<T> waitAllFutures(List<Callable<T>> calls, int milliseconds) throws Exception {
Preconditions.checkArgument(null != calls && !calls.isEmpty(), "callable empty.");
LatchedCallables<T> latchAndCallables = wrapCallables(calls);
List<Future<T>> futurres = new LinkedList<>();
for (CountdownedCallable<T> callable : latchAndCallables.wrappedCallables) {
if (null != callable) {
futurres.add(executorService.submit(callable));
}
}
List<T> rets = new ArrayList<>();
if (latchAndCallables.latch.await(milliseconds, TimeUnit.MILLISECONDS)) {
for (CountdownedCallable<T> call : latchAndCallables.wrappedCallables) {
rets.add(call.getResult());
}
} else {
for (Future<T> future : futurres) {
if (!future.isDone()) {
future.cancel(true);
}
}
}
return rets;
}
public <T> List<T> waitAllCallables(List<Callable<T>> calls, int seconds) throws Exception {
Preconditions.checkArgument(null != calls && !calls.isEmpty(), "callable empty.");
LatchedCallables<T> latchAndCallables = wrapCallables(calls);
for (CountdownedCallable<T> callable : latchAndCallables.wrappedCallables) {
executorService.submit(callable);
}
List<T> rets = new ArrayList<>();
if (latchAndCallables.latch.await(seconds, TimeUnit.SECONDS)) {
for (CountdownedCallable<T> call : latchAndCallables.wrappedCallables) {
rets.add(call.getResult());
}
}
return rets;
}
public <T> List<T> waitAllCallables(@SuppressWarnings("unchecked") Callable<T>... calls) throws Exception {
Preconditions.checkNotNull(calls, "callable empty.");
return waitAllCallables(Arrays.asList(calls), DEFAULT_WAIT_SECONDS);
}
private static <T> LatchedCallables<T> wrapCallables(List<Callable<T>> callables) {
CountDownLatch latch = new CountDownLatch(callables.size());
List<CountdownedCallable<T>> wrapped = new ArrayList<>(callables.size());
for (Callable<T> callable : callables) {
wrapped.add(new CountdownedCallable<>(callable, latch));
}
LatchedCallables<T> returnVal = new LatchedCallables<>();
returnVal.latch = latch;
returnVal.wrappedCallables = wrapped;
return returnVal;
}
public static class LatchedCallables<T> {
public CountDownLatch latch;
public List<CountdownedCallable<T>> wrappedCallables;
}
public static class CountdownedCallable<T> implements Callable<T> {
private final Callable<T> wrapped;
private final CountDownLatch latch;
private T result;
public CountdownedCallable(Callable<T> wrapped, CountDownLatch latch) {
this.wrapped = wrapped;
this.latch = latch;
}
@Override
public T call() throws Exception {
try {
result = wrapped.call();
return result;
} finally {
latch.countDown();
}
}
public T getResult() {
return result;
}
}
}
4.테스트 클래스 만 들 기
package com.hao;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import com.hao.bean.Employee;
import com.hao.service.EmployeeService;
import com.hao.service.ExecutorContext;
public class ExecutorTest extends BaseTest {
@Autowired
ExecutorContext executorContext;
@Autowired
EmployeeService employeeService;
@Test
public void test01() {
long t0 = System.currentTimeMillis();
List<Employee> employees = new ArrayList<Employee>();
try {
List<Callable<Integer>> calls = new ArrayList<Callable<Integer>>();
Callable<Integer> able1 = new Callable<Integer>() {
@Override
public Integer call() throws Exception {
Thread.sleep(5000);
Employee employee = employeeService.getById(1L);
employees.add(employee);
return 1;
}
};
calls.add(able1);
Callable<Integer> able2 = new Callable<Integer>() {
@Override
public Integer call() throws Exception {
Thread.sleep(5000);
Employee employee = employeeService.getById(2L);
employees.add(employee);
return 2;
}
};
calls.add(able2);
Callable<Integer> able3 = new Callable<Integer>() {
@Override
public Integer call() throws Exception {
Thread.sleep(5000);
Employee employee = employeeService.getById(3L);
employees.add(employee);
return 3;
}
};
calls.add(able3);
executorContext.waitAllCallables(calls, 5000);
} catch (Exception e) {
e.printStackTrace();
}
for (Employee employee : employees) {
System.out.println(employee);
}
System.out.println(System.currentTimeMillis() - t0);
}
}
5.집행 결 과 는 다음 과 같다.다음 도구 류 의 장점 은 일반 서 비 스 를 사용 하 는 것 처럼 스 레 드 풀 을 사용 하여 병행 작업 을 할 수 있다 는 것 입 니 다.물론 Executor Context 를 sping 에 스 캔 될 수 있 는 곳 에 두 는 것 을 잊 지 마 세 요.
그렇지 않 으 면@Autowired 의존 주입 을 직접 사용 할 수 없습니다.
이상 이 바로 본 고의 모든 내용 입 니 다.여러분 의 학습 에 도움 이 되 고 저 희 를 많이 응원 해 주 셨 으 면 좋 겠 습 니 다.
이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
[Java]활용 5~12강 까지의 내용 정리Random 클래스 여러 클래스들과 메소드를 제공하여 쉽게 처리 가능 재사용성이 높은 코드 작성 가능 List,Set,Map 인터페이스로 구성된다. List와 Set은 Collection 인터페이스의 하위 인터페이스...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.