1. package Test;
   
2. /*声明一个共享数组，起两个线程，两个线程分别隔一段时间(可以写一个随机数)，
   
3. 给数组中添加数据，每一个线程为数组添加3个数据即可。*/
   
4. 
   
5. /*1、首先共添加6个数据，每个线程添加3个，数组需要同步
   
6.   2、随机数每个线程都用，故写在run方法中
   
7. */
   
8. 
   
9. 
   
10. import java.util.Random;
    
11. 
    
12. //声明一个共享数组，起两个线程，
    
13. //两个线程分别隔一段时间(可以写一个随机数)，给数组中添加数据，
    
14. //每一个线程为数组添加3个数据即可。
    
15. public class Test16 {
    
16.         //写一个类实现Runnable接口，创建两个Thread对象传入该类
    
17.            //多线程操作共享数组需要同步synchronize
    
18.        public static void main(String...args){
    
19.                fillArray fa = new fillArray();
    
20.                Thread t1 = new Thread(fa);
    
21.                Thread t2 = new Thread(fa);
    
22.                t1.start();
    
23.                t2.start();
    
24.               
    
25.        }
    
26. }
    
27. class fillArray implements Runnable{
    
28.     //定义共享数组
    
29.         int[] arr = new int[6];
    
30.         //产生随机数
    
31.         Random r = new Random();
    
32.         Object lock=new Object();
    
33.     int count = 0;
    
34.         public void run() {
    
35.                 // 同步代码块
    
36.                
    
37.                 while(true)
    
38.                 {
    
39.                         synchronized(lock)
    
40.                         {
    
41. 
    
42.                                 if (count<arr.length) {
    
43.                                         int num = r.nextInt(20);
    
44.                                         System.out.println(Thread.currentThread().getName()+"向数组中加入了"+num);
    
45.                                         arr[count] = num;
    
46.                                         count++;
    
47.                                         try {
    
48.                                                 this.wait();
    
49.                                         } catch (Exception e) {
    
50.                                                 e.printStackTrace();
    
51.                                         }
    
52.                                 }
    
53.                         }
    
54.                 }
    
55. 
    
56. //                System.out.println(Arrays.toString(arr));测试结果
    
57.         }
    
58.        
    
59. }
    

复制代码

如果按照sleep()来实现 的话应该不能够严格的交替运行，另外的线程不一定抢得到CPU执行权，用wait(),notify()的话应该可以实现，代码怎么写呢？    还有这个代码是如何实现的呢？

看别人代码是一件很头疼的事！

public class Demo13 {
        public static void main(String[] args) {
                fillArray fa = new fillArray();
        Thread t1 = new Thread(fa);
        Thread t2 = new Thread(fa);
        t1.start();
        t2.start();
        
}
}
class fillArray implements Runnable{
//定义共享数组
int[] arr = new int[6];
//产生随机数
Random r = new Random();
Object lock=new Object();
int count = 0;
public void run() {
         // 同步代码块
         
         while(true)   //这里循环如何停止??? 注意要设置一个可以让他停止的条件.
         {
                 synchronized(lock)  //自己定义的object对象锁.
                 {

                         if (count<arr.length) {  //这里是一个判断,但是外循环无限循环???
                                 int num = r.nextInt(20);
                                 System.out.println(Thread.currentThread().getName()+"向数组中加入了"+num);
                                 arr[count] = num;
                                 count++;
                                 try {
                          //                       lock.notifyAll();  //我在这里唤醒所有,结果唤醒别人,我自己在下面执行后睡着了...
                                         lock.wait(10); //this是谁?应该是线程对象.那么线程对象在这里都睡着谁唤醒?
                                         /**
                                          * 这里设置notifyAll没有意义.因为只有一个锁.
                                          * 具体多个锁,我没有实现.你自己可以去尝试创建多个锁对象,然后互相唤醒....
                                          * */
                                 } catch (Exception e) {
                                         e.printStackTrace();
                                 }
                                
                         }
                         else //让外循环停止条件.
                         {                             
                                 break;
                         }
                    //     System.out.println("1");
                 }
         }

//         System.out.println(Arrays.toString(arr));测试结果
        }
}

碎流 发表于 2015-1-16 13:21
我自我觉得:
wait,notify这个应该是用在拥有不同锁对象的情况下,而这个只是存在一个锁,是没有必要的,也不 ...

额，本来想通过计数器奇偶数来控制两个线程相互唤醒的，可惜失败了，还有这个题目你认为该如何实现呢？
（有个地方我i没想明白，wait时当前线程会释放同步锁并等待，这时候其他线程就可能得到这个同步锁然后执行自己的线程程序，这时可以增加notify达到唤醒第一个wait的目的。绕住了，求解）

当我遇上你 发表于 2015-1-16 12:43
好吧，时间改短了指定不对，还是wait配合notify来用靠谱，我正在想怎么实现一个对象两个线程相互唤醒怎么 ...

我自我觉得:
wait,notify这个应该是用在拥有不同锁对象的情况下,而这个只是存在一个锁,是没有必要的,也不可以实现的.
比如有两个锁,那么x锁在执行完毕之后唤醒y锁,这样可以.但是一个锁的情况下,a线程拿上锁之后,其他线程本来就
不可能执行的.只有a放弃锁,其他线程才会执行.那么a拿着锁唤醒,唤醒谁呢???

因此总结: wait,notify,notifyAll是用在多个锁之间,可能会产生死锁的情况下的.一个锁没有这个概念.一会我尝试一下多个锁的操作.可以试试看.
以上为我个人总结的,具体实现,这个还真没用多次尝试过,你如果尝试过了,告诉我结果...

碎流 发表于 2015-1-16 12:12
总结一下吧,我自己也是可以学习下
1.使用sleep不可以实现交替运行,只会存在一个等待时间特点.
2.锁对象.wai ...

好吧，时间改短了指定不对，还是wait配合notify来用靠谱，我正在想怎么实现一个对象两个线程相互唤醒怎么实现

总结一下吧,我自己也是可以学习下
1.使用sleep不可以实现交替运行,只会存在一个等待时间特点.
2.锁对象.wait(可以加入时间).
3.如何实现?首先是确定共享资源是什么?既然是共享资源是不是就应该存在一份?所以在创建的时候只有一个 fillArray对象.
4.多线程,有几个线程就Thread几次....让线程同时指向一个对象,那么这个对象中的数组,int变量等等都是共享的了.

总结:对象是实体的.线程是虚拟的.
实体的对象通过new操作来创建出来,虚拟的线程通过thread来创建出来.
所谓实现runnable,就是让类和thread协议声明共同可以执行线程数据的区域----run方法.