포크-조인 프레임 워 크

포크-조인 프레임 워 크
포크 와 Join 은 자바 1.7 이 제공 하 는 정형 집행 에 사용 되 는 프레임 워 크 로 큰 임 무 를 여러 개의 작은 임무 로 나 누 어 수행 하고 작은 임무 수행 결 과 를 큰 임무 의 프레임 워 크 로 모 았 다.말 그대로 포크 가 큰 임 무 를 여러 개의 작은 임무 로 나 누 는 것 이다.Join 은 작은 임 무 를 합 쳐 큰 임 무 를 얻 는 것 이다.작업 절취 알고리즘 을 사용 하 다.
작업 절취 알고리즘
다른 스 레 드 에서 작업 임 무 를 가 져 오 는 알고리즘작업 절취 알고리즘 을 사용 하면 우리 가 큰 임 무 를 여러 개의 작은 임무 로 나 누 는 데 편리 할 수 있다.스 레 드 간 의 경쟁 을 줄 이기 위해 서 우 리 는 모든 임 무 를 각각 다른 대기 열 에 넣 고 스 레 드 와 대기 열 이 일일이 대응 하지만 일부 스 레 드 는 먼저 임 무 를 완성 합 니 다.이것 은 자신의 임 무 를 완성 한 스 레 드 가 다른 스 레 드 를 도와 임 무 를 수행 하 는 것 입 니 다.이것 은 그들 이 같은 대기 열 에 방문 하 는 것 입 니 다.스 레 드 를 훔 치 는 것 과 스 레 드 를 훔 치지 않 는 경쟁 을 줄 이기 위해 서 우 리 는 보통 쌍 단 대기 열 을 사용한다.도 둑 맞 은 스 레 드 는 양 끝 대기 열의 머리 에서 작업 을 영원히 가 져 옵 니 다.스 레 드 는 양 끝 대기 열의 끝 에서 내용 을 영원히 가 져 옵 니 다.
장점:라인 을 충분히 이용 하여 병행 계산 을 하여 라인 간 의 경쟁 을 줄 이 는 것 이다.단점 은 경쟁 이 존재 하 는 것 이다.예 를 들 어 대기 열 에 하나의 작업 만 있 을 때 더 많은 시스템 자원 을 소모 하여 더 많은 스 레 드 를 만 드 는 것 이다.
제한:

포크/Join 을 사용 할 때 포크 와 Join 만 동기 화 작업 을 할 수 있 고 다른 메커니즘 을 사용 할 때 작업 라인 은 다른 작업 을 할 수 없습니다.예 를 들 어 포크/Join 프레임 워 크 에서 불면 증 을 사 용 했 으 면 수면 중 에 다른 조작 을 할 수 없습니다

포크/Join 을 사용 하 는 스 레 드 는 io 작업 을 수행 할 수 없습니다

4.567917.검사 이상 을 던 져 서 는 안 되 고 필요 한 코드 를 사용 하여 그들 을 검사 해 야 한다
데모 코드

@Slf4j
public class ForkJoinTaskExample extends RecursiveTask {

    public static final int threshold = 2;
    private int start;
    private int end;

    public ForkJoinTaskExample(int start, int end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        int sum = 0;

        //            
        boolean canCompute = (end - start) <= threshold;
        if (canCompute) {
            for (int i = start; i <= end; i++) {
                sum += i;
            }
        } else {
            //         ，           
            int middle = (start + end) / 2;
            ForkJoinTaskExample leftTask = new ForkJoinTaskExample(start, middle);
            ForkJoinTaskExample rightTask = new ForkJoinTaskExample(middle + 1, end);

            //      
            leftTask.fork();
            rightTask.fork();

            //              
            int leftResult = leftTask.join();
            int rightResult = rightTask.join();

            //      
            sum = leftResult + rightResult;
        }
        return sum;
    }

    public static void main(String[] args) {
        ForkJoinPool forkjoinPool = new ForkJoinPool();

        //        ，  1+2+3+4
        ForkJoinTaskExample task = new ForkJoinTaskExample(1, 100);

        //      
        Future result = forkjoinPool.submit(task);

        try {
            log.info("result:{}", result.get());
        } catch (Exception e) {
            log.error("exception", e);
        }
    }
}