简介关键词:Synchronize与volatile
volatile问题抛出:
让我们看到这样一个问题,我们设置一个含有boolean标志位的类Test,以及两个Runable接口实例,分别为MyThread1,MyThread2。
在MyThread1中通过while循环判断flag是否更改,如果更改便结束循环退出。
在MyThread2中改变flag值。
代码如下:
Test:
public class Test { boolean flag = true; }
MyThread1:
public class MyThread1 implements Runnable{ Test test; public MyThread1(Test test){ this.test = test; } @Override public void run() { while (test.flag){ } System.out.println(Thread.currentThread().getName()+" 我已退出"); } }
MyThread2:
public class MyThread2 implements Runnable{ Test test; public MyThread2(Test test){ this.test = test; } @Override public void run() { try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } test.flag = false; } }
main函数:
public static void main(String[] args) { Test test = new Test(); MyThread1 myThread1 = new MyThread1(test); MyThread2 myThread2 = new MyThread2(test); Thread thread1 = new Thread(myThread1); Thread thread2 = new Thread(myThread2); thread1.start(); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } thread2.start(); }
那么如何解决这样的问题呢?
很简单,使用volatile关键字。让线程不得不从主内存中读取flag值。
volatile boolean flag = true;
在我们添加volatile关键字后,Thread1便可以正常退出。
在Synchronize下的volatile:
此时我们已经了解了volatile关键字的作用,那么在我们的volatile关键字中,Synchronize有着怎样的作用呢?
其实在我们实际使用中,volatile其实也是有一些隐患的。
例如:我们创造10条线程,每条线程都使volatile修饰的int常量增加1000000次。
public class MyThread1 implements Runnable{ volatile int num = 0; @Override public void run() { for (int i = 0; i < 1000000; i++) { num++; System.out.println(Thread.currentThread().getName()+" "+num); } } public static void main(String[] args) { MyThread1 myThread1 = new MyThread1(); Thread[] arr = new Thread[10]; for (int i = 0; i < 10; i++) { arr[i] = new Thread(myThread1); } for (int i = 0; i < 10; i++) { arr[i].start(); } } }
在我们使用volatile关键字时,需要注意操作是否为原子操作,以免造成线程不安全。
其实,对于原子操作,Java已经提供了Atomic原子类来解决。其中涉及了CAS机制,在不使用Synchronize的情况下,通过比较原值与当前值,不但性能高效,并且也能达到线程安全的目的。