「java线程求和」java求和程序

今天给各位分享java线程求和的知识，其中也会对java求和程序进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、java怎么用5个线程求1~100的和
• 2、java 多线程 求和
• 3、java多线程求和的问题
• 4、java中怎样实现多线程执行的结果相加
• 5、Java用五个线程求1到100的和，怎么答案不对 求大神帮忙改正
• 6、java 线程同步求和（100分）

java怎么用5个线程求1~100的和

public class Test {

class MyThread implements Runnable{

private int number, start, end;

private boolean isEnd = true;

@Override

public void run() {

for (;start = end; start++) {

number += start;

}

isEnd = true;

}

public void setArea(int start, int end){

this.start = start;

this.end = end;

isEnd = false;

new Thread(this).start();

}

public int getNumber(){

return isEnd?number:-1;

}

};

public static void main(String[] args){

int num = 0;

MyThread[] arrayThread = new MyThread[5];

int[] arrayNum = new int[arrayThread.length];

Test test = new Test();

MyThread myThread;

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

myThread = test.new MyThread();

myThread.setArea(num+=1, num+=19);

arrayThread[i] = myThread;

System.out.println("step num = " + num);

}

num = 0;

for (int i = 0; i arrayNum.length;) {

if (arrayThread[i].getNumber() != -1) {

num += arrayThread[i].getNumber();

++i;

}

}

System.out.println("num = " + num);

}

}

java 多线程 求和

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

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[i];

}

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[] n = new int[x.length];

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

n[i] = new Integer(x[i]).intValue();

}

int c = n.length / p;

int a[][] = new int[p][c]; //定义一个多维数组

int b = 0;

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

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

a[i][j] = n[b];

b++;

}

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

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

System.out.print(a[i][j] + " ");

}

System.out.println();

}

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

new testthread(a[i]).start();

}

catch (IOException e) {}

}

}

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

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

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

java多线程求和的问题

将a[i]传过去，a[i][1],a[i][2]过得去

class testthread extends Thread

{

int[] b = null;

public testthread(int[] a)

{

b=a;

}

public void run()

{

for (int i = 0; ib.length; i++)

{

System.out.println(b[i]+" ");

}

}

注意变量的作用域

另外，从Thread上继承下来的run()方法是无参的

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;iend+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;i10;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用五个线程求1到100的和，怎么答案不对 求大神帮忙改正

出现这种情况是因为主线程没有等到子线程计算完毕就就把它们的结果相加输出，答案肯定不对，所以要做的是等待子线程计算完成主线程再把它们的结果相加并输出，可以使用 CountDownLatch，代码如下：

package application;

import java.util.concurrent.*;

class QiuheThread extends Thread{

int index; //线程编号

int sum=0; //保存每个线程所求的20个数的和值

CountDownLatch countDownLatch;

QiuheThread(int nindex, CountDownLatch countDownLatch){

index=nindex;

this.countDownLatch = countDownLatch;

}

public void run() { //线程执行体

for(int i=0;i20;i++) {

sum=sum+index*20+i+1; 

} 

// 标记计算结束

countDownLatch.countDown();

}

}

public class test1 { 

public static void main(String args[]) { 

CountDownLatch countDownLatch = new CountDownLatch(5);

QiuheThread q[]=new QiuheThread[5];

for(int i=0;i5;i++){

q[i]=new QiuheThread(i, countDownLatch);

q[i].start();

}

try {

// 等待子线程结束

countDownLatch.await();

} catch (InterruptedException e) {

}

System.out.println("sum="+(q[0].sum+q[1].sum+q[2].sum+q[3].sum+q[4].sum));

} 

}

java 线程同步求和（100分）

// 你看看吧。。。 不懂的在问我

public class Test implements Runnable {

public static void main(String[] args) {

for (int i = 0; i 100; i++) { // 创建100个线程

Test line = new Test();

Thread t = new Thread(line, i + "");

t.start();

}

}

public void run() { // 线程

for (int i = 0; i 10; i++) { //每条线程输出的次数 如果你是10次 100个线程,如果同步,sum 应该是1000

try {

sum.list();

Thread.sleep(100);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

}

class sum {

static Integer sum = 0;

public synchronized static void list() { //synchronized 代表线程同步, 如果去掉.就会不同步

sum++;

System.out.println("我是线程" + Thread.currentThread().getName()

+ " sum---------" + sum);

}

}

java线程求和的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java求和程序、java线程求和的信息别忘了在本站进行查找喔。