java用多线程实现累加求和

Posted 2023-03-24

如何JAVA使用多线程实现累加求和,麻烦给一个代码
比如说从1加到100,创建10个线程,第一个从1加到10,第2个从11加到20...线程同步执行,最后再把十个线程结果相加

参考技术A 在楼上基础上大概改一下，增加同步处理。
public class Test extends Thread
static int n = 0;
private int startNum = 0 ;
public Test (int sn)

this.startNum = sn ;

public static synchronized void addSum (int num)

n += num ;

public static void main(String[] args)
Thread [] thList = new Thread [10] ;
for (int i = 0; i < 10; i ++)
thList [i] = new Test(i * 10 + 1) ;
thList [i].start();

for (int i = 0 ; i < 10 ; i ++)

thList [i].join () ;

System.out.println ("Sum is : " + n) ;


public void run()
int sum = 0 ;
for (int i = 0; i < 10; ++i)
sum += sn + i ;

addSum (sum) ;

本回答被提问者和网友采纳 参考技术B class Thread_test extends Thread

int number;
public static int sum;
public Thread_test(int n) //构造函数

number=n;

public static synchronized void add(int num) //同步方法
sum += num;

public void run()

int count=0;
for(int i=0;i<10;i++)

count+=number+i;

System.out.println("The "+((int)number/10+1)+" time: "+count);
add(count);



public class Main
public static void main(String args[])
Thread_test test[] = new Thread_test[10];
for (int i = 0; i < 10; i++)
test[i] = new Thread_test(i*10+1);
test[i].start();
try
test[i].join();
catch (InterruptedException e)
e.printStackTrace();


System.out.println("Total is "+Thread_test.sum);


参考技术C public class Test extends Thread
static int n = 0;

public static void main(String[] args)
for (int i = 0; i < 10; ++i)
new Test().start();



public void run()
for (int i = 0; i < 10; ++i)
n++;
System.out.print(n + " ");

// System.out.print(n+" ");

参考技术D public class Thread_Demo_1
public static int a ;
static int d;
public static void main(String[] args)
Thread_Demo_1 tt = new Thread_Demo_1();
Thread_Demo_1.MyRunnable1 rt = tt.getmyrunnable();//实例化内部类(开辟空间)
tt.a = 1;
for (int i = 0; i < 4; i++)
//start().启动线程
new Thread(rt,"任务"+i).start();

tt.d =1;
for (int i = 0; i < 8; i++)
//计算20次累加的结果
d+=d;

System.out.println("累加8次的结果 = "+d);// d= 256

/*
* 内部类
*/
class MyRunnable1 implements Runnable
int g =0;
@Override
public void run()
int name = (int) Thread.currentThread().getId();
synchronized(this)
for (int i = 0; i <2; i++)
++g;//累加的次数
Thread_Demo_1.a+=Thread_Demo_1.a;//实现累加
try
Thread.sleep(1000);
catch (InterruptedException e)
// TODO Auto-generated catch block
e.printStackTrace();

//输出结果
System.out.println("Thread_Demo_1.a = "+Thread_Demo_1.a+"当前线程:"+name+"----累加了"+g+"次");




//获取内部类实例
public MyRunnable1 getmyrunnable()
return new MyRunnable1();


第5个回答  2009-04-19 自己用thread写一个不就可以了

java基础--29.线程池的实现方式2-结合Callable对象

创建Callable对象

注意：
Callable 是带泛型的接口
这里执行的泛型其实是 call() 方法的返回值类型

/*
 * 线程求和案例：实现 1~x 之间的累加求和
 */
public class MyCallable implements Callable 

    private Integer number = new Integer(0);

    public MyCallable(int number) 
        this.number = number;
    

    @Override
    public Object call() throws Exception 
        int sum = 0;
        for (int x = 1; x <= number; x++) 
            sum += x;
        
        return sum;
    



实现线程池的代码--方法2
/*
 *  A:创建一个线程池对象，控制要创建几个线程对象
 *      static ExecutorService newFixedThreadPool(int nThreads) 
 *      
 *  B:这种线程池的线程可以执行：
 *      可以执行Callable对象代表的线程
 *      做一个类实现Callable接口
 *      
 *  C:调用如下方法：
 *      <T> Future<T> submit(Callable<T> task)  
 *      
 *  D:执行完之后想结束线程，可以吗？
 *      可以
 *      
 *  E:利用返回值获取执行结果
 *      
 */


public class ExecutorsDemo 

    public static void main(String[] args) throws InterruptedException, ExecutionException 
        //1.创建线程池对象
        ExecutorService pool = Executors.newFixedThreadPool(2);

        //2.可以执行Runnable对象或者Callable对象代表的线程
        //利用Future对象接收返回值
        Future<Integer> f1 = pool.submit(new MyCallable(100));
        Future<Integer> f2 = pool.submit(new MyCallable(200));

        //3.通过Future对象的get()方法获取结果，并输出结果
        System.out.println(f1.get());
        System.out.println(f2.get());

        //4.运行结束后，结束线程池
        pool.shutdown();
    

运行结果：

5050
20100