Java多线程之同步锁定--volatile关键字、原子类
-
-
- 1volatile非原子的特性
- 2使用原子类进行i操作
- 3原子类也并不完全安全
-
使用volatile关键字增加了实例变量在多个线程之间的可见性。但volatile关键字最致命的缺点是不支持原子性。
下面将关键字synchronized和volatile进行一下比较:
1.)关键字volatile是线程同步的轻量级实现，所以volatile性能肯定比synchronized要好，并且volatile只能修饰于变量，而synchronized可以修饰方法，以及代码块。随着JDK新版本的发布，synchronized关键字在执行效率上得到很大提升，在开发中使用synchronized关键字的比率还是比较大的。
2)多线程访问volatile不会发生阻塞，而synchronized会出现阻塞。
3)volatile能保证数据的可见性，但不能保证原子性;而synchronized可以保证原子性，也可以间接保证可见性，因为它会将私有内存和公共内存中的数据做同步。此知识点在后面有实验做论证。
4)再次重申一下，关键字volatile解决的是变量在多个线程之间的可见性;而synchronized关键字解决的是多个线程之间访问资源的同步性。
线程安全包含原子性和可见性两个方面，Java的同步机制都是围绕这两个方面来确保线程安全的。
1、volatile非原子的特性
关键字volatile虽然增加了实例变量在多个线程之间的可见性，但它却不具备同步性，那么也就不具备原子性。下面用项目来进行测试。
1.使用volatile ，方法没有synchronized
public class MyThread extends Thread {
public volatile static int count; //使用volatile
private static void addCount() {
for (int i=0; i<100; i++) {
count++;
}
System.out.println("count=" + count);
}
public void run() {
addCount();
}
}
public class Run {
public static void main(String[] args) throws InterruptedException {
MyThread[] myThreadArray = new MyThread[100];
for (int i=0; i<100; i++) {
myThreadArray[i] = new MyThread();
}
for (int i=0; i<100; i++) {
myThreadArray[i].start();
}
}
}……
count=9599
count=9899
count=9899
count=9899
2.将上面的MyThread类修改，方法使用synchronized
public class MyThread extends Thread {
public volatile static int count; //使用volatile
//注意这个例子里一定要加static关键字
//这样的synchronized与static锁的内容就是MYThread.java类了，也就达到同步的效果了
private synchronized static void addCount() {
for (int i=0; i<100; i++) {
count++;
}
System.out.println("count=" + count);
}
public void run() {
addCount();
}
}……
count=9700
count=9800
count=9900
count=10000
在本示例的意图中，如果在方法private static void addCount()前加人synchronized同步关键字，也就没有必要再使用volatile关键字来声明count变量了。
关键字volatile主要使用的场合是在多个线程中可以感知实例变量被更改了，并且可以获得最新的值使用，也就是用多线程读取共享变量时可以获得最新值使用。
关键字volatile提示线程每次从共享内存中读取变量，而不是从私有内存中读取，这样就保证了同步数据的可见性。但在这里需要注意的是:如果修改实例变量中的数据，比如i++，也就是i=i+ 1，则这样的操作其实并不是一个原子操作，也就是非线程安全的。表达式i++的操作步骤分解如下:
1)从内存中取出i的值;
2)计算i的值;
3)将i的值写到内存中。
假如在第2步计算值的时候，另外一个线程也修改i的值，那么这个时候就会出现脏数据。解决的办法其实就是使用synchronized关键字，这个知识点在前面的案例中已经介绍过了。所以说volatile本身并不处理数据的原子性，而是强制对数据的读写及时影响到主内存的。
原因是Java的自动封箱和解箱操作在作怪。
这里的i++实际上是i = new Integer(i+1)，所以执行完i++后，i已经不是原来的对象了，同步块自然就无效了。
其它基本类型的封装类，如Short、Long等等也不能作为同步对象
用图来演示一下使用关键字volatile时出现非线程安全的原因。变量在内存中工作的过程如图所示。
由上，我们可以得出以下结论。
1)read和load阶段:从主存复制变量到当前线程工作内存;
2)use和assign阶段:执行代码，改变共享变量值;
3)store和州to阶段:用工作内存数据刷新主存对应变量的值。
2、使用原子类进行i++操作
除了在i++操作时使用synchronized关键字实现同步外，还可以使用AtomicInteger原子类进行实现。
原子操作是不能分割的整体，没有其他线程能够中断或检查正在原子操作中的变量。一个原子(atomic)类型就是一个原子操作可用的类型，它可以在没有锁的情况下做到线程安全(thread-safe).
public class AddCountThread extends Thread {
private AtomicInteger count = new AtomicInteger(0); // 原子类
public void run() {
for (int i=0; i<10000; i++) {
System.out.println(count.incrementAndGet());
}
}
}
public class Run {
public static void main(String[] args) throws InterruptedException {
AddCountThread countService = new AddCountThread();
Thread t1 = new Thread(countService);
t1.start();
Thread t2 = new Thread(countService);
t2.start();
Thread t3 = new Thread(countService);
t3.start();
Thread t4 = new Thread(countService);
t4.start();
Thread t5 = new Thread(countService);
t5.start();
}
}……
49995
49996
49997
49998
49999
50000
成功累加到50000
3、原子类也并不完全安全
原子类在具有有逻辑的情况下输出结果也具有随机性。
public class MyService {
public static AtomicLong aiRef = new AtomicLong();
public void addNum() { //在这个例子中，这里如果不加synchronized，输出的结果是随机的
System.out.println(Thread.currentThread().getName() + " 加了100之后的值是： "
+ aiRef.addAndGet(100));
aiRef.addAndGet(1);
}
}
public class MyThread extends Thread {
private MyService myService;
public MyThread(MyService myService) {
this.myService = myService;
}
public void run() {
myService.addNum();
}
}
public class Run {
public static void main(String[] args) throws InterruptedException {
MyService service = new MyService();
MyThread[] array = new MyThread[5];
for (int i=0; inew MyThread(service);
}
for (int i=0; i1000);
System.out.println(service.aiRef.get());
}
} Thread-3 加了100之后的值是： 100
Thread-4 加了100之后的值是： 201
Thread-0 加了100之后的值是： 302
Thread-1 加了100之后的值是： 502
Thread-2 加了100之后的值是： 402
505
出现这样的情况是因为addAndGet()方法是原子的，但方法和方法之间的调用却不是原子的。解决这样的问题必须要用同步，即在MyService类的addNum()方法前加synchronized，则会有如下 的结果
Thread-1 加了100之后的值是： 100
Thread-3 加了100之后的值是： 201
Thread-2 加了100之后的值是： 302
Thread-4 加了100之后的值是： 403
Thread-0 加了100之后的值是： 504
505
public class Service {
private boolean isContinueRun = true;
public void runMethod() {
while (isContinueRun == true) {
}
System.out.println("停下来了！");
}
public void stopMethod() {
isContinueRun = false;
}
}
public class MyThread1 extends Thread {
private Service service;
public MyThread1(Service service) {
super();
this.service = service;
}
public void run() {
service.runMethod();
}
}
public class MyThread2 extends Thread{
private Service service;
public MyThread2(Service service) {
super();
this.service = service;
}
public void run() {
service.stopMethod();
}
}
public class Run {
public static void main(String[] args) throws InterruptedException {
Service service = new Service();
MyThread1 a = new MyThread1(service);
a.start();
Thread.sleep(2000);
MyThread2 b = new MyThread2(service);
b.start();
System.out.println("已经发起停止的命令了！");
}
}已经发起停止的命令了！
出现死循环
得到这个结果是各线程间的数据值没有可视性造成的，而关键字synchronized可以具有可视性。更改Service
public class Service {
private boolean isContinueRun = true;
public void runMethod() {
String anyString = new String();
while (isContinueRun == true) {
synchronized (anyString) {
}
}
System.out.println("停下来了！");
}
public void stopMethod() {
isContinueRun = false;
}
}已经发起停止的命令了！
停下来了！
可以正常退出。
关键字synchronized可以保证在同一时刻，只有一个线程可以执行某一个方法或某一个代码块。它包含两个特征:互斥性和可见性。同步synchronized不仅可以解决一个线程看到对象处于不一致的状态，还可以保证进人同步方法或者同步代码块的每个线程，都看到由同一个锁保护之前所有的修改效果。
学习多线程并发，要着重“外练互斥，内修可见”，这是掌握多线程、学习多线程并发