计算10000000内的累加和利用线程和for

最新推荐文章于 2023-02-12 20:38:21 发布
最新推荐文章于 2023-02-12 20:38:21 发布
阅读量539 收藏 2
点赞数 2
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44134972/article/details/88316238
版权

利用for循环和多线程计算计算10000000内的累加和

多线程

  1. 创建一个类，实现Runnable接口
  2. 实现run() 方法

ArrayTest多线程类

/**
 * 创建一个多线程，利用该类计算10000000内的和
 * 			一共分为两个线程，一个线程计算  0 - 10000000/2 的和
 * 							 一个线程计算 10000000/2 - 10000000的和
 * 			在把两次的和计算出来 
 * @author zhuchuansheng
 *
 */
class ArrayTest implements Runnable{
	
	//存储一个数组
	private int[] array;
	//数组开始的下标
	private int start = 0;
	//数组结束的下标
	private int end = 0;
	//计算的总和
	public double sum = 0;
	
	//构造器，厨初始化参数
	public ArrayTest(int[] arra) {
		//准备数组
		this.array = arra;
		//计算数组中间值
		this.end = array.length / 2;
		System.out.println("数组中间是: "+end);
	}
	
	@Override
	public void run() {
		//保证线程的安全
		synchronized(this) {
			//计算数组的一部分和
			for (int i = start; i < end; i++) {
				sum+=array[i];
			}
			//判断是否累
			if(start != 0) {
				//累加完成，打印结果
				System.out.println("使用多线程计算："+sum);
			}else {
				//累加没有完成，计算另一部分
				this.start = array.length / 2;
				this.end = array.length;
			}
		}
	}
}

for循环

创建一个类，创建一个方法，利用for循环计算数组的和

ArrrayTest1 for循环类
/**
 * 	使用for循环计算10000000内的和
 * @author zhuchuansheng
 *
 */
class ArrayTest1{
	
	//计算数组
	private int[] array;
	//计算结果
	private double sum = 0;
	
	//构造器，初始化参数
	public ArrayTest1(int[] array) {
		this.array = array;
	}
	
	//计算累加
	public void sum() {
		for (int i = 0; i < array.length; i++) {
			sum+=array[i];
		}
		System.out.println("使用for循环计算："+sum);
	}
}

创建测试类

	测试for循环和多线程的效率。使用计算时间和比较
ThreadTeat_0 测试类
/**
 * 测试 10000000 累加
 * 		测试分线程
 * 		测试for循环
 * @author zhuchuansheng
 *
 */
public class ThreadTest_0 {
	public static void main(String[] args) {
		
		/**
		 *  线程结果： 4.9999995E13
		 *  for结果：  4.9999995E13
		 */
		
		
		//记录开始时间(毫秒)
		long s = System.currentTimeMillis();
		
		//准备数组
		int[] array = new int[10000000];
		
		//数组赋值
		for(int i = 0; i < array.length; i++) {
			array[i] = i;
		}
		
		//创建普通for的实例
		ArrayTest1 a = new ArrayTest1(array);
		//调用方法计算
		a.sum();
		//计算结果时间(毫秒)
		long e = System.currentTimeMillis();
		//计算时间差(毫秒)
		System.out.println("循环计算的时间："+(e - s));
		
		
		/**
		 * for循环
		 * ------------------------------------------------------------
		 * 多线程
		 */
		
		
//		//创建多线程的实例
//		ArrayTest a1 = new ArrayTest(array);
//		//第一个线程
//		Thread t1 = new Thread(a1);
//		//开启线程
//		t1.start();
//		//第二个线程
//		Thread t2 = new Thread(a1);
//		t2.start();
//
//		//计算结束时间(毫秒)
//		long e = System.currentTimeMillis();
//		//计算时间差(毫秒)
//		System.out.println("线程计算的时间："+(e - s));
	}
}

由上面程序知道，

						多线程计算时间是：47   47  32 毫秒

在这里插入图片描述

						for循环计算时间是：22   37  31 毫秒

在这里插入图片描述

所以多线程的效率好一些。

完整代码：

package com.zhuchuanheng.thread.test1;

/**
 * 计算10000000内的和
 * 
 * 		1.使用普通的for循环计算10000000内的和
 * 				结果：47  53  54
 * 		2.使用多线程计算10000000内的和
 * 				结果：31  40  22
 * @author zhuchuansheng
 *
 */
