如题：定义一个数组，开启两个线程，分别隔一段时间存入一个随机数，每个线程存满5个即可在论坛看到这个题，可能是自己学的还不够，求答案！！！

怎么开启两个线程啊，坤姐

1. package com.itheima;
   
2. 
   
3. import java.util.Arrays;
   
4. import java.util.Random;
   
5. 
   
6. public class Test6 {
   
7.         public static void main(String[] args) {
   
8. 
   
9.                 AddArray a = new AddArray();
   
10.                 Thread t1 = new Thread(a);
    
11.                 Thread t2 = new Thread(a);
    
12.                 t1.start();
    
13.                 t2.start();
    
14.         }
    
15. 
    
16. }
    
17. 
    
18. class AddArray implements Runnable {
    
19.         // 定义数组
    
20.         private int[] arr = new int[10];
    
21.         // 定义指针
    
22.         private int pos = 0;
    
23. 
    
24.         public void run() {
    
25.                 // 每个线程添加五个数字
    
26.                 for (int x = 0; x < 5; x++) {
    
27.                         // 获得随机数
    
28.                         int temp = new Random().nextInt();
    
29.                         synchronized (arr) {
    
30.                                 arr[pos] = temp;
    
31.                                 pos++;
    
32.                                 System.out.println(Thread.currentThread().getName()
    
33.                                                 + "...添加了..." + temp);
    
34.                                 System.out.println(Arrays.toString(arr));
    
35.                         }
    
36.                         try {
    
37.                                 Thread.sleep(500);
    
38.                         } catch (InterruptedException e) {
    
39.                                 // TODO 自动生成的 catch 块
    
40.                                 e.printStackTrace();
    
41.                         }
    
42.                 }
    
43.         }
    
44. 
    
45. }
    

复制代码

供楼主参考

不过这里好像可以不用单例 直接在main里new一个
如果用继承Thread类开线程就要用了

sk0806 发表于 2014-10-31 14:28
额，，论坛看到的这个问题

能给个链接吗

cvnmklop 发表于 2014-10-31 14:12
需求不明确啊

额，，论坛看到的这个问题

需求不明确啊

额，，，金币不够多还是问题太简单了，，大神们，求解答

1. import java.util.Random;
   
2. 
   
3. public class ShareArrThread {
   
4.    /*
   
5.    * 声明一个共享数组，起两个线程，两个线程分别隔一段时间(可以写一个随机数)，
   
6.    * 给数组中添加数据，每一个线程为数组添加3个数据即可。
   
7.    */
   
8.         public static void main(String[] args)
   
9.         {
   
10.                 final Arr arr = Arr.getArr();
    
11.                 new Thread(
    
12.                                 new Runnable()
    
13.                                 {
    
14.                                         public void run()
    
15.                                         {
    
16.                                                 for(int i = 0;i<3;i++)
    
17.                                                         arr.addA();
    
18.                                         }
    
19.                                 }
    
20.                                 ){}.start();
    
21.                                 new Thread(
    
22.                                                 new Runnable()
    
23.                                                 {
    
24.                                                         public void run()
    
25.                                                         {
    
26.                                                                 for(int i = 0;i<3;i++)
    
27.                                                                         arr.addB();
    
28.                                                         }
    
29.                                                 }
    
30.                                                 ){}.start();
    
31.         }
    
32. }
    
33. class Arr
    
34. {
    
35.         private Arr()
    
36.         {}
    
37.         private static Arr a = null;
    
38.         public static Arr getArr()
    
39.         {
    
40.                 if(a==null)
    
41.                         synchronized(Arr.class)
    
42.                         {
    
43.                                 if(a==null)
    
44.                                         a = new Arr();
    
45.                         }
    
46.                 return a;
    
47.         }
    
48.         int[] arr = new int[6];
    
49.         int i = -1;
    
50.         boolean flag = true;
    
51.         public synchronized void addA()
    
52.         {
    
53.                 while(flag)
    
54.                         try {
    
55.                                 wait();
    
56.                                 Thread.sleep(new Random().nextInt(2000));
    
57.                         } catch (InterruptedException e) {
    
58.                                 e.printStackTrace();
    
59.                         }
    
60.                 System.out.println(Thread.currentThread().getName()+"添加了"+(arr[++i]=new Random().nextInt(2000))+";");
    
61.                 flag = !flag;
    
62.                 notify();
    
63.         }
    
64.         public synchronized void addB ()
    
65.         {
    
66.                 while(!flag)
    
67.                         try {
    
68.                                 wait();
    
69.                                 Thread.sleep(new Random().nextInt(2000));
    
70.                         } catch (InterruptedException e) {
    
71.                                 e.printStackTrace();
    
72.                         }
    
73.                 System.out.println(Thread.currentThread().getName()+"添加了"+(arr[++i]=new Random().nextInt(2000))+";");
    
74.                 flag = !flag;
    
75.                 notify();
    
76.         }
    
77. }

复制代码