java多线程计算（java中怎样实现多线程执行的结果相加）

本文目录

• java中怎样实现多线程执行的结果相加
• java 多线程 求和
• Java 实现多线程的几种方式汇总
• 如何判断java多线程是否全部执行完了，并计
• java 多线程访问数组求和
• Java单多线程求pair值算法比较

java中怎样实现多线程执行的结果相加

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
/**
单独的计算线程，比如计算{1...10}的相加
@author zhaohb
*/
public class CounterThread extends Thread{
private int start;
private int end;
private CyclicBarrier barrier ;
public CounterThread(int id,int start, int end,CyclicBarrier barrier) {
this.start = start;
this.end = end;
this.barrier = barrier;
setName("Thread-"+id+" ");
}
@Override
public void run() {
int count = 0;
for(int i=start;i《end+1;i++){
count += i;
}
Counter.totalCount(count);
try {
barrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}
}
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
测试类入口
@author zhaohb
*/
public class CounterTest {
public static void main(String args) {
//CyclicBarrier指定了当10个线程运行结束时候，可以进行最后结果展示了
CyclicBarrier barrier = new CyclicBarrier(10,new TotalTask(new Counter()));
ExecutorService executorService = Executors.newCachedThreadPool();
for(int i=0;i《10;i++){
int start = i*10+1;
int end = start + 9;
CounterThread counterThread = new CounterThread(i,start, end,barrier);
executorService.execute(counterThread);
}
executorService.shutdown();
}
}
/**
线程结果计算：将单独的线程的计算的结果相加，汇总的到总的结果
@author zhaohb
*
*/
class Counter {
private static int count =0;
public synchronized static int totalCount(int perCount){
count += perCount;
return count;
}
public int totalResult(){
return count;
}
}
/**
最后结算展示线程
@author zhb
*
*/
class TotalTask implements Runnable{
private Counter counter ;
public TotalTask(Counter counter){
this.counter = counter;
}
@Override
public void run() {
System.out.println("所有线程运行完毕，总结果为：");
int total = counter.totalResult();
System.out.println(total);
}
}

java 多线程 求和

分类: 电脑/网络 》》 程序设计 》》 其他编程语言
问题描述:

我编写的一段代码，基本上已经实现多线程求和

可是没办法返回每个线程求和之后得出的值

我的目的毕竟是求总的和，不是每个线程的和

import java.io.*;
class testthread extends Thread

{ int b=null;

public testthread(int a){b=a;}

public void run()

{int sum=0;

for (int i = 0; i《b.length; i++)

{

sum=sum+b;

}

System.out.println(sum);

}

}

public class thread {

/**

* @param args

*/

public static void main(String args) {

TODO 自动生成方法存根

try{

System.out.print("输入线程数 p(p》=2)：");

BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

String A=(String)br.readLine();

int p=Integer.parseInt(A);

System.out.print("输入求和数 n：");

BufferedReader cr=new BufferedReader(new InputStreamReader(System.in));

String B=(String)cr.readLine();

String x = B.split(" ") ;

int ;

for (int i = 0; i《x.length; i++)

{

n).intValue() ;

}

int c=n.length/p;

int a; 定义一个多维数组

int b=0;

for(int i=0;i《p;i++) 将n中元素赋值给多维数组

for(int j=0;j《c;j++)

{a;b++;}

for(int i=0;i《p;i++) 测试多维数组输出

{for(int j=0;j《c;j++)

{System.out.print(a+" "); }

System.out.println();

}

for(int i=0;i《p;i++) 创建线程

new testthread(a).start();

}catch(IOException e){}

}

}

解析:

帮你帮到底，你凑合着看看吧

package test;

import java.io.*;

class testthread

extends Thread {

int b = null;

public testthread(int a) {

b = a;

}

public void run() {

int sum = 0;

for (int i = 0; i 《 b.length; i++) {

sum = sum + b;

}

System.out.println(sum);

thread.tnumInc(sum);

}

}

public class thread {

private static int ready = 0;

private static int tnum = 0;

private static int SUM = 0;

static synchronized void tnumInc(int p)

{

ready++;

SUM += p;

if(ready》=tnum){

System.out.println(SUM);

}

}

/**

* @param args

*/

public static void main(String args) {

TODO 自动生成方法存根

try {

System.out.print("输入线程数 p(p》=2)：");

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

String A = (String) br.readLine();

int p = Integer.parseInt(A);

tnum = p;

System.out.print("输入求和数 n：");

BufferedReader cr = new BufferedReader(new InputStreamReader(System.in));

String B = (String) cr.readLine();

String x = B.split(" ");

int;

for (int i = 0; i 《 x.length; i++) {

n).intValue();

}

int c = n.length / p;

int a; 定义一个多维数组

int b = 0;

for (int i = 0; i 《 p; i++) 将n中元素赋值给多维数组

for (int j = 0; j 《 c; j++) {

a;

b++;

}

for (int i = 0; i 《 p; i++) { 测试多维数组输出

for (int j = 0; j 《 c; j++) {

System.out.print(a + " ");

}

System.out.println();

}

for (int i = 0; i 《 p; i++) 创建线程

new testthread(a).start();

}

catch (IOException e) {}

}

}