/**
 * 创建一个多线程，利用该类计算10000000内的和
 * 			一共分为两个线程，一个线程计算  0 - 10000000/2 的和
 * 							 一个线程计算 10000000/2 - 10000000的和
 * 			在把两次的和计算出来 
 * @author zhuchuansheng
 *
 */
class ArrayTest implements Runnable{
	
	//存储一个数组
	private int[] array;
	//数组开始的下标
	private int start = 0;
	//数组结束的下标
	private int end = 0;
	//计算的总和
	public double sum = 0;
	
	//构造器，厨初始化参数
	public ArrayTest(int[] arra) {
		//准备数组
		this.array = arra;
		//计算数组中间值
		this.end = array.length / 2;
		System.out.println("数组中间是: "+end);
	}
	
	@Override
	public void run() {
		//保证线程的安全
		synchronized(this) {
			//计算数组的一部分和
			for (int i = start; i < end; i++) {
				sum+=array[i];
			}
			//判断是否累
			if(start != 0) {
				//累加完成，打印结果
				System.out.println("使用多线程计算："+sum);
			}else {
				//累加没有完成，计算另一部分
				this.start = array.length / 2;
				this.end = array.length;
			}
		}
	}
	
}

/**
 * 	使用for循环计算10000000内的和
 * @author zhuchuansheng
 *
 */
class ArrayTest1{
	
	//计算数组
	private int[] array;
	//计算结果
	private double sum = 0;
	
	//构造器，初始化参数
	public ArrayTest1(int[] array) {
		this.array = array;
	}
	
	//计算累加
	public void sum() {
		for (int i = 0; i < array.length; i++) {
			sum+=array[i];
		}
		System.out.println("使用for循环计算："+sum);
	}
}

/**
 * 测试 10000000 累加
 * 		测试分线程
 * 		测试for循环
 * @author zhuchuansheng
 *
 */
public class ThreadTest_0 {
	public static void main(String[] args) {
		
		/**
		 *  线程结果： 4.9999995E13
		 *  for结果：  4.9999995E13
		 */
		
		
		//记录开始时间(毫秒)
		long s = System.currentTimeMillis();
		
		//准备数组
		int[] array = new int[10000000];
		
		//数组赋值
		for(int i = 0; i < array.length; i++) {
			array[i] = i;
		}
		
		//创建普通for的实例
		ArrayTest1 a = new ArrayTest1(array);
		//调用方法计算
		a.sum();
		//计算结果时间(毫秒)
		long e = System.currentTimeMillis();
		//计算时间差(毫秒)
		System.out.println("循环计算的时间："+(e - s));
		
		
		/**
		 * for循环
		 * ------------------------------------------------------------
		 * 多线程
		 */
		
		
//		//创建多线程的实例
//		ArrayTest a1 = new ArrayTest(array);
//		//第一个线程
//		Thread t1 = new Thread(a1);
//		//开启线程
//		t1.start();
//		//第二个线程
//		Thread t2 = new Thread(a1);
//		t2.start();
//
//		//计算结束时间(毫秒)
//		long e = System.currentTimeMillis();
//		//计算时间差(毫秒)
//		System.out.println("线程计算的时间："+(e - s));
	}
}

由于CUP的调度不同每一次执行的结果不太一样，但是在效率上，多线程还是高与for循环计算

希望对你有帮助，有疑问请联系2635906359@qq.com

