자바 에서 자주 사용 하 는 네 가지 스 레 드 탱크

자바 에서 스 레 드 풀 을 사용 하면 Thread PoolExecutor 의 구조 함수 로 라인 풀 인 스 턴 스 를 직접 만 들 수 있 습 니 다. 이전 글 자바 스 레 드 풀 구조 파 라미 터 를 참조 하 는 방법 에 대해 자세히 설명 할 수 있 습 니 다.그러나 Executors 클래스 에서 자주 사용 하 는 스 레 드 풀 을 만 드 는 방법 을 제공 합 니 다.다음은 자주 사용 하 는 네 가 지 를 알 아 보 겠 습 니 다.
newFixedThreadPool
우선, 이 스 레 드 탱크 의 생 성 방법 을 보 세 요.

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

구조 방법 을 통 해 알 수 있 듯 이 스 레 드 탱크 는 고정 크기 의 스 레 드 탱크 를 만 들 었 고 하나의 작업 을 제출 할 때마다 스 레 드 탱크 의 최대 치 nThreads 에 이 를 때 까지 스 레 드 를 만 들 었 다.스 레 드 탱크 의 크기 가 최대 치 에 도달 하면 새로운 작업 을 제출 할 때 무 계 차단 대기 열 에 넣 고 스 레 드 가 남 을 때 까지 대기 열 에서 작업 을 꺼 내 계속 수행 합 니 다.그렇다면 어떻게 사용 합 니까 newFixedThreadPool?우리 예 를 들 자.

public class OneMoreStudy {
    public static void main(String[] args) {
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);

        for (int i = 0; i < 5; i++) {
            final int index = i;
            fixedThreadPool.execute(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            SimpleDateFormat sdf = new SimpleDateFormat(
                                    "HH:mm:ss");
                            System.out.println("    : " +
                                sdf.format(new Date()) + " " + index);
                            Thread.sleep(2000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                });
        }

        fixedThreadPool.shutdown(); 
    }
}

위의 예 에서 고정 크기 가 3 인 스 레 드 탱크 를 만 든 다음 온라인 스 레 드 탱크 에서 5 개의 작업 을 제출 했다.네 번 째 작업 을 제출 할 때 스 레 드 탱크 의 크기 가 3 에 이 르 렀 고 세 번 째 작업 이 실행 중이 기 때문에 네 번 째 작업 은 대기 열 에 넣 어 빈 스 레 드 가 있 을 때 실 행 됩 니 다.실행 결 과 는 다음 과 같 습 니 다 (앞의 3 개 작업 과 뒤의 2 개 작업 의 실행 시간 을 주의 하 십시오).

    : 08:09:02 1
    : 08:09:02 2
    : 08:09:02 0
    : 08:09:04 4
    : 08:09:04 3

newCachedThreadPool
우선, 이 스 레 드 탱크 의 생 성 방법 을 보 세 요.

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

구조 적 방법 을 통 해 알 수 있 듯 이 캐 시 가능 한 스 레 드 풀 을 만 들 었 습 니 다.새로운 작업 을 제출 할 때 남 은 스 레 드 가 있 으 면 작업 을 직접 처리 하고 남 은 스 레 드 가 없 으 면 새로운 스 레 드 처리 작업 을 만 듭 니 다. 대기 열 에 작업 을 저장 하지 않 습 니 다.스 레 드 탱크 는 스 레 드 탱크 의 크기 를 제한 하지 않 습 니 다. 스 레 드 탱크 의 크기 는 운영 체제 (또는 JVM) 가 만 들 수 있 는 최대 스 레 드 크기 에 전적으로 의존 합 니 다.스 레 드 의 여가 시간 이 60 초 를 넘 으 면 회수 된다.그렇다면 어떻게 사용 합 니까 newCachedThreadPool?우리 예 를 들 자.

public class OneMoreStudy {
    public static void main(String[] args) {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

        for (int i = 0; i < 5; i++) {
            final int index = i;
            cachedThreadPool.execute(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            SimpleDateFormat sdf = new SimpleDateFormat(
                                    "HH:mm:ss");
                            System.out.println("    : " +
                                sdf.format(new Date()) + " " + index);
                            Thread.sleep(2000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                });
        }

        cachedThreadPool.shutdown();
    }
}

