多线程系列第（五）篇---synchronized和volatile

1.问题描述

假设银行有个电子账户，专门用来统计存款总额，存款来源于很多个存储用户。

代码示例

public class VolatileDemo {
private  volatile static int number;  //volatile 不能保证原子性

private static void add(){
    number++;
}

public static void main(String[] args) {
    
    for(int i=0;i<1000;i++){
        new Thread(new Runnable() {
            
            public void run() {
                add();
            }
        }).start();
    }
    
    try {
        Thread.sleep(2000);
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    System.out.println(number);  //输出结果可能是999
    //因为num++不是原子性操作,可以分解为三个步骤，读取num的值，+1,写入工作内存
  }
}

运行结果
1000或者999

程序分析
1.number 表示银行的电子账户金额
2.for循环的1000个线程代表一个储户
3.add代表存钱操作，假设每次存1块钱
4.主线程在睡眠了2秒后再去查金额，就是为了让所有的线程都运行完毕，再去查询。

2.问题产生的原因

表面上看是多线程操作产生的问题，要分析深层次的原因，需要先知道以下几个知识点

2.1 java内存模型

1.所有共享变量都存储在主内存中
2.每个线程都有自己独立的工作内存，里面保存该线程使用到的变量的副本（主内存中该变量的一份拷贝）
3.不同的线程无法访问对方工作内存中的变量，线程之间的传值需要通过主内存来实现

2.2 原子性和可见性

原子性
原子是世界上最小的单位，具有不可分割的性质，原子性说的是某个操作具有不可分割性，如a=0，有的操作是可以被分割的，如a++，它实际上是a=a+1，可以分为三个操作，取值，+1，将值写入工作内存

可见性
可见性说的是线程之间的可见性，一个线程修改的状态对另一个线程是可见的。也就是一个线程修改的结果，另一个线程马上就能看到

2.3 原因分析

上述程序电子账户金额number开始时，我并没有加入volatile 关键字

原因一：number的不可见性
由于每个线程修改的只是工作内存中的值，可能没有及时将工作内存中的值刷新到主内存中
比如线程1读取到num值为99，加1后变成100，这时候这个值并没有及时刷新到主内存中，线程2读取到的值仍然是99，加1后num的值还是100

解决办法，想办法使得number具有可见性，这时就会联想到volatile。volatile变量在每次被线程访问时，都强迫从主内存中重读该变量的值，当该变量发生变化时，又会强迫线程将该变量的值刷新到主内存中
但是加上之后，仍然会得到999的结果，仔细看add的代码，发现number++，这个操做不具有原子性

原因二：number++不具有原子性
number++，在计算机指令中可以分为三个操作

1. 读取number的值
2. 将number加1
3. 将number的值写入工作内存中

假设线程A，执行操作1，读取到num的值为99，此时被线程B占用运行权，线程B读取num的值为99，继续执行操作2和3，num的值变为100，线程B执行结束，运行权重回线程A，虽然主内存中num的值已经是100了，但是线程A的操作1已经在之前就做了，这时会直接执行2和3，执行结束后num的值仍然为100，结果当然会出现问题

结论：必须要同时保证原子性和可见性才不会出现上面的问题，这就引出了今天我要介绍的主角之一：synchronized

3. synchronized

3.1 volatile 和 synchronized 比较

• volatile用来修饰变量，synchronized用来修饰方法或代码块
• volatile本质是告诉jvm当前变量在寄存器中是不确定的，需要从主内存中读取，synchronized是对对象加锁，从而保证synchronized块同一时间，只能由一个线程访问
• volatile只能保证可见性，而synchronized则既可以保证变量修改的可见性，也能保证代码块的原子性
• volatile不会造成线程阻塞，而synchronized会造成线程阻塞，即争夺锁的使用权

3.2 synchronized代码示例

public class SynchronizedDemo {
private static int number;

private synchronized static void add() {
    number++;
}

public static void main(String[] args) {

    for (int i = 0; i < 1000; i++) {
        new Thread(new Runnable() {

            public void run() {
                add();
            }
        }).start();
    }

    try {
        Thread.sleep(2000);
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    System.out.println(number);
  }
}

运行结果
1000，运行了20多次，最上面的基本运行个10几次就会出现999的结果

3.3 synchronized其他一些需要注意的地方

• synchronized(xx.class)与synchronized(this)的区别
  前者锁的是该类的所有实例对象，后者锁的是类对象(类的其中一个对象)。
  若类对象被锁，则类对象的所有同步方法全被锁；
  若实例对象被锁，则该实例对象的所有同步方法全被锁

• synchronized methods(){} 与synchronized（this）{}
  synchronized methods(){} 与synchronized（this）{}之间没有什么区别。
  只是synchronized methods(){} 便于阅读理解，而synchronized（this）{}可以更精确的控制冲突限制访问区域，有时候表现更高效率。

• synchronized(xx.class) 等价于 synchronized static methods(){}

• synchronized(this) 等价于 synchronized methods(){}