目的

本文只针对synchronized的使用进行描述以及代码演示。具体原理不做深入探讨

简介

synchronized 在多线程并发环境下，通过加锁的形式保证了数据的一致性，锁存在Java对象头里。如果对象是数组类型，则虚拟机用3个Word（字宽）存储对象头，如果对象是非数组类型，则用2字宽存储对象头。在32位虚拟机中，一字宽等于四字节，即32bit。

对象锁、代码块锁的使用

先看一段示例代码
代码块一

  2. public class T {
  4.     private Integer count = 0;
  5.     private Object o = new Object();
  7.     public void m() {
  8.         //任何线程要执行下面的代码，必须先拿到o的锁
  9.         synchronized (o) {
  10.             for (int i = 0; i < 100000; i++) {
  11.                 count++;
  12.             }
  13.         }
  14.     }
  17.     public static void main(String[] args) throws InterruptedException {
  18.         // 采用 CountDownLatch 保证了所有线程同时开始，同时结束
  19.         CountDownLatch start = new CountDownLatch(1);
  20.         CountDownLatch end = new CountDownLatch(10);
  21.         T t = new T();
  22.         for (int i = 0; i < 10; i++) {
  23.             new Thread(() -> {
  24.                 try {
  25.                     start.await();
  26.                     t.m();
  27.                 } catch (InterruptedException e) {
  28.                     e.printStackTrace();
  30.                 } finally {
  31.                     end.countDown();
  32.                 }
  34.             }).start();
  35.         }
  36.         start.countDown();
  37.         end.await();
  38.         System.out.println(Thread.currentThread().getName() + " count = " + t.count);
  39.     }
  40. }
  42. 输出结果：
  43. main count = 1000000
  44. 结果正确。

结论：我们在多线程并发环境下，为了保证所有线程对某个对象、基本类型的操作保持唯一性，需要去拿到一个全局不变的唯一锁，只有锁对象不变才能保证计算变量的唯一性。
以上写法还可以直接锁当前对象不需要new 一个object
代码块二

  1. public class T {
  3.     private Integer count = 0;
  4.     public void m() {
  5.         //任何线程要执行下面的代码，必须先拿到当前对象的锁
  6.         //锁的是当前对象
  7.         synchronized (this) {
  8.             for (int i = 0; i < 100000; i++) {
  9.                 count++;
  10.             }
  11.         }
  12.     }
  13.     public static void main(String[] args) throws InterruptedException {
  14.         // 采用 CountDownLatch 保证了所有线程同时开始，同时结束
  15.         CountDownLatch start = new CountDownLatch(1);
  16.         CountDownLatch end = new CountDownLatch(10);
  17.         T t = new T();
  18.         for (int i = 0; i < 10; i++) {
  19.             new Thread(() -> {
  20.                 try {
  21.                     start.await();
  22.                     t.m();
  23.                 } catch (InterruptedException e) {
  24.                     e.printStackTrace();
  26.                 } finally {
  27.                     end.countDown();
  28.                 }
  30.             }).start();
  31.         }
  32.         start.countDown();
  33.         end.await();
  34.         System.out.println(Thread.currentThread().getName() + " count = " + t.count);
  35.     }
  36. }

上面的代码 还可以直接在m 方法上加锁，同样锁的是当前对象，如下代码
代码块三

  2. public class T {
  4.     private Integer count = 0;
  6.     public synchronized void m() {
  7.         //任何线程要执行下面的代码，必须先拿到当前对象的锁
  8.         //锁的是当前对象
  9.         for (int i = 0; i < 100000; i++) {
  10.             count++;
  11.         }
  12.     }
  15.     public static void main(String[] args) throws InterruptedException {
  16.         // 采用 CountDownLatch 保证了所有线程同时开始，同时结束
  17.         CountDownLatch start = new CountDownLatch(1);
  18.         CountDownLatch end = new CountDownLatch(10);
  19.         T t = new T();
  20.         for (int i = 0; i < 10; i++) {
  21.             new Thread(() -> {
  22.                 try {
  23.                     start.await();
  24.                     t.m();
  25.                 } catch (InterruptedException e) {
  26.                     e.printStackTrace();
  28.                 } finally {
  29.                     end.countDown();
  30.                 }
  32.             }).start();
  33.         }
  34.         start.countDown();
  35.         end.await();
  36.         System.out.println(Thread.currentThread().getName() + " count = " + t.count);
  37.     }
  38. }

此代码块与代码块2 一样，锁的都是当前对象，代码块1为可自由锁定根据实际情况定的对象，一般采用代码块1 的方法进行代码块的锁定，这样减少了锁定的范围提高了代码的性能。通俗理解只要保证每次拿到的是同一个锁即可，对象变了锁也就变了。

以下代码为错误的例子**

  1. public class T {
  3.     private Integer count = 0;
  5.     public void m() {
  6.         //任何线程要执行下面的代码，必须先拿到当前对象的锁
  7.         //锁的是当前对象
  8.         synchronized (count) {
  9.             for (int i = 0; i < 100000; i++) {
  10.                 count++;
  12.             }
  13.         }
  14.     }
  17.     public static void main(String[] args) throws InterruptedException {
  18.         // 采用 CountDownLatch 保证了所有线程同时开始，同时结束
  19.         CountDownLatch start = new CountDownLatch(1);
  20.         CountDownLatch end = new CountDownLatch(10);
  21.         T t = new T();
  22.         for (int i = 0; i < 10; i++) {
  23.             new Thread(() -> {
  24.                 try {
  25.                     start.await();
  26.                     t.m();
  27.                 } catch (InterruptedException e) {
  28.                     e.printStackTrace();
  30.                 } finally {
  31.                     end.countDown();
  32.                 }
  34.             }).start();
  35.         }
  36.         start.countDown();
  37.         end.await();
  38.         System.out.println(Thread.currentThread().getName() + " count = " + t.count);
  39.     }
  40. }
  42. 输出结果：
  43. main count = 185200  错误的结果，我们想要的是 1000000