자바 concurrency 스 레 드 탱크 의 스 레 드 탱크 원리(4)동력 노드 자바 대학 정리

정책 소개 거부
스 레 드 탱크 의 거부 정책 은 작업 이 스 레 드 탱크 에 추 가 될 때 거부 되 는 처리 조 치 를 말 합 니 다.
스 레 드 탱크 에 작업 을 추가 하 는 것 이 거부 되 는 이 유 는 첫째,스 레 드 탱크 가 이상 하 게 닫 혔 기 때 문 일 수 있 습 니 다.둘째,작업 수량 이 스 레 드 탱크 의 최대 제한 을 초과 합 니 다.
스 레 드 탱크 는 모두 4 가지 거부 정책 을 포함 하 는데 그것 이 바로 AbortPolicy 입 니 다. CallerRunsPolicy, DiscardOldestPolicy 와 DiscardPolicy.

AbortPolicy         -- 스 레 드 풀 에 작업 을 추가 하 는 것 이 거부 되 었 을 때 Rejected Execution Exception 이상 을 던 집 니 다.

CallerRunsPolicy    -- 스 레 드 탱크 에 작업 을 추가 하 는 것 이 거부 되 었 을 때 현재 실행 중인 Thread 스 레 드 탱크 에서 거부 되 는 작업 을 처리 합 니 다.

DiscardOldestPolicy-작업 이 스 레 드 탱크 에 추가 되 어 거부 되 었 을 때 스 레 드 탱크 는 대기 열 에서 가장 오래된 처리 되 지 않 은 작업 을 포기 하고 거 부 된 작업 을 대기 열 에 추가 합 니 다.

DiscardPolicy       -- 스 레 드 탱크 에 작업 을 추가 하 는 것 이 거부 되 었 을 때 스 레 드 탱크 는 거부 되 는 작업 을 버 립 니 다.

스 레 드 탱크 의 기본 처리 정책 은 AbortPolicy 입 니 다!
정책 대비 와 예제 거부
다음은 예 시 를 통 해 스 레 드 탱크 의 4 가지 거부 정책 을 보 여 줍 니 다.
1.DiscardPolicy 예시

 import java.lang.reflect.Field;
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.ThreadPoolExecutor.DiscardPolicy;
 
 public class DiscardPolicyDemo {
 
   private static final int THREADS_SIZE = 1;
   private static final int CAPACITY = 1;
 
   public static void main(String[] args) throws Exception {
 
     //      。    "     " "     "  1(THREADS_SIZE)，"   "        1(CAPACITY)。
     ThreadPoolExecutor pool = new ThreadPoolExecutor(THREADS_SIZE, THREADS_SIZE, 0, TimeUnit.SECONDS,
         new ArrayBlockingQueue<Runnable>(CAPACITY));
     //            "  "
     pool.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy());
 
     //   10   ，           。
     for (int i = 0; i < 10; i++) {
       Runnable myrun = new MyRunnable("task-"+i);
       pool.execute(myrun);
     }
     //      
     pool.shutdown();
   }
 }
 
 class MyRunnable implements Runnable {
   private String name;
   public MyRunnable(String name) {
     this.name = name;
   }
   @Override
   public void run() {
     try {
       System.out.println(this.name + " is running.");
       Thread.sleep(100);
     } catch (Exception e) {
       e.printStackTrace();
     }
   }
 }

실행 결과:

task-0 is running.
task-1 is running.

그 결과 스 레 드 풀 의'최대 풀 크기'와'핵심 풀 크기'는 모두 1(THREADSSIZE)는'스 레 드 탱크 가 동시에 실행 할 수 있 는 작업 의 수 는 최대 1'에 불과 하 다 는 뜻 이다.
스 레 드 풀 의 차단 대기 열 은 Array BlockingQueue 이 고 Array BlockingQueue 는 경계 가 있 는 차단 대기 열 이 며 Array BlockingQueue 의 용량 은 1 입 니 다.이것 은 또한 스 레 드 탱크 의 차단 대기 열 에 하나의 스 레 드 탱크 만 막 혀 기다 릴 수 있다 는 것 을 의미한다.
""에서 분석 한 execute()코드 에 따 르 면 스 레 드 탱크 에서 모두 2 개의 작업 이 실 행 된 것 을 알 수 있 습 니 다.첫 번 째 임 무 는 Worker 에 직접 넣 고 스 레 드 를 통 해 수행 합 니 다.두 번 째 임 무 는 차단 대기 열 에 놓 고 기 다 립 니 다.다른 임 무 는 모두 버 려 졌 다!
2.DiscardOldestPolicy 예시

 import java.lang.reflect.Field;
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.ThreadPoolExecutor.DiscardOldestPolicy;
 
 public class DiscardOldestPolicyDemo {
 
   private static final int THREADS_SIZE = 1;
   private static final int CAPACITY = 1;
 
   public static void main(String[] args) throws Exception {
 
     //      。    "     " "     "  1(THREADS_SIZE)，"   "        1(CAPACITY)。
     ThreadPoolExecutor pool = new ThreadPoolExecutor(THREADS_SIZE, THREADS_SIZE, 0, TimeUnit.SECONDS,
         new ArrayBlockingQueue<Runnable>(CAPACITY));
     //            "DiscardOldestPolicy"
     pool.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardOldestPolicy());
 
     //   10   ，           。
     for (int i = 0; i < 10; i++) {
       Runnable myrun = new MyRunnable("task-"+i);
       pool.execute(myrun);
     }
     //      
     pool.shutdown();
   }
 }
 
 class MyRunnable implements Runnable {
   private String name;
   public MyRunnable(String name) {
     this.name = name;
   }
   @Override
   public void run() {
     try {
       System.out.println(this.name + " is running.");
       Thread.sleep(200);
     } catch (Exception e) {
       e.printStackTrace();
     }
   }
 }

