Android 다 중 스 레 드 - 스 레 드 탱크 ThreadPoolExecutor 상세 설명 및 사용

Android 스 레 드 풀 상세 설명
프롤로그

ThreadPoolExecutor

스 레 드 탱크 의 분류

FixedThreadPool

CachedThreadPool

ScheduledThreadPool

SingleThreadExecutor

기본 사용
머리말
개발 에 있어 서 자주 스 레 드 를 사용 하여 비동기 작업 을 하지만 모든 스 레 드 의 생 성 과 폐 기 는 일정한 비용 이 필요 합 니 다.그래서 스 레 드 탱크 가 스 레 드 를 관리 해 야 합 니 다.Android 의 스 레 드 풀 은 자바 의 Executor 에서 유래 되 었 으 며, Executor 는 인터페이스 이 며, 실제 스 레 드 풀 구현 클래스 는 ThreadPoolExecutor 입 니 다.
ThreadPoolExecutor
우 리 는 Thread PoolExecutor 를 통 해 스 레 드 풀 을 만 들 수 있 습 니 다. Thread PoolExecutor 는 4 개의 구조 방법 이 있 습 니 다. 그들 은 일련의 매개 변 수 를 제공 하여 스 레 드 풀 을 설정 합 니 다.다음은 Thread PoolExecutor 의 매개 변수 가 가장 많은 구조 방법 입 니 다.

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue 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;
    }

