多线程作加法计算

问题：多线程计算1+2+…+100，如：起四个线程，分别计算1+2+..25, 26+27+…+50, 51+52+…+75, 76+77+…100, 最后将总和相关，输出应为5050
解决方法：

• 依次调用thread.join()，主线程输出结果。注意：sum为共享变量，访问共享变量时，用synchronized同步
• 使用countDownLatch, 子线程执行完调用 countdownlatch.countdown()，主线程调用countdownlatc.await() 等待子线程执行完成，输出结果。 注意：sum为共享变量，访问共享变量时，用synchronized同步
• 使用cyclicbarrier, 子线程执行完调用 cyclicbarrier.await(), 最后都到达barrier时，输出结果。注意：sum为共享变量，访问共享变量时，用synchronized同步
• 通过线程池管理线程，用Future取得各子线程执行结果，最后将结果相加。

使用thread.join

依次调用thread.join()，主线程输出结果。注意：sum为共享变量，访问共享变量时，用synchronized同步。代码如下：

package thread;

public class ThreadAdd {
    public static int sum = 0;
    public static Object LOCK = new Object();


    public static void main(String[] args) throws InterruptedException {
        ThreadAdd add = new ThreadAdd();
        ThreadTest thread1 = add.new ThreadTest(1, 25);
        ThreadTest thread2 = add.new ThreadTest(26, 50);
        ThreadTest thread3 = add.new ThreadTest(51, 75);
        ThreadTest thread4 = add.new ThreadTest(76, 100);
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();

         thread1.join();
         thread2.join();
         thread3.join();
         thread4.join();
         System.out.println("total result: "+sum);
    }

    class ThreadTest extends Thread {
        private int begin;
        private int end;

        @Override
        public void run() {
            synchronized (LOCK) {
                for (int i = begin; i <= end; i++) {
                    sum += i;
                }
                System.out.println("from "+Thread.currentThread().getName()+" sum="+sum);
            }
        }

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

输出：
from Thread-0 sum=325
from Thread-1 sum=1275
from Thread-2 sum=2850
from Thread-3 sum=5050
total result: 5050

使用countDownLatch

子线程执行完调用 countdownlatch.countdown()，主线程调用countdownlatc.await() 等待子线程执行完成，输出结果。 注意：sum为共享变量，访问共享变量时，用synchronized同步，代码如下：

package thread;

import java.util.concurrent.CountDownLatch;

public class ThreadAddLatch {
    public static int sum = 0;
    public static Object LOCK = new Object();
    public static CountDownLatch countdown = new CountDownLatch(4);

    public static void main(String[] args) throws InterruptedException {
        ThreadAddLatch add = new ThreadAddLatch();
        ThreadTest thread1 = add.new ThreadTest(1, 25);
        ThreadTest thread2 = add.new ThreadTest(26, 50);
        ThreadTest thread3 = add.new ThreadTest(51, 75);
        ThreadTest thread4 = add.new ThreadTest(76, 100);
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();

        countdown.await();
        System.out.println("total result: "+sum);
    }

    class ThreadTest extends Thread {
        private int begin;
        private int end;

        @Override
        public void run() {
            synchronized (LOCK) {
                for (int i = begin; i <= end; i++) {
                    sum += i;
                }
                System.out.println("from "+Thread.currentThread().getName()+" sum="+sum);
            }
            countdown.countDown();
        }

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

输出：
from Thread-0 sum=325
from Thread-3 sum=2525
from Thread-2 sum=4100
from Thread-1 sum=5050
total result: 5050

使用cyclicbarrier

子线程执行完调用 cyclicbarrier.await(), 最后都到达barrier时，输出结果。注意：sum为共享变量，访问共享变量时，用synchronized同步，代码如下：

package thread;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class ThreadAddBarrier {
    public static int sum = 0;
    public static Object LOCK = new Object();

    public static CyclicBarrier cyclicbarrier = new CyclicBarrier(4,
            new Runnable() {
                public void run() {
                    System.out.println(sum);
                }
            });

    public static void main(String[] args) throws InterruptedException {
        ThreadAddBarrier add = new ThreadAddBarrier();
        ThreadTest thread1 = add.new ThreadTest(1, 25);
        ThreadTest thread2 = add.new ThreadTest(26, 50);
        ThreadTest thread3 = add.new ThreadTest(51, 75);
        ThreadTest thread4 = add.new ThreadTest(76, 100);
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();

    }

    class ThreadTest extends Thread {
        private int begin;
        private int end;

        @Override
        public void run() {
            synchronized (LOCK) {
                for (int i = begin; i <= end; i++) {
                    sum += i;
                }
                System.out.println("from "+Thread.currentThread().getName()+" sum="+sum);
            }
            try {
                cyclicbarrier.await();
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
        }

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

输出：
from Thread-0 sum=325
from Thread-2 sum=1900
from Thread-1 sum=2850
from Thread-3 sum=5050
5050

通过线程池管理线程

用Future取得各子线程执行结果，最后将结果相加。代码如下：

package thread;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ThreadAddFuture {
    public static  List futureList=new ArrayList();
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        int sum=0;
        ThreadAddFuture add = new ThreadAddFuture();
        ExecutorService pool=Executors.newFixedThreadPool(4);

        for(int i=1;i<=76;){
            ThreadTest thread=add.new ThreadTest(i,i+24);
            Future future=pool.submit(thread);
            futureList.add(future);
            i+=25;
        }

        if(futureList!=null && futureList.size()>0){
            for(Future future:futureList){
               sum+=(Integer)future.get();
            }
        }
        System.out.println("total result: "+sum);
        pool.shutdown();
    }

    class ThreadTest implements Callable {
        private int begin;
        private int end;
        public int sum=0;

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

        @Override
        public Integer call() throws Exception {
            for(int i=begin;i<=end;i++){
                sum+=i;
            }
            System.out.println("from "+Thread.currentThread().getName()+" sum="+sum);
            return sum;
        }
    }
}

输出：
from pool-1-thread-3 sum=1575
from pool-1-thread-1 sum=325
from pool-1-thread-2 sum=950
from pool-1-thread-4 sum=2200
total result: 5050