这是在视频上看到的一段代码，volatile保证线程共享数据出错，搞不懂啊，贴出来就大神。先写一个线程类。

1. class UnsafeThread implements Runnable{
   
2.        
   
3.         private volatile int count =0;
   
4.         @Override
   
5.         public void run() {
   
6.                 count++;
   
7.                
   
8.         }
   
9.         public int GetCount(){
   
10.                 return count;
    
11.         }
    
12.        
    
13. }

复制代码

上面的代码定义了一个线程类，run方法主要实现共享资源count的自加运算。给count加上了volatile关键字，确保多个线程执行count变量的自驾动作，不会使count变量产生脏数据。
下面模拟多线程的代码：

1. public static void main(String[] args) throws InterruptedException {
   
2.                 int num=1000;//设置最大循环次数。
   
3.                 int loops =0;//防止程序陷入死循环，设置界限。
   
4.                 //主线程租
   
5.                 ThreadGroup th = Thread.currentThread().getThreadGroup();
   
6.                 while(loops++ < num){
   
7.                         UnsafeThread ut = new UnsafeThread();
   
8.                         for(int i=0;i<num;i++){
   
9.                                 new Thread(ut).start();
   
10.                         }
    
11.                         //先等15毫秒，等待活动线程数为1
    
12.                         do{
    
13.                                 Thread.sleep(15);
    
14.                         }
    
15.                         while(th.activeCount() != 1);
    
16.                                 if(ut.GetCount() != num){
    
17.                                 //出现线程不安全的情况
    
18.                                 System.out.println("循环到"+loops+"遍，出现线程不安全的情况。");
    
19.                                 System.out.println("此时count为："+ut.GetCount());
    
20.                         }
    
21.                 }
    
22.                
    
23.         }
    

复制代码

然后多运行几遍，会发现每次运行都有线程不安全的情况出现。volatile关键字不是保证线程共享数据安全么，为什么会出现这种情况。

这是在视频上看到的一段代码，volatile保证线程共享数据出错，搞不懂啊，贴出来就大神。先写一个线程类。

1. class UnsafeThread implements Runnable{
   
2.        
   
3.         private volatile int count =0;
   
4.         @Override
   
5.         public void run() {
   
6.                 count++;
   
7.                
   
8.         }
   
9.         public int GetCount(){
   
10.                 return count;
    
11.         }
    
12.        
    
13. }

复制代码

上面的代码定义了一个线程类，run方法主要实现共享资源count的自加运算。给count加上了volatile关键字，确保多个线程执行count变量的自驾动作，不会使count变量产生脏数据。
下面模拟多线程的代码：

1. public static void main(String[] args) throws InterruptedException {
   
2.                 int num=1000;//设置最大循环次数。
   
3.                 int loops =0;//防止程序陷入死循环，设置界限。
   
4.                 //主线程租
   
5.                 ThreadGroup th = Thread.currentThread().getThreadGroup();
   
6.                 while(loops++ < num){
   
7.                         UnsafeThread ut = new UnsafeThread();
   
8.                         for(int i=0;i<num;i++){
   
9.                                 new Thread(ut).start();
   
10.                         }
    
11.                         //先等15毫秒，等待活动线程数为1
    
12.                         do{
    
13.                                 Thread.sleep(15);
    
14.                         }
    
15.                         while(th.activeCount() != 1);
    
16.                                 if(ut.GetCount() != num){
    
17.                                 //出现线程不安全的情况
    
18.                                 System.out.println("循环到"+loops+"遍，出现线程不安全的情况。");
    
19.                                 System.out.println("此时count为："+ut.GetCount());
    
20.                         }
    
21.                 }
    
22.                
    
23.         }
    

复制代码

然后多运行几遍，会发现每次运行都有线程不安全的情况出现。volatile关键字不是保证线程共享数据安全么，为什么会出现这种情况。