今天积极备战面试，可是网上搜索完面试题后我奔溃了。。。。好像还挺难。
这是其中一道，我想了很久，如果是真的面试，估计就挂了。。。。。。。。
声明一个共享数组，起两个线程，两个线程分别隔一段时间(可以写一个随机数)，
     给数组中添加数据，每一个线程为数组添加3个数据即可。

我写的好麻烦，不知道谁有简便算法

1. public class Demo {
   
2. 
   
3.         public static void main(String[] args) {
   
4.                 Res res = new Res();
   
5.                 new Thread(new MyThread1(res)).start();
   
6.                 new Thread(new MyThread2(res)).start();
   
7. 
   
8.         }
   
9. 
   
10. }
    
11. 
    
12. class Res {
    
13.         private int arr[] = new int[10];
    
14.         private int index = 0;
    
15.         private boolean flag = true;
    
16. 
    
17.         public boolean isFlag() {
    
18.                 return flag;
    
19.         }
    
20. 
    
21.         public void setFlag(boolean flag) {
    
22.                 this.flag = flag;
    
23.         }
    
24. 
    
25.         public synchronized void add1() {
    
26.                 if (flag) {
    
27.                         try {
    
28.                                 wait();
    
29.                         } catch (InterruptedException e) {
    
30.                                 e.printStackTrace();
    
31.                         }
    
32.                 }
    
33.                 arr[index] = (int) (Math.random() * 10);
    
34.                 System.out.println(Thread.currentThread().getName() + ":" + arr[index]);
    
35.                 index++;
    
36.                 setFlag(!flag);
    
37.                 notify();
    
38. 
    
39.         }
    
40. 
    
41.         public synchronized void add2() {
    
42.                 if (!flag) {
    
43.                         try {
    
44.                                 wait();
    
45.                         } catch (InterruptedException e) {
    
46.                                 e.printStackTrace();
    
47.                         }
    
48.                 }
    
49.                 arr[index] = (int) (Math.random() * 10);
    
50.                 System.out.println(Thread.currentThread().getName() + ":" + arr[index]);
    
51.                 index++;
    
52.                 setFlag(!flag);
    
53.                 notify();
    
54. 
    
55.         }
    
56. }
    
57. 
    
58. class MyThread1 implements Runnable {
    
59.         private Res res;
    
60.         private int count = 0;
    
61. 
    
62.         public MyThread1(Res res) {
    
63.                 this.res = res;
    
64.         }
    
65. 
    
66.         @Override
    
67.         public void run() {
    
68.                 while (count < 3) {
    
69.                         res.add1();
    
70.                         count++;
    
71.                 }
    
72.         }
    
73. 
    
74. }
    
75. 
    
76. class MyThread2 implements Runnable {
    
77.         private Res res;
    
78.         private int count = 0;
    
79. 
    
80.         public MyThread2(Res res) {
    
81.                 this.res = res;
    
82.         }
    
83. 
    
84.         @Override
    
85.         public void run() {
    
86.                 while (count < 3) {
    
87. 
    
88.                         res.add2();
    
89.                         count++;
    
90.                 }
    
91.         }
    
92. }
    

复制代码

1. import java.lang.reflect.Array;
   
2. import java.util.ArrayList;
   
3. import java.util.Arrays;
   
4. import java.util.List;
   
5. import java.util.Random;
   
6. import java.util.concurrent.CopyOnWriteArrayList;
   
7. import java.util.concurrent.Executor;
   
8. import java.util.concurrent.Executors;
   
9. import java.util.concurrent.ScheduledExecutorService;
   
10. import java.util.concurrent.ScheduledThreadPoolExecutor;
    
11. import java.util.concurrent.TimeUnit;
    
12. 
    
13. //声明一个共享数组，起两个线程，
    
14. //两个线程分别隔一段时间(可以写一个随机数)，给数组中添加数据，
    
15. //每一个线程为数组添加3个数据即可。
    
16. public class Test21 {
    
17.         //写一个类实现Runnable接口，创建两个Thread对象传入该类
    
18.            //多线程操作共享数组需要同步synchronize
    
19.        public static void main(String...args){
    
20.                fillArray fa = new fillArray();
    
21.                Thread t1 = new Thread(fa);
    
22.                Thread t2 = new Thread(fa);
    
23.                t1.start();
    
24.                t2.start();
    
25.        }
    
26. }
    
27. class fillArray implements Runnable{
    
28.     //定义共享数组
    
29.         int[] arr = new int[6];
    
30.     Random r = new Random();
    
31.     int count = 0;
    
32.         public void run() {
    
33.                 // 同步代码块
    
34.                 synchronized(r){
    
35.                         while(count<arr.length){
    
36.                                 int num = r.nextInt(20);
    
37.                                 System.out.println(Thread.currentThread().getName()+"向数组中加入了"+num);
    
38.                                 arr[count] = num;
    
39.                                 count++;
    
40.                                 try {
    
41.                                         r.wait(500);
    
42.                                 } catch (Exception e) {
    
43.                                         e.printStackTrace();
    
44.                                 }
    
45.                         }
    
46.                 }
    
47.                 System.out.println(Arrays.toString(arr));
    
48.         }
    
49.        
    
50. }

复制代码