一个练习题，自己的算法感觉有点复杂，能不能用一个run方法实现？

1. import java.util.Random;
   
2. 
   
3. /*练习：声明一个共享数组，起两个线程，两个线程分别隔一段时间(可以写一个随机数)，
   
4. * 给数组中添加数据，每一个线程为数组添加3个数据即可。
   
5. */
   
6. public class Test11 {
   
7.         public static void main(String[] args) {
   
8.                 int [] arr = new int [6];
   
9.                 ShareArray shareArray = new ShareArray(arr);
   
10.                 Thread thread1 = new Thread(new AddValue1(shareArray));
    
11.                 Thread thread2 = new Thread(new AddValue2(shareArray));
    
12.                 thread1.start();
    
13.                 thread2.start();
    
14. 
    
15.         }
    
16. }
    
17. //定义多线程操作的资源
    
18. class ShareArray {
    
19.         int[] arr;
    
20.         int i = 0;
    
21.         boolean flag = false;
    
22. 
    
23.         ShareArray(int[] arr) {
    
24.                 this.arr = arr;
    
25.         }
    
26.         //给数组添加数据
    
27.         public void setValue(int x) {
    
28.                 arr[i] = x;
    
29.                 System.out.println(Thread.currentThread().getName() + "添加了--->"
    
30.                                 + arr[i]);
    
31.                 i++;
    
32.         }
    
33. }
    
34. //线程对资源的操作
    
35. class AddValue1 implements Runnable {
    
36.         ShareArray shareArray;
    
37.         AddValue1(ShareArray shareArray){
    
38.                 this.shareArray = shareArray;
    
39.         }
    
40. 
    
41.         @Override
    
42.         public void run() {
    
43.                 // TODO Auto-generated method stub
    
44.                 for (int i = 0; i < 3; i++) {//让线程给数组循环添加数据
    
45.                         synchronized (shareArray) {//给操作共享数据的语句加上同步，用资源类对象作为锁
    
46.                                 if (shareArray.flag){
    
47.                                         try {
    
48.                                                 shareArray.wait();
    
49.                                         } catch (InterruptedException e1) {
    
50.                                                 // TODO Auto-generated catch block
    
51.                                                 e1.printStackTrace();
    
52.                                         }
    
53.                                 }
    
54.                                 try {
    
55.                                         Thread.sleep(1000);
    
56.                                 } catch (InterruptedException e) {
    
57.                                         // TODO Auto-generated catch block
    
58.                                         e.printStackTrace();
    
59.                                 }
    
60.                                 shareArray.setValue(new Random().nextInt(10));
    
61.                                 shareArray.flag = true;
    
62.                                 shareArray.notify();
    
63.                         }
    
64.                 }
    
65.         }
    
66. 
    
67. }
    
68. 
    
69. class AddValue2 implements Runnable {
    
70.         ShareArray shareArray;
    
71.         AddValue2(ShareArray shareArray){
    
72.                 this.shareArray = shareArray;
    
73.         }
    
74. 
    
75.         @Override
    
76.         public void run() {
    
77.                 // TODO Auto-generated method stub
    
78.                 for (int i = 0; i < 3; i++) {
    
79.                         synchronized (shareArray) {
    
80.                                 if (!shareArray.flag){
    
81.                                         try {
    
82.                                                 shareArray.wait();
    
83.                                         } catch (InterruptedException e1) {
    
84.                                                 // TODO Auto-generated catch block
    
85.                                                 e1.printStackTrace();
    
86.                                         }
    
87.                                 }
    
88.                                 try {
    
89.                                         Thread.sleep(1000);
    
90.                                 } catch (InterruptedException e) {
    
91.                                         // TODO Auto-generated catch block
    
92.                                         e.printStackTrace();
    
93.                                 }
    
94.                                 shareArray.setValue(new Random().nextInt(10));
    
95.                                 shareArray.flag = false;
    
96.                                 shareArray.notify();
    
97.                         }
    
98.                 }
    
99.         }
    
100. 
     
101. }
     

复制代码

他只是说每隔一段时间存入就行了，没必要交替吧。然后共享的数组和角标可以直接放在主类中。

1. public class Gongxiang
   
2. {
   
3.         public int index=0;//在主类中设置索引并初始化以便其他类引用
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 int[] share=new int[6];//设置想要存入入局的数组
   
7.                 Gongxiang gg=new Gongxiang();//创建一个主函数对象以得到共享的索引
   
8.                
   
9.                 //创建线程并启动
   
10.                 Thread t1=new Thread(new WriteArr(share,gg),"1号线程");
    
11.                 Thread t2=new Thread(new WriteArr(share,gg),"2号线程");
    
12.                 t1.start();
    
13.                 t2.start();               
    
14.                
    
15.                 //线程执行完后才能让主函数遍历数组
    
16.                 try
    
17.                 {
    
18.                         t1.join();
    
19.                         t2.join();
    
20.                 }
    
21.                 catch(Exception e)
    
22.                 {
    
23.                         e.printStackTrace();
    
24.                 }
    
25.                
    
26.                 //遍历存入数据的数组
    
27.                 for(int i:share)
    
28.                         System.out.println(i);
    
29.         }
    
30. }
    
31. 
    
32. class WriteArr implements Runnable
    
33. {
    
34.         private int[] share;
    
35.         private Gongxiang gg;
    
36.        
    
37.         public WriteArr(int[] share,Gongxiang gg)//初始化构造函数，获取数组与主类对象
    
38.         {
    
39.                 this.share=share;
    
40.                 this.gg=gg;
    
41.         }
    
42.        
    
43.         public void run()
    
44.         {
    
45.                         for(int i=0;i<3;i++)//每个线程存3个数据
    
46.                         {
    
47.                                 try
    
48.                                 {
    
49.                                         Thread.sleep((int)(Math.random()*10));//每次睡眠一段时间再存
    
50.                                 }
    
51.                                 catch(Exception e)
    
52.                                 {
    
53.                                          e.printStackTrace();
    
54.                                 }
    
55.                                 synchronized(share)//同步加锁防止索引错误
    
56.                                 {
    
57.                                         this.share[gg.index++] = (int)(Math.random()*10);//存入随机数
    
58.                                         System.out.println(Thread.currentThread().getName()+"存入了"+share[gg.index-1]);//输出存入信息
    
59.                                 }
    
60.                         }
    
61.         }
    
62. }

复制代码

这样理解就简单多了

冥夜 发表于 2014-12-8 19:40
他只是说每隔一段时间存入就行了，没必要交替吧。然后共享的数组和角标可以直接放在主类中。
...

这样能确保每个线程存三个数而不覆盖吗？

DamonZh 发表于 2014-12-8 20:43
这样能确保每个线程存三个数而不覆盖吗？

是的，因为数组的索引是放置于主类中，而且主类对象有且只有一个，并且在更改索引的代码上加了锁，所以不会出现覆盖的问题。