1. import java.util.Random;
   
2. 
   
3. public class RunDeMo extends Thread {
   
4. 
   
5.         public static void main(String[] args) throws Exception {
   
6.                 // share用于保存2个线程添加的数据
   
7.                 String[] share = new String[6];
   
8.                 Thread t1 = new Thread(new AddData(share), "线程A");
   
9.                 Thread t2 = new Thread(new AddData(share), "线程B");
   
10.                 t1.start();
    
11.                 t2.start();
    
12. 
    
13.                 // 当2个线程执行完，才执行下面的main线程程序
    
14.                 t2.join();
    
15.                 t1.join();
    
16. 
    
17.                 // 遍历share保存的数据
    
18.                 for (int i = 0; i < share.length; i++) {
    
19.                         System.out.println(Thread.currentThread().getName() + "--"
    
20.                                         + share[i]);
    
21. 
    
22.                 }
    
23.         }
    
24. 
    
25. }
    
26. 
    
27. class AddData implements Runnable {
    
28. 
    
29.         private String[] share;
    
30. 
    
31.         public AddData(String[] share) {
    
32.                 this.share = share;
    
33. 
    
34.         }
    
35. 
    
36.         @Override
    
37.         public void run() {
    
38.                 String[] data = { "第一个数据", "第二个数据", "第三个数据" };
    
39.                 int index = 0;
    
40.                 synchronized (share) {
    
41.                         for (int i = 0; i < data.length; i++) {
    
42.                                 try {
    
43.                                         Thread.sleep((new Random().nextInt(10) + 1) * 10);
    
44.                                 } catch (InterruptedException e) {
    
45.                                         e.printStackTrace();
    
46.                                 }
    
47.                                 share[index++] = Thread.currentThread().getName() + ":"
    
48.                                                 + data[i];
    
49.                         }
    
50.                 }
    
51.         }
    
52. }

复制代码

定义两个线程同时运行三次代码。
为什么只能读出来B的值A去哪了？
该线程怎么修改？

1.synchronized是多个线程共同访问一个“对象”的某个数据是所起到的保护限制，你创建了两个AddData对象，那么对于两个线程所执行的对象是不同的，线程拥有资源也就不同（也就是属性不共用）
2.每个线程中对象的index在方法run内部，属于局部变量，每个线程start都会执行run方法，也就是都会临时创建一个index=0，这样对于数组share的0,1,2位置重复赋值2次，修改代码如下：

1. package temp;
   
2. 
   
3. import java.util.Random;
   
4. 
   
5. public class Demo2 extends Thread {
   
6. 
   
7.         public static void main(String[] args) throws Exception {
   
8.                 // share用于保存2个线程添加的数据
   
9.                 String[] share = new String[6];
   
10.                 AddData addData = new AddData(share);
    
11.                 Thread t1 = new Thread(addData, "线程A");
    
12.                 Thread t2 = new Thread(addData, "线程B");
    
13.                 t1.start();
    
14.                 t2.start();
    
15. 
    
16.                 // 当2个线程执行完，才执行下面的main线程程序               
    
17.                 t1.join();
    
18.                 t2.join();
    
19. 
    
20.                 // 遍历share保存的数据
    
21.                 for (int i = 0; i < share.length; i++) {
    
22.                         System.out.println(Thread.currentThread().getName() + "--"
    
23.                                         + share[i]);
    
24. 
    
25.                 }
    
26.         }
    
27. 
    
28. }
    
29. 
    
30. class AddData implements Runnable {
    
31. 
    
32.         private String[] share;
    
33. 
    
34.         public AddData(String[] share) {
    
35.                 this.share = share;
    
36. 
    
37.         }
    
38.         int index = 0;
    
39.         @Override
    
40.         public void run() {
    
41.                 String[] data = { "第一个数据", "第二个数据", "第三个数据" };
    
42.                
    
43.                 synchronized (share) {
    
44.                         for (int i = 0; i < data.length; i++) {
    
45.                                 try {
    
46.                                         Thread.sleep((new Random().nextInt(10) + 1) * 10);
    
47.                                 } catch (InterruptedException e) {
    
48.                                         e.printStackTrace();
    
49.                                 }
    
50.                                 share[index++] = Thread.currentThread().getName() + ":"
    
51.                                                 + data[i];
    
52.                         }
    
53.                 }
    
54.         }
    
55. }

复制代码