2022/5/15-作业

1. ForkJoinPool的理解

ForkJoinPool充分利用多cpu的优势，把一个任务拆分成多个“小任务”，把多个“小任务”放到多个处理器上并行执行；当多个“小任务”执行完成之后，再将这些执行结果合并起来。感觉有点像二分法。

ForkJoinPool 的工作特点 是“工作窃取”，何为工作窃取，ForkJoinPool底层维护着一个双端队列，当一个线程的任务队列执行完毕后，其他线程的任务队列还没有执行完毕，这时，已经执行完毕的线程就会到另一个线程的双端任务队列的尾部去偷取任务执行。
 

2. CompletableFutrue的理解

CompletableFuture，提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，提供了函数式编程的能力，可以通过回调的方式处理计算结果，并且提供了转换和组合CompletableFuture的方法。

3. 归并排序？多线程版本？

单线程版

import java.util.Random;
 
public class Main {
    public static void main(String[] args) {
        int length = 1000;
        int[] data = (new Data(length)).getData();
        printArr(data);
        System.out.println();
        mergeSort(data);
        printArr(data);
    }
 
    //递归
    private static void mergeSort(int[] nums,int[] tmp,int left,int right){
        if(left<right){
            int center = (left+right)/2;
            mergeSort(nums,tmp,left,center);
            mergeSort(nums,tmp,center+1,right);
            merge(nums,tmp,left,center+1,right);
        }
    }
 
    //合并
    private static void merge(int[] nums,int[] tmp,int leftPos, int rightPos, int rightEnd){
        int leftEnd = rightPos-1;
        int tmpPos = leftPos;
        int numElements = rightEnd - leftPos + 1;
    
        while(leftPos<=leftEnd&&rightPos<=rightEnd){
            if(nums[leftPos]<nums[rightPos])
                tmp[tmpPos++]=nums[leftPos++];
            else 
                tmp[tmpPos++]=nums[rightPos++];
        }
        while(leftPos<=leftEnd)
            tmp[tmpPos++]=nums[leftPos++];
        
        while(rightPos<=rightEnd)
            tmp[tmpPos++]=nums[rightPos++];
    
        for(int i = 0;i<numElements;i++,rightEnd--)
            nums[rightEnd]=tmp[rightEnd];
    }
    public static void mergeSort(int[] nums){
        int[] tmp = new int[nums.length];
        mergeSort(nums,tmp,0,nums.length-1);
    }
    
    //打印
    public static void printArr(int[] arr) {
        for(int i : arr){
            System.out.print(i+" ");
        }
    }
 
 
}
 
 
/**
 * 产生随机数据
 */
class Data{
    int length;
    int[] data;
 
    public Data(int length){
        this.length = length;
        data = new int[length];
    }
 
    public int[] getData(){
 
        Random random = new Random(System.currentTimeMillis());
        for(int i=0;i<length;i++){
            data[i]=random.nextInt(2*length);
        }
        return data;
    }
 
 
}

多线程版

import java.util.Random;
import java.util.concurrent.CountDownLatch;
 
public class Main {
    public static void main (String[] args) throws InterruptedException {
        int length = 1000;
        int[] data = (new Data(length)).getData();
        printArr(data);
        System.out.println();
        // mergeSort(data);
        //在这里修改
        int center = data.length/2;
 
        int[] tmp = new int[data.length];
        CountDownLatch latch = new CountDownLatch(2);//CountDownLatch能够使一个线程在等待另            
                                                    //外一些线程完成各自工作之后，再继续执行
        new Thread(new Runnable(){
        
            @Override
            public void run() {
                mergeSort(data,tmp,0,center);
                latch.countDown();
            }
        }).start();
 
        new Thread(new Runnable(){
        
            @Override
            public void run() {
                mergeSort(data,tmp,center+1,data.length-1);
                latch.countDown();
            }
        }).start();
 
        latch.await();
 
        merge(data, tmp, 0, center+1, data.length-1);
 
        printArr(data);
        System.out.println();
        verify(data);
    }
 
    //递归
    private static void mergeSort(int[] nums,int[] tmp,int left,int right){
        if(left<right){
            int center = (left+right)/2;
            mergeSort(nums,tmp,left,center);
            mergeSort(nums,tmp,center+1,right);
            merge(nums,tmp,left,center+1,right);
        }
    }
 
    //合并
    private static void merge(int[] nums,int[] tmp,int leftPos, int rightPos, int rightEnd){
        int leftEnd = rightPos-1;
        int tmpPos = leftPos;
        int numElements = rightEnd - leftPos + 1;
    
        while(leftPos<=leftEnd&&rightPos<=rightEnd){
            if(nums[leftPos]<nums[rightPos])
                tmp[tmpPos++]=nums[leftPos++];
            else 
                tmp[tmpPos++]=nums[rightPos++];
        }
        while(leftPos<=leftEnd)
            tmp[tmpPos++]=nums[leftPos++];
        
        while(rightPos<=rightEnd)
            tmp[tmpPos++]=nums[rightPos++];
    
        for(int i = 0;i<numElements;i++,rightEnd--)
            nums[rightEnd]=tmp[rightEnd];
    }
    public static void mergeSort(int[] nums){
        int[] tmp = new int[nums.length];
        mergeSort(nums,tmp,0,nums.length-1);
    }
    
    //打印
    public static void printArr(int[] arr) {
        for(int i : arr){
            System.out.print(i+" ");
        }
    }
    
    public static void verify(int[] nums) {
        for(int i=0;i<nums.length-1;i++){
            if(nums[i]>nums[i+1]){
                System.out.println("排序失败");
                return;
            } 
 
        }
        System.out.println("排序成功");
    }
    
 
 
}
 
 
/**
 * 产生随机数据
 */
class Data{
    int length;
    int[] data;
 
    public Data(int length){
        this.length = length;
        data = new int[length];
    }
 
    public int[] getData(){
 
        Random random = new Random(System.currentTimeMillis());
        for(int i=0;i<length;i++){
            data[i]=random.nextInt(2*length);
        }
        return data;
    }
 
}·