1. package _7_26;
   
2. 
   
3. import java.util.Random;
   
4. 
   
5. public class ThreadScopeShareData2 {
   
6. 
   
7.         private static int data = 0;
   
8. //        private static Map<Thread, Integer> threadData = new HashMap<Thread, Integer>();
   
9.         public static void main(String[] args) {
   
10.                 for(int i=0;i<2;i++){
    
11.                         new Thread(new Runnable(){
    
12.                                 @Override
    
13.                                 public void run() {
    
14.                                          data = new Random().nextInt();
    
15.                                         System.out.println(Thread.currentThread().getName()
    
16.                                                         + " has put data :" + data);
    
17. //                                        threadData.put(Thread.currentThread(), data);
    
18.                                         new A().get();
    
19.                                         new B().get();
    
20.                                 }
    
21.                         }).start();
    
22.                 }
    
23.                 new Thread(new Runnable(){
    
24.                         @Override
    
25.                         public void run() {
    
26.                                  data = new Random().nextInt();
    
27.                                 System.out.println(Thread.currentThread().getName()
    
28.                                                 + " has put data :" + data);
    
29. //                                threadData.put(Thread.currentThread(), data);
    
30.                                 new A().get();
    
31.                                 new B().get();
    
32.                         }
    
33.                 }).start();
    
34.         }
    
35.         
    
36.         static class A{
    
37.                 public void get(){
    
38. //                        int data = threadData.get(Thread.currentThread());
    
39.                         System.out.println("A from " + Thread.currentThread().getName()
    
40.                                         + " get data :" + data);
    
41.                 }
    
42.         }
    
43.         
    
44.         static class B{
    
45.                 public void get(){
    
46. //                        int data = threadData.get(Thread.currentThread());                        
    
47.                         System.out.println("B from " + Thread.currentThread().getName()
    
48.                                         + " get data :" + data);
    
49.                 }               
    
50.         }
    
51. }
    

复制代码

for循环里的两个线程为什么生成的随机数都一样？？
在for循环外面新建一个线程，却能生成不同的随机数？谁给解释一下，这个很蹊跷。
---------------运行结果：------------------
Thread-0 has put data :1500315473
Thread-1 has put data :1500315473
Thread-2 has put data :445127673
A from Thread-0 get data :445127673
A from Thread-2 get data :445127673
A from Thread-1 get data :445127673
B from Thread-1 get data :445127673
B from Thread-2 get data :445127673
B from Thread-0 get data :445127673

就看前三行，前两个线程产生的随机数和后一个不同，为什么啊？按理说应该是三个都不同才对，前两个相同，还能是因为for循环里的两个线程顺便就把变量共享了么？？

1. <p>package cn.itcast.day1;</p><p> </p><p>import java.util.Random;
   
2. </p><p>public class ThreadScopeShareData2 {
   
3. 
   
4.         private static int data = 0;
   
5.         
   
6. 
   
7. //        private static Map<Thread, Integer> threadData = new HashMap<Thread, Integer>();
   
8. 
   
9.         public static void main(String[] args) {
   
10. 
    
11.                 for(int i=0;i<2;i++){
    
12. 
    
13.                         new Thread(new Runnable(){
    
14.                         
    
15. 
    
16.                                 @Override
    
17. 
    
18.                                 public void run() {
    
19.                                  synchronized(ThreadScopeShareData2.class){//加一个锁
    
20. 
    
21.                                          data = new Random().nextInt();
    
22. 
    
23.                                         System.out.println(Thread.currentThread().getName()
    
24.                                                         + " has put data :" + data);
    
25. 
    
26. //                                        threadData.put(Thread.currentThread(), data);
    
27. 
    
28.                                         new A().get();
    
29. 
    
30.                                         new B().get();
    
31.                                  }
    
32. 
    
33.                                 }
    
34. 
    
35.                         }).start();
    
36. 
    
37.                 }
    
38. 
    
39.                 new Thread(new Runnable(){
    
40. 
    
41.                         @Override
    
42. 
    
43.                         public void run() {
    
44.                          synchronized(ThreadScopeShareData2.class){//加一个锁
    
45. 
    
46.                                  data = new Random().nextInt();
    
47. 
    
48.                                 System.out.println(Thread.currentThread().getName()
    
49.                                                 + " has put data :" + data);
    
50. 
    
51. //                                threadData.put(Thread.currentThread(), data);
    
52. 
    
53.                                 new A().get();
    
54. 
    
55.                                 new B().get();
    
56.                          }
    
57. 
    
58.                         }
    
59. 
    
60.                 }).start();
    
61. 
    
62.         }
    
63. 
    
64.         
    
65. 
    
66.         static class A{
    
67. 
    
68.                 public void get(){
    
69. 
    
70. //                        int data = threadData.get(Thread.currentThread());
    
71. 
    
72.                         System.out.println("A from " + Thread.currentThread().getName()
    
73.                                         + " get data :" + data);
    
74. 
    
75.                 }
    
76. 
    
77.         }
    
78. 
    
79.         
    
80. 
    
81.         static class B{
    
82. 
    
83.                 public void get(){
    
84. 
    
85. //                        int data = threadData.get(Thread.currentThread());                        
    
86. 
    
87.                         System.out.println("B from " + Thread.currentThread().getName()
    
88.                                         + " get data :" + data);
    
89. 
    
90.                 }               
    
91.         }
    
92. 
    
93. }
    
94. </p>

复制代码

这是由于多线程共同运行造成的！你没有给他们同一个锁！三个线程一起运行，有可能线程1拿到执行权执行到data = new Random().nextInt();时，这时线程0拿到执行权，重新给data赋 一个值，打印出一个数据后执行权又被线程1抢走了，线程1接下来后面打印数据的操作，可刚打印出一个数据执行权被线程2抢走了，线程2重新给data赋值，而data是共享数据，所以接下来线程0，1，2打印出来的全是同一个数据了。
你多运行几次，有可能会出现三个不同的数据，每个数据都被打印3次。

代码如上所示，在第19行和44行给线程加同一个锁后，问题得以解决，每个线程产生不同的数据，每个数据打印3次。