通过多个线程计算1到50000相加之和-java篇

1.通过cyclicBarrier来计算，原则是启动五个线程，然后等待都完成，然后输出结果

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @Author: 张小乙
 * @Date: 2019/2/4 15:29
 * @Version: 1.0
 * @Description: 1.0
 */
public class CyclicBarrierTest {

    public final static int[] SUMS_ARRAY = new int[5];


    public static class Number implements Runnable {

        private int[] array;

        private int start;

        private int end;

        private int batch;

        private CyclicBarrier cyclicBarrier;

        public Number(int[] array, int start, int end, int batch, CyclicBarrier cyclicBarrier) {
            this.array = array;
            this.start = start;
            this.end = end;
            this.batch = batch;
            this.cyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run() {
            int sums = 0;
            for (int i = start; i < end; i++) {
                sums += array[i];
            }
            SUMS_ARRAY[batch] = sums;
            System.out.println(Thread.currentThread().getName() + ",SUMS_ARRAY:" + sums);
            try {
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        int[] array = new int[50000];
        for (int i = 0; i < array.length; i++) {
            array[i] = i;
        }

        AtomicInteger sums = new AtomicInteger(0);
        AtomicBoolean isFinish = new AtomicBoolean(false);
        CyclicBarrier cyclicBarrier = new CyclicBarrier(5, () -> {
            for (int i = 0; i < SUMS_ARRAY.length; i++) {
                sums.addAndGet(SUMS_ARRAY[i]);
            }
            isFinish.set(true);
            System.out.println("总和为：" + sums);
        });

        int corePoolSize = 5;
        int maximumPoolSize = 5;
        long keepAliveTime = 0l;
        final RejectedExecutionHandler defaultHandler =
                new ThreadPoolExecutor.AbortPolicy();

        ExecutorService executorService = new ThreadPoolExecutor(corePoolSize,
                                                                 maximumPoolSize,
                                                                 keepAliveTime,
                                                                 TimeUnit.SECONDS,
                                                                 new LinkedBlockingQueue<>(),
                                                                 Executors.defaultThreadFactory(), defaultHandler);
        for (int i = 0; i < 5; i++) {
            Number number = new Number(array, (i) * 10000, (i + 1) * 10000 - 1, i, cyclicBarrier);
            executorService.execute(number);
        }

        while (true) {
            if (isFinish.get()) {
                System.out.println("总和2为：" + sums);
                break;
            }
        }
    }
}

2.通过Callable与Future方法

/**
 * @Author: 张小乙
 * @Date: 2019/2/12 15:22
 * @Version: 1.0
 * @Description: 1.0
 */
public class FutureTest {

    public final static int[] SUMS_ARRAY = new int[5];


    public static class Number implements Callable<Integer> {

        private int[] array;

        private int start;

        private int end;

        private int batch;

        public Number(int[] array, int start, int end, int batch) {
            this.array = array;
            this.start = start;
            this.end = end;
            this.batch = batch;
        }

        @Override
        public Integer call(){
            int sums = 0;
            for (int i = start; i < end; i++) {
                sums += array[i];
            }
            SUMS_ARRAY[batch] = sums;
            System.out.println(Thread.currentThread().getName() + ",SUMS_ARRAY:" + sums);
            return sums;
        }
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException, TimeoutException {
        int[] array = new int[50000];
        for (int i = 0; i < array.length; i++) {
            array[i] = i;
        }

        int corePoolSize = 5;
        int maximumPoolSize = 5;
        long keepAliveTime = 0l;
        final RejectedExecutionHandler defaultHandler = new ThreadPoolExecutor.AbortPolicy();

        ExecutorService executorService = new ThreadPoolExecutor(corePoolSize,
                                                                 maximumPoolSize,
                                                                 keepAliveTime,
                                                                 TimeUnit.SECONDS,
                                                                 new LinkedBlockingQueue<>(),
                                                                 Executors.defaultThreadFactory(),
                                                                 defaultHandler);
        List<Future<Integer>> futureList = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            Number number = new Number(array, (i) * 10000, (i + 1) * 10000 - 1, i);
            Future<Integer> future = executorService.submit(number);
            futureList.add(future);
        }

        Integer sums = 0;
        for(Future<Integer> future : futureList){
            Integer amount = future.get(2000,TimeUnit.MILLISECONDS);
            sums+= amount;
        }
        System.out.println("房款总金额为sums:" + sums);
    }
}