并行搜索分而治之的思想

public class ConcurrentSearch {

static int[] arr;
static ExecutorService pool = Executors.newCachedThreadPool();
static final int Thread_Num = 2;
static AtomicInteger result = new AtomicInteger(-1);

public static int search(int searchValue,int begin,int end){
    int i=0;
    for(i=begin;i<end;i++){if(result.get()>0){// 默认值是小于 0 的，所以如果大于 0 就证明取到了数据
            return result.get();}
        if(arr[i]==searchValue){// 如果设置失败，证明其他线程已经找到了
            if(!result.compareAndSet(-1,i)){return result.get();
            }
            return i;
        }
    }
    return -1;
}


public static class SearchTask implements Callable<Integer>{
    int begin,end,searchValue;

    public SearchTask(int begin, int end, int searchValue) {
        this.begin = begin;
        this.end = end;
        this.searchValue = searchValue;
    }

    @Override
    public Integer call() throws Exception {int re = search(searchValue,begin,end);
        return re;
    }
}


public static int pSearch(int searchValue) throws ExecutionException, InterruptedException {
    int subArrSize = arr.length/Thread_Num+1;// 按照线程数进行分组
    List<Future<Integer>> re = new ArrayList<>();
    /** 大概思想逻辑
     * 对该段下面 for 的解释
     * 假设 arr 数组里有 20 个数字，那么 subArrSize=11
     * 第一轮循环 end=11；* 提交一个线程执行 index0 到 11 的数据
     * 第一轮循环完后，i=11 i<20
     * 开始执行第二轮
     * 第二轮循环 end=22，最终等于 19
     * 所以第二轮执行 index 11 19
     * 完了之后 i =22 所以不存在第三轮循环
     */
    for(int i = 0;i<arr.length;i+=subArrSize){
        int end =i+subArrSize;
        if(end>=arr.length){end =arr.length;}
        re.add(pool.submit(new SearchTask(searchValue,i,end)));
    }
    for(Future<Integer> fu:re){if(fu.get()>=0){return fu.get();
        }
    }
    return -1;
}
public static void main(String[] args) {}

}