编写程序实现如下功能：一个线程进行如下运算：1*2+2*3+3*4+……+199*200；另一个线程每隔一段时间读取前一个线程运算结果。
我的代码如下：

1. class Resource
   
2. {
   
3.         private long sum=0;
   
4.         private int i=1;
   
5.         public void setSum(long sum)
   
6.         {
   
7.                 this.sum=sum;
   
8.         }
   
9.         public long getSum()
   
10.         {
    
11.                 return sum;
    
12.         }
    
13.         public void setI(int i)
    
14.         {
    
15.                 this.i=i;
    
16.         }
    
17.         public int getI()
    
18.         {
    
19.                 return i;
    
20.         }
    
21. }
    
22. class Yunsuan implements Runnable
    
23. {
    
24.         private Resource res;
    
25.         Yunsuan(Resource res)
    
26.         {
    
27.                 this.res=res;
    
28.         }
    
29.         public void run()
    
30.         {
    
31.                 long temp=0;
    
32.                 for (int i=1;i<200 ;i++ )
    
33.                 {
    
34.                         temp += i*(i+1);
    
35.                         res.setSum(temp);
    
36.                         try
    
37.                         {
    
38.                                 Thread.sleep(10);
    
39.                         }
    
40.                         catch (InterruptedException e)
    
41.                         {
    
42.                         }
    
43.                         res.setI(res.getI()+1);
    
44.                 }
    
45.         }
    
46. }
    
47. 
    
48. class Huoqu implements Runnable
    
49. {
    
50.         private Resource res;
    
51.         Huoqu(Resource res)
    
52.         {
    
53.                 this.res=res;
    
54.         }
    
55.        
    
56.         public void run()
    
57.         {
    
58.                 while (res.getI()<200)
    
59.                 {
    
60.                                 System.out.println(res.getSum());
    
61.                                 try
    
62.                                 {
    
63.                                         Thread.sleep(10);
    
64.                                 }
    
65.                                 catch (InterruptedException e)
    
66.                                 {
    
67.                                 }
    
68. 
    
69.                 }
    
70.                
    
71.         }
    
72. }
    
73. 
    
74. class YunsuanTest
    
75. {
    
76.         public static void main(String[] args)
    
77.         {
    
78.                 Resource res=new Resource();
    
79. 
    
80.                 Yunsuan y = new Yunsuan(res);
    
81.                 Huoqu h=new Huoqu(res);
    
82. 
    
83.                 Thread t1 = new Thread(y);
    
84.                 Thread t2 = new Thread(h);
    
85. 
    
86.                 t1.start();
    
87.                 t2.start();
    
88.                
    
89.         }
    
90. }

复制代码

能够成功运行，不知道是否会发生安全问题，另外如何能避免发生读取了相同数据的情况？
还有一个问题是：感觉代码过长，有木有办法可以优化一下？

首先我可以帮你把循环优化一下，把循环次数减半，别的吃完饭在想

1. static int j
   
2. for(int i = 2; i<=100; i+2)
   
3. {
   
4.    temp+=j*i+(++(++j))  //我忘了java有 没有自增每次加2的符号 ？
   
5. 
   
6. }
   
7. 1X2+2x3  +3X4+4X5...是由规律的，可以分组第一组(j=1)*(i=2) +(i=2)*(j+2) 每两组都符合这个规律

复制代码

其实单层循环问题不大，可是我们以后保不齐要接触到运算量较大的情况，而且也很可能在一个别的循环里调用这个方法而形成嵌套循环，这时候优化循环的意义就比较大了，尤其是要循环上千万次的情况，和在嵌入式设备上代码的效率我觉得很重要