자바 및 패키지 3 개 실 용적 인 병렬 스 레 드 보조 클래스

1.Count Downlatch 는 이 를 이용 하여 유사 한 카운터 의 기능 을 실현 할 수 있다.예 를 들 어 하나의 작업 A 가 있 습 니 다.다른 4 개의 작업 이 실 행 된 후에 야 실 행 될 수 있 습 니 다.이 때 는 Count Downlatch 를 이용 하여 이 기능 을 실현 할 수 있 습 니 다.Count Downlatch 류 는 하나의 구조 만 제공 합 니 다:Public Count Downlatch(int count){};/매개 변수 count 를 계수 값 으로 합 니 다.
그리고 다음 세 가지 방법 은 CountDownlatch 클래스 에서 가장 중요 한 방법 입 니 다:Public void await()throws Interrupted Exception{};/await()방법 을 호출 하 는 스 레 드 가 걸 립 니 다.count 값 이 0 이 될 때 까지 기다 리 고 있 습 니 다.Public boolean await(long timeout,TimeUnit unit)throws Interrupted Exception{};/await()와 유사 합 니 다.일정 시간 을 기다 린 후에 count 값 이 0 으로 변 하지 않 으 면 Public void countDown(){}을 계속 실행 합 니 다./count 값 을 1 감소
public class countDownlatch{/예 를 들 어 하나의 퀘 스 트 A 가 있 습 니 다.다른 4 개의 퀘 스 트 가 실 행 된 후에 야 Public static void main(String[]args){/**4 가 퀘 스 트 수 보다 많 으 면 2 개의 퀘 스 트 를 수행 한 후에 도 깨 어 날 때 까지 기 다 립 니 다.1 이 퀘 스 트 수 보다 작 으 면 2 개의 퀘 스 트 를 수행 합 니 다.*/final CountDownLatch latch = new CountDownLatch(2);