실행 결과:

task-0 is running.
task-9 is running.

결과 설명:"스 레 드 탱크 의 거부 정책"을 DiscardPolicy 에서 DiscardOldestPolicy 로 수정 한 후 스 레 드 탱크 에 작업 을 추가 하 는 것 이 거부 되 었 을 때 스 레 드 탱크 는 대기 열의 끝 을 막 는 작업 을 버 리 고 거 부 된 작업 을 끝 에 추가 합 니 다. 
3.AbortPolicy 예시

 import java.lang.reflect.Field;
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.ThreadPoolExecutor.AbortPolicy;
 import java.util.concurrent.RejectedExecutionException;
 
 public class AbortPolicyDemo {
 
   private static final int THREADS_SIZE = 1;
   private static final int CAPACITY = 1;
 
   public static void main(String[] args) throws Exception {
 
     //      。    "     " "     "  1(THREADS_SIZE)，"   "        1(CAPACITY)。
     ThreadPoolExecutor pool = new ThreadPoolExecutor(THREADS_SIZE, THREADS_SIZE, 0, TimeUnit.SECONDS,
         new ArrayBlockingQueue<Runnable>(CAPACITY));
     //            "    "
     pool.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
 
     try {
 
       //   10   ，           。
       for (int i = 0; i < 10; i++) {
         Runnable myrun = new MyRunnable("task-"+i);
         pool.execute(myrun);
       }
     } catch (RejectedExecutionException e) {
       e.printStackTrace();
       //      
       pool.shutdown();
     }
   }
 }
 
 class MyRunnable implements Runnable {
   private String name;
   public MyRunnable(String name) {
     this.name = name;
   }
   @Override
   public void run() {
     try {
       System.out.println(this.name + " is running.");
       Thread.sleep(200);
     } catch (Exception e) {
       e.printStackTrace();
     }
   }
 }

(한 번)실행 결과:

java.util.concurrent.RejectedExecutionException
  at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:1774)
  at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:768)
  at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:656)
  at AbortPolicyDemo.main(AbortPolicyDemo.java:27)
task-0 is running.
task-1 is running.

결과 설명:"스 레 드 탱크 의 거부 정책"을 DiscardPolicy 에서 AbortPolicy 로 수정 한 후 스 레 드 탱크 에 추가 하 는 작업 이 거부 되면 Rejected Execution Exception 을 던 집 니 다.
4.CallerRunsPolicy 예시

 import java.lang.reflect.Field;
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.ThreadPoolExecutor.CallerRunsPolicy;
 
 public class CallerRunsPolicyDemo {
 
   private static final int THREADS_SIZE = 1;
   private static final int CAPACITY = 1;
 
   public static void main(String[] args) throws Exception {
 
     //      。    "     " "     "  1(THREADS_SIZE)，"   "        1(CAPACITY)。
     ThreadPoolExecutor pool = new ThreadPoolExecutor(THREADS_SIZE, THREADS_SIZE, 0, TimeUnit.SECONDS,
         new ArrayBlockingQueue<Runnable>(CAPACITY));
     //            "CallerRunsPolicy"
     pool.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
 
     //   10   ，           。
     for (int i = 0; i < 10; i++) {
       Runnable myrun = new MyRunnable("task-"+i);
       pool.execute(myrun);
     }
 
     //      
     pool.shutdown();
   }
 }
 
 class MyRunnable implements Runnable {
   private String name;
   public MyRunnable(String name) {
     this.name = name;
   }
   @Override
   public void run() {
     try {
       System.out.println(this.name + " is running.");
       Thread.sleep(100);
     } catch (Exception e) {
       e.printStackTrace();
     }
   }
 }

(한 번)실행 결과:

task-2 is running.
task-3 is running.
task-4 is running.
task-5 is running.
task-6 is running.
task-7 is running.
task-8 is running.
task-9 is running.
task-0 is running.
task-1 is running.

결과 설명:"스 레 드 탱크 의 거부 정책"을 DiscardPolicy 에서 CallerRunsPolicy 로 수정 한 후 스 레 드 탱크 에 작업 을 추가 하 는 것 이 거부 되 었 을 때 스 레 드 탱크 는 거 부 된 작업 을"스 레 드 탱크 가 실행 중인 스 레 드"에 추가 하여 실행 합 니 다.