Java 多线程计算1到1000的和

public class Test {
    public  static  void main(String[] args) throws InterruptedException {
        MTC mtc = new MTC();
        for(int i = 0; i < 10; i++){
            new Thread(mtc).start();
            Thread.sleep(500);
        }
        while(mtc.threadNums > 0) Thread.sleep(50);
        System.out.println("---------------------" + mtc.sum);
    }
}

class MTC implements Runnable{
    volatile int step;
    volatile int sum;
    volatile int threadNums;

    public MTC(){
        step = 0;
        sum = 0;
        threadNums = 0;
    }

    private synchronized int getStep(){
        step++;
        threadNums++;
        return step;
    }

    private synchronized void finish(){
        threadNums--;
    }

    private  synchronized void addSum(int t){
        sum += t;
    }

    public void computing() throws InterruptedException {
        int begin = (getStep() - 1) * 100 + 1;
        int end = begin + 100;
        int tSum = 0;
        System.out.println(Thread.currentThread().getName() + "\tAim: " + "from " + begin + " to " + (end - 1));
        for(int i = begin; i < end; ++i){
            tSum += i;
            Thread.sleep(80);
            System.out.println(Thread.currentThread().getName() + ": " + (i - begin) + "%");
        }
        System.out.println(Thread.currentThread().getName() + " sum: " + tSum);
        addSum(tSum);
        finish();
    }

    @Override
    public void run() {
        try{
            computing();
        }
        catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

基于线程池实现

Executor

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

public class Test {
    public  static  void main(String[] args) throws InterruptedException, ExecutionException {
        ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newCachedThreadPool();
        List<Future<Integer>> results = new ArrayList<>();
        for(int i = 0; i < 10; i++){
            MTC mtc = new MTC(i*100+1, (i+1)*100);
            Future<Integer> result = executor.submit(mtc);
            results.add(result);
        }

        while(executor.getCompletedTaskCount() < results.size()){
            Thread.sleep(50);
        }

        int total = 0;
        for(Future<Integer> sum : results){
            int t = sum.get();
            total += t;
            System.out.println("partSum: " + t);
        }
        System.out.println("Sum: " + total);
        executor.shutdown();
    }
}

class MTC implements Callable{
    int begin, end;

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

    public Integer computing() throws InterruptedException {
        int sum = 0;
        System.out.println(Thread.currentThread().getName() + "\tAim: " + "from " + begin + " to " + end);
        for(int i = begin; i <= end; ++i){
            sum += i;
            Thread.sleep(100);
        }
        return sum;
    }

    @Override
    public Object call() throws Exception {
        try{
            return computing();
        }
        catch (InterruptedException e){
            e.printStackTrace();
            return 0;
        }
    }
}

ForkJoinPool

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;

public class Test {
    public  static  void main(String[] args) throws ExecutionException, InterruptedException {
        ForkJoinPool pool = new ForkJoinPool();
        MTC mtc = new MTC(1, 1000);
        ForkJoinTask<Integer> result = pool.submit(mtc);

        while (!mtc.isDone()){
            System.out.printf("Main: Thread Count: %d\n",pool.getActiveThreadCount());
            System.out.printf("Main: Paralelism: %d\n",pool.getParallelism());
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println(result.get());
    }
}

class MTC extends RecursiveTask<Integer>{
    int begin, end;

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

    @Override
    protected Integer compute() {
        if(end - begin + 1 > 100){
            int mid = (end + begin) / 2;
            MTC sub1 = new MTC(begin, mid);
            MTC sub2 = new MTC(mid + 1, end);
//            sub1.fork();
//            sub2.fork();此种写法相当于另外将任务分成两部分，自己只等这两部分结果
            invokeAll(sub1, sub2);//此种写法相当于另外将任务分成两部分，自己做其中一部分sub1
            return sub1.join() + sub2.join();
        }
        else{
            int sum = 0;
            for(int i = begin; i <=end; ++i){
                sum += i;
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return sum;
        }
    }
}

CountDownLatch

import java.util.concurrent.CountDownLatch;

public class Test {
    public  static  void main(String[] args){
        int n = 10;
        int[] result = new int[n];
        CountDownLatch latch = new CountDownLatch(n);

        for(int i = 0; i < n; i++){
                new Thread(new subTask(i * 100 + 1, (i + 1)*100, latch, i, result)).start();
        }

        try{
            latch.await();
            int sum = 0;
            for(int e : result){
                sum += e;
            }
            System.out.println(sum);
        }
        catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

class  subTask implements Runnable{
    private int begin, end;
    private CountDownLatch latch;
    private int n;
    private int[] result;

    public subTask(int begin, int end, CountDownLatch latch, int n, int[] result){
        this.begin = begin;
        this.end = end;
        this.latch = latch;
        this.n = n;
        this.result = result;
    }

    @Override
    public void run() {
        try {
            int sum = 0;
            for(int i = begin; i <= end; i++){
                sum += i;
            }
            result[n] = sum;
            latch.countDown();
        }
        catch (Exception e){
            e.printStackTrace();
        }
    }
}

CyclicBarrier

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.atomic.AtomicInteger;

public class Test {
    public  static  void main(String[] args){
        int n = 10;
        int[] result = new int[n];
        CyclicBarrier cyclicBarrier = new CyclicBarrier(n, () -> {
            int sum = 0;
            for(int i = 0; i < n; i++){
                sum += result[i];
            }
            System.out.println(sum);
        });

        for(int i = 0; i < n; i++){
                new Thread(new subTask(i * 100 + 1, (i + 1)*100, cyclicBarrier, i, result)).start();
        }

    }
}

class  subTask implements Runnable{
    private int begin, end;
    private CyclicBarrier cyclicBarrier;
    private int n;
    private int[] result;

    public subTask(int begin, int end, CyclicBarrier cyclicBarrier, int n, int[] result){
        this.begin = begin;
        this.end = end;
        this.cyclicBarrier = cyclicBarrier;
        this.n = n;
        this.result = result;
    }

    @Override
    public void run() {
        try {
            int sum = 0;
            for(int i = begin; i <= end; i++){
                sum += i;
            }
            result[n] = sum;
            cyclicBarrier.await();
        }
        catch (Exception e){
            e.printStackTrace();
        }
    }
}