Java使用5个线程计算数组之和-eolink官网

Java使用5个线程计算数组之和

前言

之前写过多线程累加计数，原理跟本篇类似，传送门

累加计数比计算数组之和逻辑稍微简单一点，如果对于这块不熟悉的，可以先看下累加计数。

基本思想已经在之前那篇文章里写过了，这里就直接贴代码了。

这里分别通过自己创建线程来实现功能，还有通过线程池来实现功能。思想都差不多。只是代码写法略有不同。仅供参考。

代码一：

五个线程交替累加计算数组之和，这种方法其实不如单线程直接累加快，因为交替累加需要前一个线程计算的结果。

package test;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class FiveThreadCount {

private int count=0;

private int[] arr={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28};

private int j=0;

//定义一个任务，关键点所在

private class MyThread extends Thread{

@Override

public void run() {

super.run();

while(j

{

synchronized (MyThread.class) {

if(j>=arr.length){

return;

}

count+=arr[j++];

try {

Thread.sleep(100);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName());

}

//方法一

public void test1(){

for(int i=0;i<5;i++){

new MyThread().start();

}

try {

Thread.sleep(10000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println(count);

}

//方法二

public void test2(){

Thread myThread=new MyThread();

for(int i=0;i<5;i++){

new Thread(myThread).start();

}

try {

Thread.sleep(10000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println(count);

}

//方法一的线程池实现版

public void test3(){

ExecutorService service=Executors.newCachedThreadPool();

for(int i=0;i<5;i++){

service.execute(new MyThread());

}

try {

Thread.sleep(10000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println(count);

}

//方法二的线程池实现版

public void test4(){

ExecutorService service=Executors.newCachedThreadPool();

Thread myThread=new MyThread();

for(int i=0;i<5;i++){

service.execute(myThread);

}

try {

Thread.sleep(10000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println(count);

}

上边代码中，用到了sleep方法的原因，sleep(100)是为了让其他线程有时间执行任务，如果不sleep的话，有可能一个线程就全部执行完了。最后的sleep（10000）是为了等所有线程执行完后，打印最后的计算结果。

代码二：

将数组分为5等分，让每个线程计算自己负责的那份，并发计算，最后汇总结果。这种方式比代码一速度会快些。因为线程独立计算，不依赖其他线程的结果。最后几个线程将总数累加即可。

方式一：

使用Callable，FutureTask方式，来实现代码：

package test;

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.FutureTask;

public class FiveThreadCount2 {

private int[] arr={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28};

private int total=0;

public void test() throws InterruptedException, ExecutionException{

ExecutorService service=Executors.newFixedThreadPool(5);

int length=arr.length;

for(int j=0;j

FutureTask task;

if( (j+(length/5))

task=new FutureTask(new MyCallable(arr, j, j+(length/5)));

}else{

task=new FutureTask(new MyCallable(arr, j, length));

}

service.execute(task);

total+=task.get();

}

service.shutdown();

System.out.println(total);

}

public class MyCallable implements Callable{

int[] arr;

int startIndex;

int endIndex;

public MyCallable(int[] arr,int startIndex,int endIndex){

this.arr=arr;

this.startIndex=startIndex;

this.endIndex=endIndex;

}

@Override

public Integer call() throws Exception {

int sum=0;

for(int i=startIndex;i

sum+=arr[i];

}

System.out.println(Thread.currentThread().getName());

return sum;

}

这个方式有一个缺点，看似5个线程异步执行，其实是顺序执行，因为 task.get是要等待线程执行完毕才会执行下边的代码。所以效率不会高,可能换种写法可以解决这个问题，这里就不深入研究。

方式二：

通过java工具类CountDownLatch实现并发计算

package test;

import java.util.concurrent.CountDownLatch;

public class FiveThreadCount3 {

private int[] arr={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28};

private int total=0;

public void test() throws InterruptedException{

int length=arr.length;

CountDownLatch latch=new CountDownLatch(length%5==0?5:6);

System.out.println(length);

for(int j=0;j

MyThread task;

if( (j+(length/5))<=length){

task=new MyThread(arr, j, j+(length/5), latch);

}else{

task=new MyThread(arr, j, length, latch);

}

new Thread(task).start();

}

latch.await();

System.out.println(total);

}

private class MyThread implements Runnable{

int[] arr;

int startIndex;

int endIndex;

CountDownLatch latch;

public MyThread(int[] arr,int startIndex,int endIndex,CountDownLatch latch){

this.arr=arr;

this.startIndex=startIndex;

this.endIndex=endIndex;

this.latch=latch;

}

@Override

public void run() {

int sum=0;

for(int i=startIndex;i

sum+=arr[i];

}

synchronized (MyThread.class) {

total+=sum;

}

System.out.println(Thread.currentThread().getName());

latch.countDown();

}

对于CountDownLatch不熟悉的可以搜索下用法。

方式三：

通过java工具类 CyclicBarrier实现并发计算。

package test;

import java.util.concurrent.BrokenBarrierException;

import java.util.concurrent.CyclicBarrier;

public class FiveThreadCount1 {

private int[] arr={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28};

private int total=0;

public void test() throws InterruptedException, BrokenBarrierException{

int length=arr.length;

CyclicBarrier barrier=new CyclicBarrier((length%5==0?5:6)+1);

System.out.println(length);

for(int j=0;j

MyThread task;

if( (j+(length/5))<=length){

task=new MyThread(arr, j, j+(length/5), barrier);

}else{

task=new MyThread(arr, j, length, barrier);

}

new Thread(task).start();

}

barrier.await();

System.out.println(total);

}

private class MyThread implements Runnable{

int[] arr;

int startIndex;

int endIndex;

CyclicBarrier barrier;

public MyThread(int[] arr,int startIndex,int endIndex,CyclicBarrier barrier){

this.arr=arr;

this.startIndex=startIndex;

this.endIndex=endIndex;

this.barrier=barrier;

}

@Override

public void run() {

int sum=0;

for(int i=startIndex;i

sum+=arr[i];

}

synchronized (MyThread.class) {

total+=sum;

}

try {

System.out.println(Thread.currentThread().getName());

barrier.await();

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (BrokenBarrierException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

总结

总体来说，代码二的方式二、三，效率会高一点。以上代码都是通过main方法调用示例代码的test方法，输出结果到控制台。

{

synchronized (MyThread.class) {

if(j>=arr.length){

return;

}

count+=arr[j++];

try {

Thread.sleep(100);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println(Thread.currentThread().getName());

}

//方法一

public void test1(){

for(int i=0;i<5;i++){

new MyThread().start();

}

try {

Thread.sleep(10000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println(count);

}

//方法二

public void test2(){

Thread myThread=new MyThread();

for(int i=0;i<5;i++){

new Thread(myThread).start();

}

try {

Thread.sleep(10000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println(count);

}

//方法一的线程池实现版

public void test3(){

ExecutorService service=Executors.newCachedThreadPool();

for(int i=0;i<5;i++){

service.execute(new MyThread());

}

try {

Thread.sleep(10000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println(count);

}

//方法二的线程池实现版

public void test4(){

ExecutorService service=Executors.newCachedThreadPool();

Thread myThread=new MyThread();

for(int i=0;i<5;i++){

service.execute(myThread);

}

try {

Thread.sleep(10000);

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

System.out.println(count);

}

代码二：

方式一：

使用Callable，FutureTask方式，来实现代码：

package test;

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.FutureTask;

public class FiveThreadCount2 {

private int[] arr={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28};

private int total=0;

public void test() throws InterruptedException, ExecutionException{

ExecutorService service=Executors.newFixedThreadPool(5);

int length=arr.length;

for(int j=0;j

FutureTask task;

if( (j+(length/5))

task=new FutureTask(new MyCallable(arr, j, j+(length/5)));

}else{

task=new FutureTask(new MyCallable(arr, j, length));

}

service.execute(task);

total+=task.get();

}

service.shutdown();

System.out.println(total);

}

public class MyCallable implements Callable{

int[] arr;

int startIndex;

int endIndex;

public MyCallable(int[] arr,int startIndex,int endIndex){

this.arr=arr;

this.startIndex=startIndex;

this.endIndex=endIndex;

}

@Override

public Integer call() throws Exception {

int sum=0;

for(int i=startIndex;i

sum+=arr[i];

}

System.out.println(Thread.currentThread().getName());

return sum;

}

方式二：

通过java工具类CountDownLatch实现并发计算

package test;

import java.util.concurrent.CountDownLatch;

public class FiveThreadCount3 {

private int[] arr={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28};

private int total=0;

public void test() throws InterruptedException{

int length=arr.length;

CountDownLatch latch=new CountDownLatch(length%5==0?5:6);

System.out.println(length);

for(int j=0;j

MyThread task;

if( (j+(length/5))<=length){

task=new MyThread(arr, j, j+(length/5), latch);

}else{

task=new MyThread(arr, j, length, latch);

}

new Thread(task).start();

}

latch.await();

System.out.println(total);

}

private class MyThread implements Runnable{

int[] arr;

int startIndex;

int endIndex;

CountDownLatch latch;

public MyThread(int[] arr,int startIndex,int endIndex,CountDownLatch latch){

this.arr=arr;

this.startIndex=startIndex;

this.endIndex=endIndex;

this.latch=latch;

}

@Override

public void run() {

int sum=0;

for(int i=startIndex;i

sum+=arr[i];

}

synchronized (MyThread.class) {

total+=sum;

}

System.out.println(Thread.currentThread().getName());

latch.countDown();

}

对于CountDownLatch不熟悉的可以搜索下用法。

方式三：

通过java工具类 CyclicBarrier实现并发计算。

package test;

import java.util.concurrent.BrokenBarrierException;

import java.util.concurrent.CyclicBarrier;

public class FiveThreadCount1 {

private int[] arr={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28};

private int total=0;

public void test() throws InterruptedException, BrokenBarrierException{

int length=arr.length;

CyclicBarrier barrier=new CyclicBarrier((length%5==0?5:6)+1);

System.out.println(length);

for(int j=0;j

MyThread task;

if( (j+(length/5))<=length){

task=new MyThread(arr, j, j+(length/5), barrier);

}else{

task=new MyThread(arr, j, length, barrier);

}

new Thread(task).start();

}

barrier.await();

System.out.println(total);

}

private class MyThread implements Runnable{

int[] arr;

int startIndex;

int endIndex;

CyclicBarrier barrier;

public MyThread(int[] arr,int startIndex,int endIndex,CyclicBarrier barrier){

this.arr=arr;

this.startIndex=startIndex;

this.endIndex=endIndex;

this.barrier=barrier;

}

@Override

public void run() {

int sum=0;

for(int i=startIndex;i

sum+=arr[i];

}

synchronized (MyThread.class) {

total+=sum;

}

try {

System.out.println(Thread.currentThread().getName());

barrier.await();

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (BrokenBarrierException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

总结

总体来说，代码二的方式二、三，效率会高一点。以上代码都是通过main方法调用示例代码的test方法，输出结果到控制台。

FutureTask task;

if( (j+(length/5))

task=new FutureTask(new MyCallable(arr, j, j+(length/5)));

}else{

task=new FutureTask(new MyCallable(arr, j, length));

}

service.execute(task);

total+=task.get();

}

service.shutdown();

System.out.println(total);

}

public class MyCallable implements Callable{

int[] arr;

int startIndex;

int endIndex;

public MyCallable(int[] arr,int startIndex,int endIndex){

this.arr=arr;

this.startIndex=startIndex;

this.endIndex=endIndex;

}

@Override

public Integer call() throws Exception {

int sum=0;

for(int i=startIndex;i

sum+=arr[i];

}

System.out.println(Thread.currentThread().getName());

return sum;

}

方式二：

通过java工具类CountDownLatch实现并发计算

package test;

import java.util.concurrent.CountDownLatch;

public class FiveThreadCount3 {

private int[] arr={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28};

private int total=0;

public void test() throws InterruptedException{

int length=arr.length;

CountDownLatch latch=new CountDownLatch(length%5==0?5:6);

System.out.println(length);

for(int j=0;j

MyThread task;

if( (j+(length/5))<=length){

task=new MyThread(arr, j, j+(length/5), latch);

}else{

task=new MyThread(arr, j, length, latch);

}

new Thread(task).start();

}

latch.await();

System.out.println(total);

}

private class MyThread implements Runnable{

int[] arr;

int startIndex;

int endIndex;

CountDownLatch latch;

public MyThread(int[] arr,int startIndex,int endIndex,CountDownLatch latch){

this.arr=arr;

this.startIndex=startIndex;

this.endIndex=endIndex;

this.latch=latch;

}

@Override

public void run() {

int sum=0;

for(int i=startIndex;i

sum+=arr[i];

}

synchronized (MyThread.class) {

total+=sum;

}

System.out.println(Thread.currentThread().getName());

latch.countDown();

}

对于CountDownLatch不熟悉的可以搜索下用法。

方式三：

通过java工具类 CyclicBarrier实现并发计算。

package test;

import java.util.concurrent.BrokenBarrierException;

import java.util.concurrent.CyclicBarrier;

public class FiveThreadCount1 {

private int[] arr={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28};

private int total=0;

public void test() throws InterruptedException, BrokenBarrierException{

int length=arr.length;

CyclicBarrier barrier=new CyclicBarrier((length%5==0?5:6)+1);

System.out.println(length);

for(int j=0;j

MyThread task;

if( (j+(length/5))<=length){

task=new MyThread(arr, j, j+(length/5), barrier);

}else{

task=new MyThread(arr, j, length, barrier);

}

new Thread(task).start();

}

barrier.await();

System.out.println(total);

}

private class MyThread implements Runnable{

int[] arr;

int startIndex;

int endIndex;

CyclicBarrier barrier;

public MyThread(int[] arr,int startIndex,int endIndex,CyclicBarrier barrier){

this.arr=arr;

this.startIndex=startIndex;

this.endIndex=endIndex;

this.barrier=barrier;

}

@Override

public void run() {

int sum=0;

for(int i=startIndex;i

sum+=arr[i];

}

synchronized (MyThread.class) {

total+=sum;

}

try {

System.out.println(Thread.currentThread().getName());

barrier.await();

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (BrokenBarrierException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

总结

总体来说，代码二的方式二、三，效率会高一点。以上代码都是通过main方法调用示例代码的test方法，输出结果到控制台。

task=new FutureTask(new MyCallable(arr, j, j+(length/5)));

}else{

task=new FutureTask(new MyCallable(arr, j, length));

}

service.execute(task);

total+=task.get();

}

service.shutdown();

System.out.println(total);

}

public class MyCallable implements Callable{

int[] arr;

int startIndex;

int endIndex;

public MyCallable(int[] arr,int startIndex,int endIndex){

this.arr=arr;

this.startIndex=startIndex;

this.endIndex=endIndex;

}

@Override

public Integer call() throws Exception {

int sum=0;

for(int i=startIndex;i

sum+=arr[i];

}

System.out.println(Thread.currentThread().getName());

return sum;

}

方式二：

通过java工具类CountDownLatch实现并发计算

package test;

import java.util.concurrent.CountDownLatch;

public class FiveThreadCount3 {

private int[] arr={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28};

private int total=0;

public void test() throws InterruptedException{

int length=arr.length;

CountDownLatch latch=new CountDownLatch(length%5==0?5:6);

System.out.println(length);

for(int j=0;j

MyThread task;

if( (j+(length/5))<=length){

task=new MyThread(arr, j, j+(length/5), latch);

}else{

task=new MyThread(arr, j, length, latch);

}

new Thread(task).start();

}

latch.await();

System.out.println(total);

}

private class MyThread implements Runnable{

int[] arr;

int startIndex;

int endIndex;

CountDownLatch latch;

public MyThread(int[] arr,int startIndex,int endIndex,CountDownLatch latch){

this.arr=arr;

this.startIndex=startIndex;

this.endIndex=endIndex;

this.latch=latch;

}

@Override

public void run() {

int sum=0;

for(int i=startIndex;i

sum+=arr[i];

}

synchronized (MyThread.class) {

total+=sum;

}

System.out.println(Thread.currentThread().getName());

latch.countDown();

}

对于CountDownLatch不熟悉的可以搜索下用法。

方式三：

通过java工具类 CyclicBarrier实现并发计算。

package test;

import java.util.concurrent.BrokenBarrierException;

import java.util.concurrent.CyclicBarrier;

public class FiveThreadCount1 {

private int[] arr={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28};

private int total=0;

public void test() throws InterruptedException, BrokenBarrierException{

int length=arr.length;

CyclicBarrier barrier=new CyclicBarrier((length%5==0?5:6)+1);

System.out.println(length);

for(int j=0;j

MyThread task;

if( (j+(length/5))<=length){

task=new MyThread(arr, j, j+(length/5), barrier);

}else{

task=new MyThread(arr, j, length, barrier);

}

new Thread(task).start();

}

barrier.await();

System.out.println(total);

}

private class MyThread implements Runnable{

int[] arr;

int startIndex;

int endIndex;

CyclicBarrier barrier;

public MyThread(int[] arr,int startIndex,int endIndex,CyclicBarrier barrier){

this.arr=arr;

this.startIndex=startIndex;

this.endIndex=endIndex;

this.barrier=barrier;

}

@Override

public void run() {

int sum=0;

for(int i=startIndex;i

sum+=arr[i];

}

synchronized (MyThread.class) {

total+=sum;

}

try {

System.out.println(Thread.currentThread().getName());

barrier.await();

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (BrokenBarrierException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

总结

总体来说，代码二的方式二、三，效率会高一点。以上代码都是通过main方法调用示例代码的test方法，输出结果到控制台。

sum+=arr[i];

}

System.out.println(Thread.currentThread().getName());

return sum;

}

方式二：

通过java工具类CountDownLatch实现并发计算

package test;

import java.util.concurrent.CountDownLatch;

public class FiveThreadCount3 {

private int[] arr={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28};

private int total=0;

public void test() throws InterruptedException{

int length=arr.length;

CountDownLatch latch=new CountDownLatch(length%5==0?5:6);

System.out.println(length);

for(int j=0;j

MyThread task;

if( (j+(length/5))<=length){

task=new MyThread(arr, j, j+(length/5), latch);

}else{

task=new MyThread(arr, j, length, latch);

}

new Thread(task).start();

}

latch.await();

System.out.println(total);

}

private class MyThread implements Runnable{

int[] arr;

int startIndex;

int endIndex;

CountDownLatch latch;

public MyThread(int[] arr,int startIndex,int endIndex,CountDownLatch latch){

this.arr=arr;

this.startIndex=startIndex;

this.endIndex=endIndex;

this.latch=latch;

}

@Override

public void run() {

int sum=0;

for(int i=startIndex;i

sum+=arr[i];

}

synchronized (MyThread.class) {

total+=sum;

}

System.out.println(Thread.currentThread().getName());

latch.countDown();

}

对于CountDownLatch不熟悉的可以搜索下用法。

方式三：

通过java工具类 CyclicBarrier实现并发计算。

package test;

import java.util.concurrent.BrokenBarrierException;

import java.util.concurrent.CyclicBarrier;

public class FiveThreadCount1 {

private int[] arr={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28};

private int total=0;

public void test() throws InterruptedException, BrokenBarrierException{

int length=arr.length;

CyclicBarrier barrier=new CyclicBarrier((length%5==0?5:6)+1);

System.out.println(length);

for(int j=0;j

MyThread task;

if( (j+(length/5))<=length){

task=new MyThread(arr, j, j+(length/5), barrier);

}else{

task=new MyThread(arr, j, length, barrier);

}

new Thread(task).start();

}

barrier.await();

System.out.println(total);

}

private class MyThread implements Runnable{

int[] arr;

int startIndex;

int endIndex;

CyclicBarrier barrier;

public MyThread(int[] arr,int startIndex,int endIndex,CyclicBarrier barrier){

this.arr=arr;

this.startIndex=startIndex;

this.endIndex=endIndex;

this.barrier=barrier;

}

@Override

public void run() {

int sum=0;

for(int i=startIndex;i

sum+=arr[i];

}

synchronized (MyThread.class) {

total+=sum;

}

try {

System.out.println(Thread.currentThread().getName());

barrier.await();

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (BrokenBarrierException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

总结

总体来说，代码二的方式二、三，效率会高一点。以上代码都是通过main方法调用示例代码的test方法，输出结果到控制台。

MyThread task;

if( (j+(length/5))<=length){

task=new MyThread(arr, j, j+(length/5), latch);

}else{

task=new MyThread(arr, j, length, latch);

}

new Thread(task).start();

}

latch.await();

System.out.println(total);

}

private class MyThread implements Runnable{

int[] arr;

int startIndex;

int endIndex;

CountDownLatch latch;

public MyThread(int[] arr,int startIndex,int endIndex,CountDownLatch latch){

this.arr=arr;

this.startIndex=startIndex;

this.endIndex=endIndex;

this.latch=latch;

}

@Override

public void run() {

int sum=0;

for(int i=startIndex;i

sum+=arr[i];

}

synchronized (MyThread.class) {

total+=sum;

}

System.out.println(Thread.currentThread().getName());

latch.countDown();

}

对于CountDownLatch不熟悉的可以搜索下用法。

方式三：

通过java工具类 CyclicBarrier实现并发计算。

package test;

import java.util.concurrent.BrokenBarrierException;

import java.util.concurrent.CyclicBarrier;

public class FiveThreadCount1 {

private int[] arr={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28};

private int total=0;

public void test() throws InterruptedException, BrokenBarrierException{

int length=arr.length;

CyclicBarrier barrier=new CyclicBarrier((length%5==0?5:6)+1);

System.out.println(length);

for(int j=0;j

MyThread task;

if( (j+(length/5))<=length){

task=new MyThread(arr, j, j+(length/5), barrier);

}else{

task=new MyThread(arr, j, length, barrier);

}

new Thread(task).start();

}

barrier.await();

System.out.println(total);

}

private class MyThread implements Runnable{

int[] arr;

int startIndex;

int endIndex;

CyclicBarrier barrier;

public MyThread(int[] arr,int startIndex,int endIndex,CyclicBarrier barrier){

this.arr=arr;

this.startIndex=startIndex;

this.endIndex=endIndex;

this.barrier=barrier;

}

@Override

public void run() {

int sum=0;

for(int i=startIndex;i

sum+=arr[i];

}

synchronized (MyThread.class) {

total+=sum;

}

try {

System.out.println(Thread.currentThread().getName());

barrier.await();

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (BrokenBarrierException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

总结

总体来说，代码二的方式二、三，效率会高一点。以上代码都是通过main方法调用示例代码的test方法，输出结果到控制台。

sum+=arr[i];

}

synchronized (MyThread.class) {

total+=sum;

}

System.out.println(Thread.currentThread().getName());

latch.countDown();

}

对于CountDownLatch不熟悉的可以搜索下用法。

方式三：

通过java工具类 CyclicBarrier实现并发计算。

package test;

import java.util.concurrent.BrokenBarrierException;

import java.util.concurrent.CyclicBarrier;

public class FiveThreadCount1 {

private int[] arr={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28};

private int total=0;

public void test() throws InterruptedException, BrokenBarrierException{

int length=arr.length;

CyclicBarrier barrier=new CyclicBarrier((length%5==0?5:6)+1);

System.out.println(length);

for(int j=0;j

MyThread task;

if( (j+(length/5))<=length){

task=new MyThread(arr, j, j+(length/5), barrier);

}else{

task=new MyThread(arr, j, length, barrier);

}

new Thread(task).start();

}

barrier.await();

System.out.println(total);

}

private class MyThread implements Runnable{

int[] arr;

int startIndex;

int endIndex;

CyclicBarrier barrier;

public MyThread(int[] arr,int startIndex,int endIndex,CyclicBarrier barrier){

this.arr=arr;

this.startIndex=startIndex;

this.endIndex=endIndex;

this.barrier=barrier;

}

@Override

public void run() {

int sum=0;

for(int i=startIndex;i

sum+=arr[i];

}

synchronized (MyThread.class) {

total+=sum;

}

try {

System.out.println(Thread.currentThread().getName());

barrier.await();

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (BrokenBarrierException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

总结

总体来说，代码二的方式二、三，效率会高一点。以上代码都是通过main方法调用示例代码的test方法，输出结果到控制台。

MyThread task;

if( (j+(length/5))<=length){

task=new MyThread(arr, j, j+(length/5), barrier);

}else{

task=new MyThread(arr, j, length, barrier);

}

new Thread(task).start();

}

barrier.await();

System.out.println(total);

}

private class MyThread implements Runnable{

int[] arr;

int startIndex;

int endIndex;

CyclicBarrier barrier;

public MyThread(int[] arr,int startIndex,int endIndex,CyclicBarrier barrier){

this.arr=arr;

this.startIndex=startIndex;

this.endIndex=endIndex;

this.barrier=barrier;

}

@Override

public void run() {

int sum=0;

for(int i=startIndex;i

sum+=arr[i];

}

synchronized (MyThread.class) {

total+=sum;

}

try {

System.out.println(Thread.currentThread().getName());

barrier.await();

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (BrokenBarrierException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

总结

总体来说，代码二的方式二、三，效率会高一点。以上代码都是通过main方法调用示例代码的test方法，输出结果到控制台。

sum+=arr[i];

}

synchronized (MyThread.class) {

total+=sum;

}

try {

System.out.println(Thread.currentThread().getName());

barrier.await();

} catch (InterruptedException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (BrokenBarrierException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

总结

总体来说，代码二的方式二、三，效率会高一点。以上代码都是通过main方法调用示例代码的test方法，输出结果到控制台。

Iterator与LIstIterator接口在java中的区别有哪些

295 2022-10-24

Java使用5个线程计算数组之和

Flask接口签名sign原理与实例代码浅析

zookeeper python接口实例详解

Iterator与LIstIterator接口在java中的区别有哪些

推荐文章

接口调用是什么意思？几种常用接口调用方式

接口设计原则

8款在线 API 接口文档管理工具

api管理系统是什么？

什么是接口调试？接口调试的步骤有哪些？

api 接口管理系统有哪些？

接口测试有几种测试方法

API文档生成工具有哪些？

微服务和api网关区别

交换机配置步骤

最近发表

热评文章

在线接口文档管理工具推荐，支持在线测试，HTTP接口

开源的在线接口文档wiki工具Mindoc的介绍与使

如何优雅的进行接口设计？接口设计的六大原则是什么？

什么是API测试,api检测公司

软件接口设计怎么做？前后端分离软件接口设计思路

接口管理平台推荐，几大接口管理平台总有一款适合你！