다음 매개 변 수 를 설명 하 겠 습 니 다.
---------int corePoolSize
핵심 루틴 수.기본 적 인 상황 에서 오프라인 풀 은 비어 있 습 니 다. 작업 을 제출 할 때 만 스 레 드 를 만 듭 니 다.현재 실행 중인 스 레 드 수가 corePoolSize 보다 적 으 면 새 스 레 드 를 만들어 작업 을 처리 합 니 다.core PoolSize 와 같 거나 크 면 만 들 지 않 습 니 다.스 레 드 탱크 의 prestart Allcore Thread 방법 을 호출 하면 스 레 드 탱크 는 모든 핵심 스 레 드 를 미리 만 들 고 시작 하여 작업 을 기다 릴 것 입 니 다.
---------int maximumPoolSize
스 레 드 탱크 에서 만 들 수 있 는 최대 스 레 드 수 입 니 다.작업 대기 열 이 가득 차고 스 레 드 수가 maximumPoolSize 보다 적 으 면 스 레 드 탱크 는 여전히 새로운 스 레 드 를 만들어 작업 을 처리 합 니 다.
---------long keepAliveTime
비 핵심 스 레 드 유 휴 시간 초과.이 시간 이 지나 면 회수 합 니 다.만약 에 임무 가 많 고 모든 임무 의 수행 사건 이 짧 으 면 keepAliveTime 을 확대 하여 라인 의 이 용 률 을 높 일 수 있다.또한 allowCoreThreadTimeOut 속성 을 true 로 설정 하면 keepAliveTime 도 핵심 스 레 드 에 적 용 됩 니 다.
---------TimeUnit unit
keepAliveTime 매개 변 수 를 지정 하 는 시간 단위 입 니 다.분 (TimeUnit. MINUTES), 초 (TimeUnit. SECOND S), 밀리초 (TimeUnit. MILLISECONDS) 등 이 자주 사용 되 는 매 거 진 이다.
---------BlockingQueue workQueue
작업 대기 열.현재 스 레 드 수가 corePoolSize 보다 많 으 면 이 작업 대기 열 에 작업 을 추가 합 니 다.이 작업 대기 열 은 BlockingQueue 형식 입 니 다. 즉, 대기 열 을 막 는 것 입 니 다.
---------ThreadFactory threadFactory
선로 공장.스 레 드 탱크 에 새 스 레 드 를 만 드 는 기능 을 제공 합 니 다. ThreadFactory 는 인터페이스 입 니 다. 하나의 방법 만 있 습 니 다. Thread newThread (Runnable r);
---------RejectedExecutionHandler handler
포화 전략.이것 은 작업 대기 열 과 스 레 드 탱크 가 가득 찼 을 때 취 하 는 대응 전략 입 니 다. 기본 값 은 Abord Policy 입 니 다. 새 작업 을 처리 할 수 없 음 을 표시 하고 Rejected Execution Exception 이상 을 던 집 니 다.그 밖 에 세 가지 전략 이 있 는데 각각 다음 과 같다.
1. CallerRunsPolicy: 호출 자가 있 는 스 레 드 로 작업 을 처리 합 니 다.이 정책 은 새로운 작업 의 제출 속 도 를 늦 출 수 있 는 간단 한 피드백 제어 체 제 를 제공 합 니 다.2. DiscardPolicy: 실행 할 수 없 는 작업 을 삭제 합 니 다.3. DiscardOldestPolicy: 대기 열의 최근 작업 을 버 리 고 현재 작업 을 수행 합 니 다.
Thread PoolExecutor 가 임 무 를 수행 할 때 다음 과 같은 몇 가지 원칙 을 따른다.
(1) 스 레 드 탱크 의 스 레 드 수가 핵심 스 레 드 수 에 이 르 지 못 하면 핵심 스 레 드 를 만들어 작업 을 처리 합 니 다. (2) 스 레 드 수가 크 거나 핵심 스 레 드 수 와 같 으 면 작업 은 작업 대기 열 에 들 어가 줄 을 서서 실행 을 기다 리 고 스 레 드 탱크 의 남 은 스 레 드 는 작업 대기 열 에서 작업 을 계속 꺼 내 처리 합 니 다. (3) 작업 대기 열 이 가득 차 있 고 이때 스 레 드 수량 이 최대 스 레 드 수량 에 이 르 지 못 하면 즉시 비 핵심 스 레 드 를 시작 하여 작업 을 처리 합 니 다. (4) 스 레 드 수가 최대 스 레 드 수 를 초과 하면 포화 전략 을 실행 합 니 다.Thread PoolExecutor 는 Rejected Execution Handler 의 rejected Execution 방법 을 호출 하여 호출 자 에 게 알 립 니 다.
스 레 드 탱크 의 분류
Android 에는 네 가지 가장 흔히 볼 수 있 는 서로 다른 기능 을 가 진 스 레 드 탱크 가 있 는데 이들 은 Thread PoolExecutor 의 인 자 를 직접 또는 간접 적 으로 설정 하여 자신의 기능 특성 을 실현 합 니 다.
FixedThreadPool
Fixed ThreadPool 은 Executors 의 new Fixed ThreadPool 방법 을 통 해 만 들 어 졌 으 며 스 레 드 수가 고정된 스 레 드 풀 입 니 다.스 레 드 가 비어 있 을 때 스 레 드 탱크 가 닫 히 지 않 는 한 회수 되 지 않 습 니 다.

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

Fixed ThreadPool 의 core PoolSize 와 maximum PoolSize 는 모두 Fixed ThreadPool 이 지정 한 매개 변수 nThreads 를 만 드 는 것 으로 설정 되 어 있 습 니 다. 이 는 Fixed ThreadPool 은 핵심 스 레 드 만 있 고 수량 이 고정 되 어 있 으 며 비 핵심 스 레 드 가 없다 는 것 을 의미 합 니 다.Fixed ThreadPool 은 핵심 스 레 드 만 있 고 이 핵심 스 레 드 는 회수 되 지 않 기 때문에 외부 요청 에 더욱 빠르게 응 할 수 있 음 을 의미 합 니 다.keepAliveTime 을 0 L 로 설정 하면 남 은 스 레 드 가 즉시 종 료 됩 니 다.여분의 스 레 드 가 발생 하지 않 기 때문에 keepAliveTime 은 잘못된 인자 입 니 다.또한, 작업 대기 열 은 경계 없 는 차단 대기 열 링크 드 Blocking Queue 를 사용 합 니 다.
CachedThreadPool
CachedThreadPool 은 Executors 의 new CachedThreadPool 방법 을 통 해 만 들 어 졌 으 며, 스 레 드 수가 고정 되 지 않 은 스 레 드 풀 입 니 다.

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

