声明一个共享数组，起两个线程，两个线程分别隔一段时间(可以写一个随机数)，给数组中添加数据，每一个线程为数组添加3个数据即可（最好实现两个线程交替添加，不要用基础中没学过的内容），谢谢大家了

可以用锁 lock，或者synchronized 线程里面run方法  每次循环给数组副三次值就行了

没写注释，自己看看吧，我也捣鼓了好久才弄懂的。

1. import java.util.Random;
   
2. import java.util.concurrent.locks.Condition;
   
3. import java.util.concurrent.locks.Lock;
   
4. import java.util.concurrent.locks.ReentrantLock;
   
5. 
   
6. /*声明一个共享数组，起两个线程，两个线程分别隔一段时间(可以写一个随机数)，给数组中添加数据，每一个线程为数组添加3个数据即可。*/
   
7. 
   
8. public class TwoThreadToArray {
   
9.         public static void main(String[] args) {
   
10.                 final Rec2 r=new Rec2();
    
11.                 Thread t1=new Thread(new Runnable(){
    
12.                         public void run()
    
13.                         {
    
14.                                 for(int x=0;x<3;x++)
    
15.                                 {
    
16.                                         r.addFirst(x,r.num++);
    
17.                                 }
    
18.                         }
    
19.                 },"w1");
    
20.                
    
21.                 Thread t2=new Thread(new Runnable(){
    
22.                         public void run()
    
23.                         {
    
24.                                 for(int x=0;x<3;x++)
    
25.                                 {
    
26.                                         r.addSecond(x,r.num++);
    
27.                                 }
    
28.                         }
    
29.                 },"w2");
    
30.                 t1.start();
    
31.                 t2.start();
    
32.                
    
33.                 try {t1.join();        } catch (InterruptedException e) {e.printStackTrace();}
    
34.                 try {t2.join();        } catch (InterruptedException e) {e.printStackTrace();}
    
35.                 System.out.println("--------------");
    
36.                 for(int i=0;i<r.arr.length;i++)
    
37.                 {
    
38.                         System.out.println("arr["+i+"]="+r.arr[i]);
    
39.                 }
    
40.         }
    
41.        
    
42. }
    
43. class Rec2
    
44. {
    
45.         int[] arr=new int[6];
    
46.         boolean flag;
    
47.         int num;
    
48.         Lock lock=new ReentrantLock();
    
49.         Condition conditon_fr=lock.newCondition();
    
50.         Condition conditon_se=lock.newCondition();
    
51.        
    
52.         public  void addFirst(int x,int num) {
    
53.                 lock.lock();
    
54.                 try{
    
55.                         while(flag)
    
56.                         {
    
57.                                 conditon_fr.await();
    
58.                         }
    
59.                         Thread.sleep(100);
    
60.                         arr[num]=new Random().nextInt(10);
    
61.                         System.out.println(Thread.currentThread().getName()+"first--"+"arr["+num+"]"+arr[num]);
    
62.                         flag=true;
    
63.                         conditon_se.signal();
    
64.                 }
    
65.                 catch(Exception e)
    
66.                 {
    
67.                        
    
68.                 }
    
69.                 finally
    
70.                 {
    
71.                         lock.unlock();
    
72.                 }
    
73.         }
    
74.         public  void addSecond(int x,int num) {
    
75.                 lock.lock();
    
76.                 try{
    
77.                         while(!flag)
    
78.                         {
    
79.                                 conditon_se.await();
    
80.                         }
    
81.                         Thread.sleep(100);
    
82.                         arr[num]=new Random().nextInt(10);
    
83.                         System.out.println(Thread.currentThread().getName()+"second--"+"arr["+num+"]"+arr[num]);
    
84.                         flag=false;
    
85.                         conditon_fr.signal();
    
86.                 }
    
87.                 catch(Exception e)
    
88.                 {
    
89.                        
    
90.                 }
    
91.                 finally
    
92.                 {
    
93.                         lock.unlock();
    
94.                 }
    
95.         }
    
96. }

复制代码

public class NewTest4 {

        public static void main(String[] args) {
               
                ResourceType r = new ResourceType();
                ProducerType pro = new ProducerType(r);
                ConsumerType con = new ConsumerType(r);
               
                new Thread(pro, "成产者线程").start();;
                new Thread(con, "消费者线程").start();;
        }

}


class ResourceType{
       
        private int[] arr = new int[3];
        private Random random  = new Random();
        private boolean flag;
       
        Lock lock  = new ReentrantLock();
        Condition pro_condition = lock.newCondition();
        Condition cons_condition = lock.newCondition();
       
       
        public void set(){
                lock.lock();
                while(flag){
                        try {
                                pro_condition.await();
                        } catch (InterruptedException e) {
                                e.printStackTrace();
                        }
                }
                contorlArr();
                flag = true;
                cons_condition.signal();
                lock.unlock();
               
        }
        public void out(){
                lock.lock();
                while(!flag){
                        try {
                                cons_condition.await();
                        } catch (InterruptedException e) {
                                e.printStackTrace();
                        }
                }
                contorlArr();
                flag = false;
                pro_condition.signal();
                lock.unlock();
        }
       
       
        public void contorlArr(){
                arr[0]=random.nextInt();
                arr[1]=random.nextInt();
                arr[2]=random.nextInt();
                System.out.println(Thread.currentThread().getName()+"...#####...."+Arrays.toString(arr));
        }
}

class ProducerType implements Runnable{
        private ResourceType r;
        public ProducerType(ResourceType r){
               
                this.r = r;
        }
        @Override
        public void run() {
                while(true)
                r.set();
               
        }
       
}

class ConsumerType implements Runnable{
        private ResourceType r;
        public ConsumerType(ResourceType r){
                this.r = r;
        }
        @Override
        public void run() {
                while(true)
                r.out();
        }
       
}