public class xiancheng {
         public static int[]arr=new int[6];
        public  int dex=0;
        public static void main(String[] args) throws Exception {

        new Thread(new thread()).start();
        new Thread(new thread()).start();
        Thread.sleep(2200);
        for(int a:arr){
                System.out.println(a);
        }
        }

}
class thread implements Runnable{
         int[]arr=new int[6];
         int dex=0;
        @Override
        public void run() {
                try {
                        Thread.sleep(3000);
                } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
                for(int i=0;i<3;i++){
                        int num=(int) (Math.random()*10+1);
                        synchronized(xiancheng.class){
                        arr[dex]=num;
                        System.out.println(arr[dex]);
                        dex++;
                        }
                }
        }
        
}
没有达到效果 这是哪的问题

在学野马 发表于 2014-10-4 18:32
这个不算是共享吧

我的思路：
1.将数组【15】，操作数组的指针 pos ，和向数组中添加元素的方法add 封装成一个类myArray.
2.建立一个Runnable的实现类myArrayAdd, 此类中初始就有一个myArray资源，run方法中分3次调用add方法，即向数组中存随机数。
3.主函数中建立一个myArrayAdd对象ma（只有一个），建立4个线程操作，注意由于只有一个对象，所以操作的是同一个数组。只是调用了4次run（），即向数组中add了12次随机数。

希望有用。

JerryJava 发表于 2014-10-4 16:56
这样吧， 楼主先看一遍多线程部分的银行存钱的例子，思路是一样的。
以下是我的代码，参考下吧～ 希望能帮 ...

这个不算是共享吧

在学野马 发表于 2014-10-4 16:49
当我把睡眠时间改了以后 为什么会出现好几个0的现象

是说又改了还是说上面的？
如果是number加上static后又改了睡眠时间的话，就要看主线程打印的时候其余两个线程是否已经执行完毕，若没有则会输出0.
如果说的上面的，是因为两个线程修改的都是数组前三个元素的值。

这样吧， 楼主先看一遍多线程部分的银行存钱的例子，思路是一样的。
以下是我的代码，参考下吧～ 希望能帮到你。

1. package com.JerryJava;
   
2. 
   
3. import java.util.Random;
   
4. 
   
5. public class interview_04_2 {
   
6. 
   
7.         /**
   
8.          * @param args
   
9.          */
   
10.         public static void main(String[] args) {
    
11.                 // TODO Auto-generated method stub
    
12.                 myArrayAdd ma = new myArrayAdd();
    
13. //                ma.run();
    
14.                 new Thread(ma).start();
    
15.                 new Thread(ma).start();
    
16.                 new Thread(ma).start();
    
17.                 new Thread(ma).start();
    
18.         }
    
19. 
    
20. }
    
21. class myArray
    
22. {
    
23.         private int[] arr = new int[15];
    
24.         private int pos = 0 ;
    
25.         public synchronized void add(int num)
    
26.         {
    
27.                 int time = new Random().nextInt(10)+1;
    
28.                 try {
    
29.                         Thread.sleep(time*200);
    
30.                 } catch (InterruptedException e) {
    
31.                         // TODO Auto-generated catch block
    
32.                         e.printStackTrace();
    
33.                 }
    
34.                 arr[pos]= num;
    
35.                
    
36.                 //System.out.println("arr::"+pos+"__"+arr[2]);
    
37.                 System.out.println("arr"+pos+"=::"+arr[pos]);
    
38.                 pos++;
    
39.         }
    
40. }
    
41. class myArrayAdd implements Runnable
    
42. {
    
43.         private myArray ma = new myArray();
    
44.         public void run(){
    
45.                 for(int i=1 ; i<=3 ; i++)
    
46.                 {
    
47.                         int num = new Random().nextInt(20);
    
48.                         //System.out.println(num);
    
49.                         ma.add(num);
    
50.                 }
    
51.                
    
52.                
    
53.         }
    
54. }

复制代码

水竹 发表于 2014-10-4 16:39
number并不是static的，所以两个新线程中都各有一个number，所以其实他们操作的都是数组中的前三个元素， ...

当我把睡眠时间改了以后 为什么会出现好几个0的现象

在学野马 发表于 2014-10-4 16:01
package lianxi;

public class xiancheng implements Runnable{

number并不是static的，所以两个新线程中都各有一个number，所以其实他们操作的都是数组中的前三个元素，先执行的线程写入的内容被后执行的线程重新赋值了。要想把数组写满，把number修饰为static的即可。

水竹 发表于 2014-10-4 15:38
没看出来你想要什么效果，三个线程各自操作各自的数组，不涉及任何对共享资源的操作，三个线程还有一段时间 ...

package lianxi;

public class xiancheng implements Runnable{
        private static int[] arr=new int[6];
        int number=0;
        public static void main(String[] args) throws Exception{
                new Thread(new xiancheng()).start();
                new Thread(new xiancheng()).start();
                Thread.sleep(2000);
                for(int i:arr){
                        System.out.println(i);
                }
               
        }

        @Override
        public void run() {

                try {
                        Thread.sleep(500);
                } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
                for(int i=0;i<3;i++){
                        int sum=(int) (Math.random()*10+1);
                        synchronized(xiancheng.class){
                                arr[number]=sum;
                                System.out.println(arr[number]);
                                number++;
                        }
                }
        }
}
这样呢 怎么 也没有共享

没看出来你想要什么效果，三个线程各自操作各自的数组，不涉及任何对共享资源的操作，三个线程还有一段时间在同时睡觉。两个新线程循环体里面数组角标变化明明和循环码子完全相同，还是弄成了两个变量。主线程数组默认初始化，所以打印六个零，两个新线程各自打印数组中前三个元素，这样的输出不是理所当然么，根本看不出你期望的效果是什么。