随便写写，没有测试过。你自己调调看吧。

大概思路就是给一个方法合并结果，并对已经完成的thread进行计数

当完成的thread的数量==总数的时候，最后结果就出来了

Java 实现多线程的几种方式汇总

有三种：
(1)继承Thread类，重写run函数
创建：
class xx extends Thread{
public void run(){
Thread.sleep(1000)//线程休眠1000毫秒，sleep使线程进入Block状态，并释放资源
}}
开启线程：
对象.start()//启动线程，run函数运行
(2)实现Runnable接口，重写run函数
开启线程：
Thread t = new Thread(对象)//创建线程对象
t.start()
(3)实现Callable接口，重写call函数
Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。
Callable和Runnable有几点不同:
①Callable规定的方法是call()，而Runnable规定的方法是run().
②Callable的任务执行后可返回值，而Runnable的任务是不能返回值的
③call()方法可抛出异常，而run()方法是不能抛出异常的。
④运行Callable任务可拿到一个Future对象，Future表示异步计算的结果。它提供了检查计算是否完成的方法,以等
待计算的完成,并检索计算的结果.通过Future对象可了解任务执行情况,可取消任务的执行,还可获取任务执行的结果

如何判断java多线程是否全部执行完了，并计

思路： 把所有的线程都放到线程池里面
步骤：
1： 创建线程池 ExecutorService cachedThreadPool
2： 开启一个线程 cachedThreadPool.execute(new Runnable() ｛//做任务｝）
3.： 判断线程池里面是否执行完， cachedThreadPool.isTerminated()
while (true) {
if (cachedThreadPool.isTerminated()) { // 计算耗时
long time = System.currentTimeMillis() - start;
System.out.println(":" + "程序结束了，总耗时：" + time + " ms(毫秒)！\n");
break;
}
}

java 多线程访问数组求和

public class T
{
 int input={100,5,98,77,60,88,36};  
 int output={0,0,0,0,0,0,0};  
 int curr = 0;
 
 public synchronized int getCurr() {
  if( curr== input.length )
   return -1;
  return curr++;
 }
 
 
 static class Worker extends Thread
 {
  T t;
  public Worker(T t) {
   this.t = t;
  }
  
  public void run() {
   int idx; 
   while( (idx=t.getCurr()) != -1 ) {
    int sum = 0;
    for(int i=0; i《t.input; i++ ) {
     sum += i;
    }
    t.output = sum;
   }
   System.out.println( getName() + " over" );
  }
 }
 
 public static void main(String args) throws Exception{
  T t = new T();
  Thread t1 = new Worker(t);
  Thread t2 = new Worker(t);
  Thread t3 = new Worker(t);
  t1.start();
  t2.start();
  t3.start();
  t1.join();
  t2.join();
  t3.join();
  for(int i=0; i《t.output.length; i++) {
   System.out.print( t.output + "," );
  }
  System.out.println();
 }
}

Java单多线程求pair值算法比较

　　 进程和线程的概念

　　 什么是进程

　　一个进程就是在一个运行的程序 它有自己独立的内存空间 一组系统资源 每个进程的内部数据和状态都是独立的 例如在window是同时打开多个记事本 虽然它们所运行的程序代码都是一样的 但是所使用的内存空间是独立的 互不干扰

　　 什么是线程

　　线程与进程相似 是一段完成某个特定功能的代码 是程序中单个顺序的流控制;但与进程不同的是 同类的多个线程共享一块内存空间和一组系统资源 而线程本身的数据通常只有微处理器的寄存器数据 以及一个供程序执行时使用的堆栈

　　 进程与线程的区别

　　 进程:每个进程都有独立的代码和数据空间(进程上下文) 进程切换的开销大

　　 线程:轻量的进程 同一类线程共享代码和数据空间 每个线程有独立的运行栈和程序计数器(PC) 线程切换的开销小

　　 多进程:在操作系统中 能同时运行多个任务程序

　　 多线程:在同一应用程序中 有多个顺序流同时执行

　　 线程创建的两种方式

　　采用继承Thread类创建线程

　　该方法比较简单 主要是通过继承java lang Thread类 并覆盖Thread类的run()方法来完成线成的创建 Thread 类是一个具体的类 即不是抽象类 该类封装了线程的行为 要创建一个线程 程序员必须创建一个从 Thread 类导出的新类 Thread类中有两个最重要的函数run()和start()

　　通过实现Runnable接口创建线程

　　该方法通过生成实现java lang Runnable接口的类 该接口只定义了一个方法run() 所以必须在新类中实现它 但是 Runnable 接口并没有任何对线程的支持 我们还必须创建 Thread 类的实例 这一点通过 Thread 类的构造函数

　　public Thread(Runnable target);来实现

　　 单线程和多线程性能比较

　　以使用蒙特卡罗概率算法求π为例 进行单线程和多线程时间比较

　　 什么是蒙特卡罗概率算法

　　蒙特卡罗法(Monte Carlo method)是以概率和统计的理论 方法为基础的一种计算方法 将所求解的问题同一定的概率模型相联系 用电子计算机实现统计模拟或抽样 以获得问题的近似解 故又称统计模拟法或统计试验法 百度百科

　　蒙特卡罗求算法求π

　　第一步

　　画正方形和内切圆

　　第二步

　　变换表达式

　　正方形面积As=( R)^

　　圆的面积Ac=πR^

　　Ac/As=( R)^ /πR^

　　π= As/Ac

　　令P=As/Sc 则π= P

　　第三步

　　重复N次实验求平均值

　　在正方形区域内随机生成一个点A 若A落在圆区域内 M++

　　P=M/N

　　π= P N的取值越大 π的值越精确

　　 java代码实现算法

　　N取值为 万 多线程的数为 每个线程执行 万次模拟实验

　　线程实现

　　import ncurrent CountDownLatch;

　　public class ProModel implements Runnable {

　　public int N;//随机实验的总次数

　　public static int M;//随机点落在圆中的次数

　　private int id;

　　private final CountDownLatch doneSignal;

　　OBJ semaphore;

　　public ProModel(int id CountDownLatch doneSignal int N OBJ semaphore ){

　　this id=id;

　　this doneSignal=doneSignal;

　　this N=N;

　　this semaphore=semaphore ;

　　M= ;

　　}

　　public void run(){

　　int tempM= ;

　　for(int i= ;i《N;i++){

　　if(isInCircle()){

　　tempM++;

　　}

　　}

　　synchronized (semaphore) {

　　add(tempM);

　　}

　　untDown();//使end状态减

　　}

　　public  void add(int tempM){

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

　　M=M+tempM;

　　System out println(M);

　　}

　　//随机产生一个在正方形区域的点 判断它是否在圆中

　　public boolean isInCircle(){

　　double x=Math random();

　　double y=Math random();

　　if((x )*(x )+(y )*(y )《 )

　　return true;

　　else

　　return false;

　　}

　　public static int getTotal(){

　　return M;

　　}

　　}

　　多线程Main实现

　　import ncurrent CountDownLatch;

　　import ncurrent ExecutorService;

　　import ncurrent Executors;

　　public class MutliThread {

　　public static void main(String args) throws InterruptedException {

　　long begin=System currentTimeMillis();

　　int threadSize= ;

　　int N= ;

　　OBJ semaphore = new OBJ();

　　CountDownLatch doneSignal  = new CountDownLatch(threadSize);

　　ProModel;

　　//设置特定的线程池 大小为threadSizde

　　System out println( begins! );

　　ExecutorService exe = Executors newFixedThreadPool(threadSize);

　　for(int i= ;i《threadSize;i++)

　　exe execute(new ProModel(i+ doneSignal N semaphore));

　　try{

　　doneSignal await();            //等待end状态变为            }catch (InterruptedException e) {

　　// TODO: handle exception

　　e printStackTrace();

　　}finally{

　　System out println( ends! );

　　System out println( *(float)ProModel getTotal()/(float)(threadSize*N));

　　}

　　exe shutdown();

　　long end=System currentTimeMillis();

　　System out println( used time(ms): +(end begin));

　　}

　　}

　　class OBJ{}

　　单线程Main实现

　　import ncurrent CountDownLatch;

　　import ncurrent ExecutorService;

　　import ncurrent Executors;

　　public class SingleThread {

　　public static void main(String args) {

　　long begin=System currentTimeMillis();

　　int threadSize= ;

　　int N= ;

　　OBJ semaphore = new OBJ();

　　CountDownLatch doneSignal  = new CountDownLatch(threadSize);

　　ProModel;

　　//设置特定的线程池 大小为

　　System out println( begins! );

　　ExecutorService exe = Executors newFixedThreadPool(threadSize);

　　for(int i= ;i《threadSize;i++)

　　exe execute(new ProModel(i+ doneSignal N semaphore));

　　try{

　　doneSignal await();            //等待end状态变为            }catch (InterruptedException e) {

　　// TODO: handle exception

　　e printStackTrace();

　　}finally{

　　System out println( ends! );

　　System out println( *(float)ProModel getTotal()/(float)(threadSize*N));

　　}

　　exe shutdown();

　　long end=System currentTimeMillis();

　　System out println( used time(ms): +(end begin));

　　}

　　}

　　运行结果比较