CachedThreadPool 의 corePoolSize 는 0 이 고 maximumPoolSize 는 Integer. MAX 로 설정 되 어 있 습 니 다.VALUE, 이 는 CachedThreadPool 에 핵심 스 레 드 가 없고 비 핵심 스 레 드 가 무한 하 다 는 것 을 의미한다.keepAliveTime 을 60L 로 설정 하면 남 은 스 레 드 가 새 작업 을 기다 리 는 최 장 시간 은 60s 입 니 다.이 곳 에서 차단 대기 열 SynchronousQueue 를 사 용 했 습 니 다. 요 소 를 저장 하지 않 는 차단 대기 열 입 니 다. 모든 삽입 작업 은 다른 스 레 드 의 제거 작업 을 기 다 려 야 합 니 다. 마찬가지 로 모든 제거 작업 은 다른 스 레 드 의 삽입 작업 을 기 다 려 야 합 니 다.
ScheduledThreadPool
Scheduled ThreadPool 은 정시 와 주기 적 인 임 무 를 수행 할 수 있 는 스 레 드 풀 입 니 다.

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

Scheduled Thread PoolExecutor 를 만 들 었 습 니 다. Scheduled Thread PoolExecutor 는 Thread PoolExecutor 에서 계승 합 니 다. 지연 되 는 작업 을 지정 하거나 정기 적 으로 작업 을 처리 하 는 데 사 용 됩 니 다.구조 방법 은 다음 과 같다.

	public ScheduledThreadPoolExecutor(int corePoolSize) {
        super(corePoolSize, Integer.MAX_VALUE,
              DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
              new DelayedWorkQueue());
    }

Scheduled Thread PoolExecutor 의 구조 방법 은 최종 적 으로 Thread PoolExecutor 의 구조 방법 을 호출 합 니 다.corePoolSize 는 들 어 오 는 고정 수치 이 고 maximumPoolSize 의 값 은 Integer. MAX 입 니 다.VALUE。Delayed WorkQueue 를 사용 하 는 것 은 무한 하기 때문에 maximum PoolSize 라 는 매개 변 수 는 유효 하지 않 습 니 다.
SingleThreadExecutor
싱글 ThreadExecutor 는 하나의 작업 스 레 드 를 사용 하 는 스 레 드 풀 입 니 다.

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

core PoolSize 와 maximum PoolSize 는 모두 1 로 Single ThreadExecutor 는 하나의 핵심 스 레 드 만 있 음 을 의미 하 며 모든 작업 이 같은 스 레 드 에서 순서대로 실 행 될 수 있 도록 합 니 다.그 의 미 는 모든 외부 임 무 를 하나의 스 레 드 로 통일 시 켜 이 임무 들 간 에 스 레 드 동기 화 문 제 를 처리 할 필요 가 없 도록 하 는 것 이다.다른 매개 변 수 는 Fixed ThreadPool 과 같 습 니 다.
기본 사용
다음 코드 는 네 가지 스 레 드 탱크 의 기본 사용 을 간단하게 소개 합 니 다.

		Runnable task = new Runnable() {
            @Override
            public void run() {
                //      
            }
        };

        ExecutorService pool1 = Executors.newFixedThreadPool(3);
        pool1.execute(task);

        ExecutorService pool2 = Executors.newCachedThreadPool();
        pool2.execute(task);

        ScheduledExecutorService pool3 = Executors.newScheduledThreadPool(4);
        pool3.schedule(task, 1000, TimeUnit.MILLISECONDS);//1000m   task
        pool3.scheduleAtFixedRate(task, 100, 1000, TimeUnit.MILLISECONDS);//  100ms   1000ms    task

        ExecutorService pool4 = Executors.newSingleThreadExecutor();
        pool4.execute(task);