weixin_44134972
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用 Runnable 接口实现累加操作
weixin_54420332的博客
02-18 347
必须通过 join 使得子线程执行结束后再执行主线程中的累加操作，如果子线程没有执行结束，主线程会阻塞等待。学习代码如下： public class JoinTest { public static void main(String[] args)throws Exception { MyRunnable[] mr = new MyRunnable[10]; Thread[] tarr = new Thread[10]; for (int i = 0; i < 10; i++) {
【JAVA学习笔记】多线程和并发编程
weixin_39966701的博客
03-25 323
在家把前两天B站上的看过的JAVA核心技术【进阶】的多线程部分总结一下。 1 多进程和多线程简介 多进程概念 当前的OS都是多任务的 每个独立执行的任务就是一个进程 OS将CPU的时间划分为多个时间片 在每个时间片里将CPU分配给某一个任务，时间片结束，CPU被自动回收，又分配给其他的任务去执行。在外部看，可能是所有任务同时在运行，但其实在单核CPU系统中，任务是串行的在CPU中运行。...
写一个1-10000的累加程序
weixin_42581846的博客
02-12 52
。 这是一个简单的累加程序，您可以使用以下代码实现： sum =0 for i in range(1, 10001): sum += i print(sum) 这个程序将从1加到10000，并输出累加的总和。
写一个函数，计算两个1000000位长的正整数相加的值
weixin_45718351的博客
06-12 119
public String sum(String first,String second){ Map<String,char[]> firstMap = this.subString(first); Map<String,char[]> secondMap = this.subString(second); StringBuilder result = new StringBuilder(); Stack<...
C/C++代码验证多线程计算与单线程计算同一组值（1000个）求和花费的时间
hai033825的专栏
07-14 519
#include<iostream> #include<mutex> #include<list> #include<thread> #include<vector> #include "function_Ptr.h" #include "testThread.h" #include "testMutex.h" int main(void) { RegFun(Min); Plat(); RegFun(Max); ...
linux c开多线程算质数,计算1000以内的总质数个数
weixin_35398720的博客
05-11 480
#include int main() {int micro[500]; // 质数保存素组int number = 0; // 质数个数micro[number++] = 2; // micro[0]=2micro[number++] = 3; // micro[1]=3, number=2unsigned long counter = 0; // 计算处理次数in...
算法优化之c++多线程优化：思考与总结
gaussrieman123的博客
07-10 8778
最近的项目中要用多线程来对代码进行优化，期间查阅了一些资料，主要是踩过一些坑，在此记录一下。1.什么是线程？没有谁比维基百科说的更好了，直接点击查看：线程（英语：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也...
pthread多线程计算pi
06-16
读入第一个参数为线程数，第二个参数为N，积分法计算pi，C+pthread实现，附结果比较表
OpenCL多线程累加计算
Code_Life_LiWan的专栏
04-15 4928
初学OpenCL，写的不好的地方还请见谅。 本次说的是一个累加和的问题，给定一个一维数组A[n]，然后计算B[n]，其中，B[0]=A[0],B[1]=A[1]+B[0],B[2]=A[2]+B[1]...依此类推。 在我们的CPU中计算的时候使用一个循环来计算，程序是这样的： B[0]=A[0]; for(int i=1;i<n;i++){ B[i]=B[i-1]+A[i];
Java面试题：用多线程统计1~1000000之间有多少个素数
lxy_mycnds的博客
07-24 1412
用多线程统计1~1000000之间有多少个素数 package api.test; import java.util.ArrayList; import java.util.LinkedList; import java.util.List; public class FaceThreadTest { private final static int REGION_SIZE = 1...
java多线程累加计数
热门推荐
安迪爸爸
03-21 3万+
java多线程计数 题目 给定count=0；让5个线程并发累加到1000； 思路 创建一个类MyRunnable，实现Runnable（继承Thread类也可） 定义一个公共变量count(初始值为0)，5个线程都可以访问到； 创建5个线程并发递增count到1000； 方法 方法一 将count公共变量放到测试类Test的类成员变量里，将MyRunnable类作为Te...
C++多线程多少个线程算多？
10-25 6583
程序一启动就创建了60个线程，太多了，应该控制一下。也有同学提出不同意见，说线程多不是问题，别把它当成指标，盯住内存、CPU才是正经。使用多线程，为的是提高执行效率；那么，是不是线程越多越好呢？ 假设我们有100个下载任务，我们可以有以下3种实现方法： 使用一个线程，依次执行100个下载任务； 使用100个线程，每个线程执行一个下载任务； 使用10个线程，每个线程依次执行10个下载任务。 ...
通过多个线程计算1到50000相加之和-java篇
weixin_40544651的博客
02-12 2174
1.通过cyclicBarrier来计算，原则是启动五个线程，然后等待都完成，然后输出结果 import java.util.concurrent.*; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicInteger; /** * @Author: 张小乙 *...
利用多线程实现加法并行计算
李泽珑李泽珑~~~
05-01 4629
前提：数据规模较小的时候，并行计算可能用时更多利用Callable创建线程，可以返回值。利用future获取返回值。以下是源码：-------------------------------------------------------------------import java.util.Arrays; import java.util.List; import java.util.conc...
java多线程计算素数
lingmao555的博客
08-21 6766
package com.sunyard.demo.concurrency; /** * 此类作为工具类 */ public abstract class AbstractPrimeFinder { /** * 判断一个数是否为素数 * @param number * @return */ public boolean isPrime(f
第3关:使用多线程方式求累加和
最新发布
06-10
好的，这是一个经典的多线程编程问题。假设我们要对一个数组中...使用多线程方式求解累加和可以充分利用多核CPU的优势，提高计算效率。但是需要注意线程数量不能过多，否则会导致线程切换开销过大，反而降低计算效率。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值