很重要，对于理解 锁的是哪个对象很重要以及volatile的可见性并不能代表数据的一致性以及数据的原子性，因此volatile并非是数据安全的。

模拟银行账户读写，数据是否一致

  2. public class Account_01 {
  4.     private String name;
  5.     private int balance;
  7.     void set(String name, int balance) {
  8.         // 此处睡两秒是为了保证 main 主线程先执行一次getBalance方法
  9.         try {
  10.             Thread.sleep(2000);
  11.         } catch (InterruptedException e) {
  12.             e.printStackTrace();
  13.         }
  14.         this.name = name;
  15.         this.balance = balance;
  16.     }
  18.     int getBalance(String name) {
  19.         return balance;
  20.     }
  22.     public static void main(String[] args) throws InterruptedException {
  23.         Account_01 a = new Account_01();
  24.         new Thread(() -> a.set("zhangsan", 2), "t1").start();
  26.         System.out.println("thread t1 exe set before balance value :  " + a.getBalance("zhangsan"));
  28.         // 此处睡3 秒是为了保证线程 t1 set 方法 执行完毕
  29.         try {
  30.             TimeUnit.SECONDS.sleep(3);
  31.         } catch (InterruptedException e) {
  32.             e.printStackTrace();
  33.         }
  34.         System.out.println("thread t1 exe set after balance value:  " + a.getBalance("zhangsan"));
  35.     }
  36. }
  37. 输出结果：
  38. thread t1 exe set before balance value :  0
  39. thread t1 exe set after balance value:  2

出现了脏读现象，现在为了保持 写入的数据和读到的数据保持一致，代码做以下更改。

加synchronized

  1. public class Account_01 {
  3.     private String name;
  4.     private int balance;
  6.     synchronized void set(String name, int balance) {
  7.         // 此处睡两秒是为了保证 main 主线程先执行一次getBalance方法
  8.         try {
  9.             Thread.sleep(2000);
  10.         } catch (InterruptedException e) {
  11.             e.printStackTrace();
  12.         }
  13.         this.name = name;
  14.         this.balance = balance;
  15.     }
  17.     synchronized int getBalance(String name) {
  18.         return balance;
  19.     }
  21.     public static void main(String[] args) throws InterruptedException {
  22.         Account_01 a = new Account_01();
  23.         new Thread(() -> a.set("zhangsan", 2), "t1").start();
  25.         System.out.println("thread t1 exe set before balance value :  " + a.getBalance("zhangsan"));
  27.         // 此处睡3 秒是为了保证线程 t1 set 方法 执行完毕
  28.         try {
  29.             TimeUnit.SECONDS.sleep(3);
  30.         } catch (InterruptedException e) {
  31.             e.printStackTrace();
  32.         }
  33.         System.out.println("thread t1 exe set after balance value:  " + a.getBalance("zhangsan"));
  36.     }
  37. }
  39. 输出结果：
  40. thread t1 exe set before balance value :  2
  41. thread t1 exe set after balance value:  2

读和写结果是一致的，此处说明了 synchronized 锁定的是当前对象，当 我们去调用get 方法时提示有锁，需要等待set方法执行完毕之后才可以执行 get方法。 重点，方法上的锁是对象的。

为啥不用volatile 呢， 试试看下输出结果。

  1. public class Account_01 {
  3.     private String name;
  4.     private volatile int balance;
  6.     synchronized void set(String name, int balance) {
  7.         // 此处睡两秒是为了保证 main 主线程先执行一次getBalance方法
  8.         try {
  9.             Thread.sleep(2000);
  10.         } catch (InterruptedException e) {
  11.             e.printStackTrace();
  12.         }
  13.         this.name = name;
  14.         this.balance = balance;
  15.     }
  17.      int getBalance(String name) {
  18.         return balance;
  19.     }
  21.     public static void main(String[] args) throws InterruptedException {
  22.         Account_01 a = new Account_01();
  23.         new Thread(() -> a.set("zhangsan", 2), "t1").start();
  25.         System.out.println("thread t1 exe set before balance value :  " + a.getBalance("zhangsan"));
  27.         // 此处睡3 秒是为了保证线程 t1 set 方法 执行完毕
  28.         try {
  29.             TimeUnit.SECONDS.sleep(3);
  30.         } catch (InterruptedException e) {
  31.             e.printStackTrace();
  32.         }
  33.         System.out.println("thread t1 exe set after balance value:  " + a.getBalance("zhangsan"));
  36.     }
  37. }
  39. 输出结果：
  40. thread t1 exe set before balance value :  0
  41. thread t1 exe set after balance value:  2

