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();
}
}
}