并发计算问题

最近看到一个 关于并发计算的问题：并行计算类 Node 有成员变量double类型A,B,C构造方法 
public Demp(double num1, double num2)
{
 this.A = num1;
 this.B = num2;
}

现在有一组超过10000个Node的实例集合。
按照 C=A+B 规则，并行计算每个Node实例的C的值。
并将所有实例的C的值进行合计。

备注：计算C的值时，保留两位小数。

1. 首先创建一个名称为Demo的类

   public class Demo
   {
   	public long A = 0l;//定义长整型变量 A ，赋初值 0，后面的L表示0是长整型。
   
   	public long B = 0l;
   
   	public Demo(long num1, long num2)
   	{
   		this.A = num1;
   		this.B = num2;
   	}
   
   	public long sum()
   	{
   		return (A+B);
   	}
   }

   
   
2. 其次创建一个名称为Thread的类

   import java.util.concurrent.Callable;
   
   public class Thread implements Callable<Boolean>
   {
   	private Demo node = null;
   	
   	private Long[] sum = null;
   	
   	public Thread(Demo n, Long[] result)
   	{
   		this.node = n;
   		this.sum = result;
   	}
   	
   	
   	@Override
   	public Boolean call() throws Exception
   	{
   		long num = node.sum();
   		synchronized (this.sum)
   		{
   			this.sum[0] += num;
   		}
   		return true;
   	}
   
   }
   

3. 接着创建一个名称为Test的类

   import java.util.ArrayList;
   import java.util.List;
   import java.util.concurrent.Callable;
   import java.util.concurrent.ExecutorService;
   import java.util.concurrent.Executors;
   
   public class Test
   {
   	public static void main(String[] args)
   	{
   		ArrayList<Demo> demoList = new ArrayList<Demo>();
   		for (int i = 0; i < 100000; i++)
   		{
   			demoList.add(new Demo((long) i, (long) i + 1));
   		}
   
   		System.out.println(getSum1(demoList));
   		
   		// 并行计算所有demo中A+B的值的合计
   		System.out.println(getSum2(demoList));
   	}
   
   	private static String getSum1(ArrayList<Demo> demoList)
   	{
   		long start = System.currentTimeMillis();//开始时间
   		long result = 0;
   		for (Demo demo : demoList)
   		{
   			result += demo.sum();
   		}
   		System.out.println("执行时间:" + (System.currentTimeMillis() - start));
   		return String.valueOf(result);//转换成字符串类型
   	}
   
   	private static String getSum2(ArrayList<Demo> demoList)
   	{
   		long start = System.currentTimeMillis();
   		Long[] result = new Long[]{0l};定义数组 A ，赋初值 0，后面的L表示0是长整型。
   		try
   		{
   			// 创建一个固定大小的线程池
   			ExecutorService exe = Executors.newFixedThreadPool(5);
   			List<Callable<Boolean>> callList = new ArrayList<Callable<Boolean>>();
   			for (Demo demo : demoList)
   			{
   				callList.add(new Thread(demo, result));
   			}
   			exe.invokeAll(callList);// 批量提交不限时任务
   			exe.shutdown();//结束任务
   		}
   		catch (Exception e)
   		{
   			e.printStackTrace();//在命令行打印异常信息在程序中出错的位置及原因。
   		}
   		System.out.println("并行执行时间:" + (System.currentTimeMillis() - start));
   		return String.valueOf(result[0]);
   	}
   }
   

4. 最后运行输出结果：