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

最新推荐文章于 2024-04-29 20:56:19 发布
最新推荐文章于 2024-04-29 20:56:19 发布
阅读量3k 收藏 14
点赞数 2
分类专栏： java 文章标签： 多线程 数组之和 计算
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wzmde007/article/details/89947481
版权

前言

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

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

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

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

代码一：

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

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<arr.length)
				{
					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<length;j+=(length/5)){
			FutureTask<Integer> task;
			if( (j+(length/5))<length){
				task=new FutureTask<Integer>(new MyCallable(arr, j, j+(length/5)));
			}else{
				task=new FutureTask<Integer>(new MyCallable(arr, j, length));
			}
			service.execute(task);
			total+=task.get();
		}
		service.shutdown();
		System.out.println(total);

	}
	
	public class MyCallable implements Callable<Integer>{
		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<endIndex;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<length;j+=(length/5)){
			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<endIndex;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<length;j+=(length/5)){
			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<endIndex;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方法，输出结果到控制台。 

安迪爸爸
关注
专栏目录
多线程并行计算数据总和 —— 优化计算思想（多线程去计算）—— C语言demo...
u013085496的博客
05-08 852
多线程计算整型数组数据总和： #include <stdio.h> #include <stdlib.h> #include <Windows.h> #include<process.h> #include <time.h> #define N 1024 struct Myinfo { int ...
利用多线程计算元素数组的和
PKU_ZZY的博客
12-17 3649
利用多线程计算元素数组的和
Lab-Aula08:使用线程对 C 中的数组求和
06-09
实验班 08 使用线程对 C 中的数组求和
多线程并行数组求和（相邻配对模式）
武泗海的博客
12-16 772
//并行规约 //参数含义：L为数据总长度，length是当前线程的计算长度。 template T omp_reduction1(T*data ,int length,int L) { if (length == 1) return *data; int strize = pow(2,log(L)/log(2)-log(length)/log(2)); for (int i = 0; i
通过多个线程计算1到50000相加之和-java篇
weixin_40544651的博客
02-12 2199
1.通过cyclicBarrier来计算，原则是启动五个线程，然后等待都完成，然后输出结果 import java.util.concurrent.*; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicInteger; /** * @Author: 张小乙 *...
java二维数组的初始化及使用其长度
weixin_30332241的博客
04-17 467
二维数组的初始化 1.静态初始化 int intArray[ ][ ]={{1,2},{2,3},{3,4,5}}; Java语言中，由于把二维数组看作是数组的数组，数组空间不是连续分配的，所以不要求二维数组每一维的大小相同。 2.动态初始化 1) 直接为每一维分配空间，格式如下： arrayName = new type[arrayLength1][arrayLength2];...
Java多线程并行计算包含2千个整数的数组和
Ethon自动化测试
12-25 1522
import java.util.ArrayList; import java.util.Scanner; public class Add { public static void main(String[] args) throws Exception { // 定义一个数组并初始化 int[] nums = new int[2000]; for (int i = 0; i...
java多线程实现累加_多线程实现一个累加（可以是具体业务）操作
weixin_39846289的博客
02-13 1100
普通做法在这个直接累加100public static void main(String[] args) throws Exception {long start = System.currentTimeMillis();Integer count = 100;Integer sum = 0;for (int a = 0; a < count; a++) {sum += a;Thread.s...
多线程累加计数
Jamie's Blogs
11-07 1260
多线程累加计数使用Runnable接口使用AtomicInteger加线程池 使用Runnable接口 public class ThreadTest { // 公共变量 int count = 0; public static void main(String[] args) { ThreadTest threadTest = new ThreadTe...
Java多个线程计算数组中数字之和并输出最终结果
NnNnNnNnNn_5的博客
08-12 2256
import java.util.ArrayList; import java.util.List; /** * 一个包含了2千个整数的数组，分拆了多个线程来进行并行计算，最后汇总出计算的结果。 * * * @author Zhouzilong * @date 2019年8月12日 */ public class P2 { public static void main(...
实现计算数组元素的最大值_在数组中找到最大值_
10-04
2. **遍历数组**：使用for循环，从数组的第一个元素开始，逐个检查每个元素。循环的结构可以写成： ```c for(int i = 0; i 数组长度; i++) { // 待执行的操作 } ``` 3. **比较和更新**：在循环体内部，使用...
python线程数组_小练手：用Python实现多线程计算大数组元素和
weixin_35340730的博客
01-30 687
刚学Python三四天，记得不久前面试被问过一道用多线程实现计算大数组元素之和的问题，就顺路用Python来实现了一下。刚学Python不久，如果程序上有什么实现错误，请各位大哥不吝指点下哈~~代码如下：#coding: UTF-8"""经过非正规的测试，多线程并行计算并未像想象中那样会比串行计算快。相反，在我的PC上运行后，多线程并行计算反而慢了。不知是计算量不够大，还是怎么。(本身内存有限，无...
一道Java典型多线程题：请分成N个线程，计算m到n的值的总和。要求每个线程计算的数字量之差不超过1
xiedongze__的博客
11-15 1011
一、用到的知识点：多例多线程、synchronized锁、数据共享 public class task05 { public static void main(String[] args) { System.out.println("请输入m到n的值，用于计算的线程数N："); Scanner in = new Scanner(System.in); int m = in.nextInt(); int n = in.nextInt(); int threadNumber = in.n
10个线程求1到10000的和
我和你不再联系，不是因为我不想你。。。
09-19 3096
面试遇到的笔试题，基本思路是每个线程计算1000个数的和，下面用两个方式实现： 1、利用线程池和Future获取每个线程的结果 package com.demo.test; import java.util.concurrent.Callable; public class CountThread implements Callable<Integer> { public ...
十个随机数的求和
ZK137856的博客
04-12 821
1 Private Sub Command1_Click() Cls Dim n As Integer, s As Integer, a(10) As Integer n = 1 While n a(n) = Int(Rnd * 1000) n = n + 1 Wend n = 1 While n Print a(n) n = n + 1 Wen
怎么使用线程池计算1到10000的和
最新发布
hello_boyu的博客
04-29 227
这段代码会将1到1万的计算任务分成四个子任务，分别交给线程池执行。然后等待每个子任务完成，并将它们的结果累加得到最终的总和。
使用 CountDownLatch 多线程累加求和
qq_42331367的博客
12-30 440
【代码】使用 CountDownLatch 多线程累加求和。
java随机数多线程求和
Sunbeam的博客
08-02 683
直接上代码： public class ExecutorsCalculate { static int[] nums = new int[1000]; static Random random = new Random(); static int sums; static { for (int i = 0; i < nums.length; i++) { nums[i]...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值