输出结果 是读和写不一致，再一次说明了 volatile 只能保持数据的可见性，并不能说明数据的一致性，synchronized 才可以保证数据的原子性和一致性。
用了 synchronized 之后还需要用volatile 吗？ 不需要。synchronized 已经保证了多线程之间数据的一致性了。

模拟多线程写，用map存

  2. public class Account_01 {
  4.     private String name;
  5.     private volatile int balance;
  7.     private Map<String, Integer> map = new HashMap<>();
  9.     synchronized void set(String name, int balance) {
  10.         balance = (Objects.isNull(map.get(name)) ? 0 : map.get(name)) + balance;
  11.         map.put(name, balance);
  13.     }
  15.     synchronized int getBalance(String name) {
  16.         return (Objects.isNull(map.get(name)) ? 0 : map.get(name));
  17.     }
  19.     public static void main(String[] args) throws InterruptedException {
  20.         Account_01 a = new Account_01();
  22.         CountDownLatch start = new CountDownLatch(1);
  23.         CountDownLatch end = new CountDownLatch(20);
  24.         for (int i = 0; i < 20; i++) {
  25.             new Thread(() -> {
  26.                 try {
  27.                     start.await();
  28.                     a.set("zhangsan", 2);
  29.                 } catch (InterruptedException e) {
  30.                     e.printStackTrace();
  31.                 } finally {
  32.                     end.countDown();
  33.                 }
  34.             }, "t1").start();
  35.         }
  37.         start.countDown();
  38.         end.await();
  39.         System.out.println("输出结果： " + a.getBalance("zhangsan"));
  41.     }
  42. }
  44. 输出结果：
  45. 输出结果：  40  // get 方法加锁了，等到 set 完成释放锁之后才拿到锁执行get 方法获取到值

是否为同一把锁

  2. @SuppressWarnings("all")
  3. public class Account_01 {
  5.     private String name;
  6.     private volatile int balance;
  8.     private ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
  10.     void set(String name, int balance) {
  11.         synchronized (this) {
  12.             balance = (Objects.isNull(map.get(name)) ? 0 : map.get(name)) + balance;
  13.         }
  14.         map.put(name, balance);
  15.     }
  17.     synchronized int getBalance(String name) {
  18.         return (Objects.isNull(map.get(name)) ? 0 : map.get(name));
  19.     }
  21.     public static void main(String[] args) throws InterruptedException {
  22.         for (int n = 0; n < 500000; n++) {
  23.             Account_01 a = new Account_01();
  24.             CountDownLatch start = new CountDownLatch(1);
  25.             CountDownLatch end = new CountDownLatch(20);
  26.             for (int i = 0; i < 20; i++) {
  27.                 new Thread(() -> {
  28.                     try {
  29.                         start.await();
  30.                         a.set("zhangsan", 2);
  31.                     } catch (InterruptedException e) {
  32.                         e.printStackTrace();
  33.                     } finally {
  34.                         end.countDown();
  35.                     }
  36.                 }, "t1").start();
  37.             }
  39.             start.countDown();
  40.             end.await();
  41.             if (a.getBalance("zhangsan") != 40) {
  42.                 System.out.println("Incorrect result output: " + a.getBalance("zhangsan"));
  43.             }
  44.             System.out.println("Correct result output: " + a.getBalance("zhangsan"));
  45.         }
  46.     }
  47. }
  49. 输出结果：
  50. Correct result output: 40
  51. Correct result output: 40
  52. Incorrect result output: 38
  53. Correct result output: 38
  54. Correct result output: 40
  55. Correct result output: 40
  56. Incorrect result output: 38
  57. Correct result output: 38
  58. Correct result output: 40
  59. Correct result output: 40
  60. Correct result output: 40
  61. Correct result output: 40
  62. Correct result output: 40
  63. Correct result output: 40
  64. Correct result output: 40
  65. Correct result output: 40‘
  67. 很显然输出结果里面有读写不一致的情况。这个代码里面我们用到了ConcurrentHashMap 为啥还读写不一致呢，个人认为 读和写并不是同一把锁导致的。所以要体现出读写一致，必定需要使用同一把锁