    //  1
    new Thread() {
        @Override
        public void run() {
            try {
                System.out.println("   " + Thread.currentThread().getName() + "    ");
                Thread.sleep(3000);
                System.out.println("   " + Thread.currentThread().getName() + "    ");
                latch.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }.start();

    //  2
    new Thread() {
        @Override
        public void run() {
            try {
                System.out.println("   " + Thread.currentThread().getName() + "    ");
                Thread.sleep(3000);
                System.out.println("   " + Thread.currentThread().getName() + "    ");
                latch.countDown();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }.start();

    try {
        System.out.println("  2        ...");
        latch.await();//  await()         ，      count  0     
        System.out.println("2          ");
        System.out.println("       ");
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

}
2.Cyclic Barrier 용법 은 이 를 통 해 한 스 레 드 를 특정한 상태 로 기다 린 후에 모두 동시에 실행 할 수 있 습 니 다.리 턴 이 라 고 하 는 것 은 모든 대기 스 레 드 가 풀 려 난 후에 Cyclic Barrier 가 다시 사용 할 수 있 기 때 문 입 니 다.우 리 는 잠시 이 상 태 를 barrier 라 고 부 릅 니 다.await()방법 을 호출 한 후에 스 레 드 는 barrier 에 있 습 니 다.CyclicBarrier 는 2 개의 구조 기 를 제공 합 니 다:Public CyclicBarrier(int parties,Runnable barrier Action){}
public CyclicBarrier(int parties){}매개 변수 parties 는 몇 개의 스 레 드 나 작업 을 barrier 상태 로 기다 리 게 하 는 지 말 합 니 다.매개 변수 barrierAction 은 이 스 레 드 가 barrier 상태 에 이 르 렀 을 때 실 행 될 내용 입 니 다.
그리고 Cyclic Barrier 에서 가장 중요 한 방법 은 await 방법 입 니 다.2 개의 리 셋 버 전이 있 습 니 다.Public int await()throws Interrupted Exception,BrokenBarrier Exception{};public int await(long timeout, TimeUnit unit)throws InterruptedException,BrokenBarrierException,TimeoutException { }; 첫 번 째 버 전 은 현재 스 레 드 를 걸 고 모든 스 레 드 가 barrier 상태 에 도달 할 때 까지 후속 작업 을 수행 하 는 데 자주 사용 합 니 다.
두 번 째 버 전 은 이 스 레 드 를 일정한 시간 까지 기다 리 게 하 는 것 입 니 다.만약 에 스 레 드 가 barrier 상태 에 도착 하지 않 으 면 barrier 에 도착 하 는 스 레 드 로 하여 금 후속 임 무 를 수행 하 게 합 니 다.
package com.ky.kafka;
import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException;
/**

만약 에 몇 개의 스 레 드 가 데 이 터 를 작성 하 는 작업 을 하고 모든 스 레 드 가 데 이 터 를 작성 하 는 작업 을 마 친 후에 야 이 스 레 드 는 뒤의 일 을 계속 할 수 있 습 니 다.이때 CyclicBarrier/Public class cyclicBarrier{Public static void main(String[]args){int N=4;/CyclicBarrier barrier = new CyclicBarrier(N); /* * 모든 스 레 드 에 기록 작업 이 끝 난 후에 추가 작업 을 하려 면 CyclicBarrier 에 Runnable 인 자 를 제공 할 수 있 습 니 다*네 개의 스 레 드 가 barrier 상태 에 도착 하면 네 개의 스 레 드 에서 하나의 스 레 드 를 선택 하여 Runnable*/CyclicBarrier barrier=new CyclicBarrier(N,new Runnable(){@Override public void run(){System.out.println("현재 스 레 드"+Thread.currentThread().getName();});for (int i = 0; i < N; i++) new Writer(barrier).start(); } /**
4.567917.모든 기록 스 레 드 가 데 이 터 를 작성 하 는 작업 을 마 친 후에 다른 스 레 드 가 기록 되 기 를 기다 리 고 있 습 니 다

모든 스 레 드 스 레 드 기록 작업 이 끝 난 후에 모든 스 레 드 는 후속 작업 을 계속 진행 합 니 다*/static class Writer extends Thread{private CyclicBarrier cyclicBarrier;public Writer(CyclicBarrier cyclicBarrier) { this.cyclicBarrier = cyclicBarrier; } @override public void run(){System.out.println("스 레 드"+Thread.currentThread().getName()+"데 이 터 를 쓰 고 있 습 니 다...");try { Thread.sleep(5000); //수면 으로 데 이 터 를 모 의 기록 하 는 작업 System.out.println("스 레 드"+Thread.current Thread().getName()+"데 이 터 를 기록 하고 다른 스 레 드 가 끝 날 때 까지 기 다 립 니 다");/cyclicBarrier.await(); try{//앞의 세 스 레 드 가 모두 barrier 에 도달 한 후에 지 정 된 시간 을 기 다 렸 는데 네 번 째 스 레 드 가 barrier 에 도달 하지 않 은 것 을 발견 하면 이상 을 던 지고 뒤의 작업 을 계속 수행 합 니 다 cyclicBarrier.awat(2000,TimeUnit.MILLISECONDS).}catch (TimeoutException e) { e.printStackTrace(); } } catch (InterruptedException e) { e.printStackTrace(); } catch (BrokenBarrierException e) { e.printStackTrace(); } System.out.println("모든 스 레 드 기록 완료,다른 작업 계속 처리...");}}

Semaphore 용법:Semaphore 는 신 호 량 이라는 뜻 으로 번역 되 었 습 니 다.Semaphore 는 동시에 접근 하 는 라인 개 수 를 제어 할 수 있 습 니 다.acquire()를 통 해 허 가 를 받 을 수 있 습 니 다.없 으 면 기다 리 고 release()는 허 가 를 내 립 니 다.public Semaphore(int permits){/매개 변수 permits 는 허가 수 를 표시 합 니 다.동기 화=new NonfairSync(permits)에 접근 할 수 있 는 스 레 드 를 동시에 허용 합 니 다.}public Semaphore(int permits,boolean fair){//이것 은 공평 한 지 아 닌 지 를 나타 내 는 인자 fair 가 하나 더 있 습 니 다.즉,오래 기다 릴 수록 허가 sync=(fair)를 먼저 받 습 니까?new FairSync(permits) : new NonfairSync(permits); }
다음은 Semaphore 클래스 에서 중요 한 몇 가지 방법 을 말씀 드 리 겠 습 니 다.우선 acquire(),release()방법:public void acquire()throws Interrupted Exception{}/허 가 를 받 은 public void acquire(int permits)throws Interrupted Exception{}/허 가 를 받 은 public void release(){}/허 가 를 받 은 public void release(int permits){}//허 가 를 받 은 permits 개 허가
acquire()는 허 가 를 받 는 데 사용 되 며,허가 없 이 얻 을 수 있다 면 허 가 를 받 을 때 까지 기다 릴 것 입 니 다.release()는 허 가 를 석방 하 는 데 쓰 인 다.석방 허 가 를 받 기 전에 먼저 허 가 를 받 아야 함 을 주의 하 세 요.이 네 가지 방법 은 모두 막 힐 수 있 으 며,즉시 실행 결 과 를 얻 으 려 면 다음 과 같은 몇 가지 방법 을 사용 할 수 있다.
public boolean tryAcquire() { }; //허 가 를 받 으 려 고 시도 합 니 다.성공 하면 즉시 true 로 돌아 갑 니 다.실패 하면 false Public boolean try Acquire(long timeout,TimeUnit unit)throws Interrupted Exception{};/허 가 를 받 으 려 고 시도 합 니 다.지정 한 시간 안에 성공 하면 즉시 true 로 돌아 갑 니 다.그렇지 않 으 면 false Public boolean try Acquire(int permits){}로 돌아 갑 니 다./permits 허 가 를 받 으 려 고 시도 합 니 다.성공 하면 즉시 true 로 돌아 갑 니 다.실패 하면 false Public boolean try Acquire(int permits,long timeout,TimeUnit unit)throws Interrupted Exception{};/permits 허 가 를 받 으 려 고 시도 합 니 다.지정 한 시간 안에 성공 하면 즉시 true 로 돌아 갑 니 다.그렇지 않 으 면 false 로 돌아 갑 니 다.
또한 availablePermits()방법 을 통 해 사용 가능 한 허가 수 를 얻 을 수 있다.
package com.ky.kafka;
import java.util.concurrent.Semaphore;
/**
4.567917.만약 에 한 공장 에 5 대의 기계 가 있 지만 8 명의 노동자 가 있 고 한 대의 기 계 는 한 명의 노동자 만 사용 할 수 있 으 며 다 사용 해 야 다른 노동자 들 이 계속 사용 할 수 있다.그러면 우 리 는 Semaphore 를 통 해 실현 할 수 있다

Semaphore 는 동시에 방문 하 는 스 레 드 개 수 를 제어 할 수 있 습 니 다.acquire()를 통 해 허 가 를 받 을 수 있 습 니 다.없 으 면 기다 리 고 release()는 허 가 를 풀 수 있 습 니 다.*/public class semaphore { public static void main(String[] args) { int n = 8;//일꾼 8 개 final Semaphore semaphore=new Semaphore(5);/기계 5 개 for(int i=0;i < n; i++){//8 개의 스 레 드 new Worker(semaphore).start();}static class Worker extends Thread { private Semaphore semaphore;

 public Worker(Semaphore semaphore) {
     this.semaphore = semaphore;
 }

 @Override
 public void run() {
     try {
         semaphore.acquire();//      
         System.out.println("           ...");
         Thread.sleep(2000);
         System.out.println("       ");
         semaphore.release();//        
         System.out.println(semaphore.availablePermits());//      
     } catch (InterruptedException e) {
         e.printStackTrace();
     }
 }

} }

4.위의 세 가지 보조 류 를 정리 합 니 다.1)Count Downlatch 와 Cyclic Barrier 는 모두 스 레 드 간 의 기다 림 을 실현 할 수 있 습 니 다.다만 이들 의 중심 은 다 릅 니 다.
CountDownlatch 는 보통 특정한 스 레 드 A 에서 여러 개의 다른 스 레 드 가 임 무 를 수행 한 후에 야 실 행 됩 니 다.
한편,Cyclic Barrier 는 보통 한 스 레 드 가 서로 특정한 상태 로 기다 린 다음 에 이 스 레 드 를 동시에 실행 하 는 데 사 용 됩 니 다.
또한 Count Downlatch 는 다시 사용 할 수 없고 Cyclic Barrier 는 다시 사용 할 수 있 습 니 다.
2)Semaphore 는 사실 자물쇠 와 유사 합 니 다.그룹 자원 에 대한 접근 권한 을 제어 하 는 데 사 용 됩 니 다.