이 스 레 드 는 새로운 작업 을 제출 하면 새 스 레 드 (스 레 드 탱크 에 빈 스 레 드 가 없 을 때) 를 만 들 수 있 습 니 다. 기다 릴 필요 가 없 기 때문에 제출 한 5 개의 작업 의 실행 시간 은 같 습 니 다. 실행 결 과 는 다음 과 같 습 니 다.

    : 08:45:18 2
    : 08:45:18 1
    : 08:45:18 3
    : 08:45:18 4
    : 08:45:18 0

newSingleThreadExecutor
우선, 이 스 레 드 탱크 의 생 성 방법 을 보 세 요.

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

구조 방법 을 통 해 알 수 있 듯 이 이것 은 단선 화 된 스 레 드 탱크 를 만 들 었 다. 이것 은 유일한 작업 스 레 드 로 만 임 무 를 수행 하고 모든 임 무 를 지 정 된 순서에 따라 집행 하도록 보장 할 수 있다.그렇다면 어떻게 사용 합 니까 newSingleThreadExecutor?우리 예 를 들 자.

public class OneMoreStudy {
    public static void main(String[] args) {
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

        for (int i = 0; i < 5; i++) {
            final int index = i;
            singleThreadExecutor.execute(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            SimpleDateFormat sdf = new SimpleDateFormat(
                                    "HH:mm:ss");
                            System.out.println("    : " +
                                sdf.format(new Date()) + " " + index);
                            Thread.sleep(2000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                });
        }

        singleThreadExecutor.shutdown();
    }
}

이 스 레 드 탱크 는 단일 스 레 드 실행 과 유사 하기 때문에 먼저 이전 작업 을 수행 한 다음 에 다음 작업 을 순서대로 수행 합 니 다. 실행 결 과 는 다음 과 같 습 니 다.

    : 08:54:17 0
    : 08:54:19 1
    : 08:54:21 2
    : 08:54:23 3
    : 08:54:25 4

어떤 학생 들 은 단일 스 레 드 실행 과 유사 한 이상 이런 스 레 드 탱크 가 존재 할 필요 가 있 느 냐 고 의심 할 수도 있다.이곳 의 단일 스 레 드 실행 은 스 레 드 탱크 내 부 를 말 합 니 다. 스 레 드 탱크 밖의 측면 에서 볼 때 메 인 스 레 드 는 작업 을 스 레 드 탱크 에 제출 할 때 막 히 지 않 고 비동기 적 입 니 다.
newScheduledThreadPool
이 방법 은 시간 과 주기 적 인 작업 수행 을 지원 하 는 고정 크기 의 스 레 드 풀 을 만 들 었 습 니 다.우선 정시 에 실행 되 는 예 를 살 펴 보 자.

public class OneMoreStudy {
    public static void main(String[] args) {
        final SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
        System.out.println("    : " + sdf.format(new Date()));
        scheduledThreadPool.schedule(new Runnable() {
                @Override
                public void run() {
                    System.out.println("    : " + sdf.format(new Date()));
                }
            }, 3, TimeUnit.SECONDS);
        scheduledThreadPool.shutdown();
    }
}

이 스 레 드 탱크 의 schedule 방법 을 사용 하여 3 초 지연 후 임 무 를 수행 합 니 다. 실행 결 과 는 다음 과 같 습 니 다.

    : 09:11:39
    : 09:11:42

주기 적 으로 실행 되 는 예 를 다시 봅 시다.

public class OneMoreStudy {
    public static void main(String[] args) {
        final SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
        System.out.println("    : " + sdf.format(new Date()));
        scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
                @Override
                public void run() {
                    System.out.println("    : " + sdf.format(new Date()));
                }
            }, 1, 3, TimeUnit.SECONDS);
        Thread.sleep(10000);
        scheduledThreadPool.shutdown();
    }
}

이 스 레 드 탱크 의 scheduleAtFixedRate 방법 을 사용 하여 1 초 지연 후 3 초 마다 작업 을 수행 합 니 다. 실행 결 과 는 다음 과 같 습 니 다.

    : 09:23:20
    : 09:23:21
    : 09:23:24
    : 09:23:27