一、给对象加把锁

synchronized关键字是Java唯一内置的互斥锁，通过关键字 synchronized 可以保证同一时刻只有一个线程获得某个同步代码块的执行权，但不会导致其他线程执行非同步方法时阻塞。

当获得锁的线程执行完同步代码块后，线程会将锁释放，其他由于锁占用导致阻塞的线程可以通过非公平的方式（非公平指的是获得锁的操作不是按照请求锁的顺序，即没有先来后到之分）获得锁，并进入同步代码块执行代码。

虽然我们通常要在方法上或是为某个代码块标记 synchronized，但实际上，JVM实现锁的逻辑是通过给对象加锁。

如果将一个成员方法标记为synchronized，那么执行这个方法时就需要给当前对象 this 加锁。对象只有一个，而synchronized方法可能有多个，因此，如果某个线程已经获得了这把锁，那么就意味着其他线程不仅没有权限执行当前方法，就连其他同步方法也无法执行，因为这些同步方法都需要获得同一个对象锁。

想要证明是锁对象其实非常简单，下面这个demo可以看出synchronized锁定的是同一个共享对象，而不是这个对象的某一个加锁方法。

import java.util.concurrent.TimeUnit;/*** 此例证明了synchronized锁是锁定的对象而不是代码片段 <br>* 类名：ObjectLockDemo<br>* 作者： mht<br>* 日期： 2018年8月27日-下午1:25:47<br>*/
public class ObjectLockDemo {public static void main(String[] args) {T t = new T();new Thread(() -> t.doSomthing(), "t1").start();new Thread(() -> t.doOtherthing(), "t2").start();}
}class T {synchronized void doSomthing() {System.out.println(Thread.currentThread().getName() + " do something start...");try {TimeUnit.SECONDS.sleep(5);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + " do something end...");}synchronized void doOtherthing() {System.out.println(Thread.currentThread().getName() + " do otherthing...start");System.out.println(Thread.currentThread().getName() + " do otherthing...end");}
}

上面这个例子非常简单。首先，我们为T类创建了两个加锁的方法doSomthing()和doOtherthing()，在主线程中，我们创建了一个 t 对象，然后通过线程 t1 调用 对象 t 的doSomthing()加锁方法，紧接着线程 t2 去调用 对象 t 的另一个加锁方法doOtherthing()，如果synchronized锁住的是方法，那么在 t1 执行的5秒内，t2 可以自由的执行doOtherthing()方法而不受限制，但是如果是锁住了对象那么线程 t2 只有当 t1 执行完成后释放了对象锁，才能去执行 doOtherthing()方法，也就证明了synchronized锁住的是 t 对象。

执行结果如下，很明显，t2 等到 t1 完成后才执行了线程，synchronized锁住的是对象。

二、synchronized用法

synchronized不论如何使用，都是直接锁住了对象，但是在写法上，却存在很多变式：

用法一：

public class A {private Object o = new Object();private int count = 10;public void m() {synchronized (o) {// 任何线程若想执行代码块中的语句，必须先拿到o的锁count--;System.out.println(Thread.currentThread().getName() + " count = " + count);}}
}

用法二：

public class A {private int count = 10;public void m() {synchronized (this) {// 任何线程若想执行代码块中的语句，必须先拿到this的锁count--;System.out.println(Thread.currentThread().getName() + " count = " + count);}}
}

synchronized锁定的是一个对象，任何代表对象的事物都可以作为synchronized参数。

用法三：

public class A {private int count = 10;public synchronized void m() { // 等同于在方法的代码执行时要synchronized(this)count--;System.out.println(Thread.currentThread().getName() + " count = " + count);}
}

上面代码就是平时比较常见的加锁方式，虽然synchronized修饰了方法，但是一定不能理解为锁定了代码块，而是执行这段代码的当前对象 this

用法四（修饰静态方法）：

public class A {private static int count = 10;public synchronized static void m() { // 这里相当于synchronized(thingking.com.A.class)count--;System.out.println(Thread.currentThread().getName() + " count = " + count);}public static void mm() {synchronized (A.class) {// 这是不可以写this，this指代对象，而静态方法是通过类来调用的，没有this对象count--;}}
}

三、互斥锁的重入性

作为一种互斥锁，synchronized可以避免并发情景下的线程乱入问题，保证了同步代码块的顺序执行。

重入性指的是，允许同一个线程重复获得已经获得的锁，不会造成阻塞，即重复进入同步代码块。重入性是互斥锁的一个重要特性，如果在同步代码块中又调用了该对象的其他同步方法，那么就会出现当前线程需要反复获取锁的情况，如果锁不允许同一个线程重入，就会出现“我拿不到我自己占用的锁”的尴尬情况，最终导致死锁！

public class T {synchronized void m() {System.out.println("m start...");try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("m end...");}public static void main(String[] args) {new TT().m();}
}class TT extends T {@Overridesynchronized void m() {System.out.println("child m start...");super.m();System.out.println("child m end...");}
}

上述代码是重入性的一种典型应用，子类中的同步方法调用父类中的同步方法，也是允许重入的。当调用子类的同步方法时，实际上锁定的是this，而子类的对象同样也可以看做是一个父类对象，因此这个锁是允许重入的，不会造成死锁。

执行结果：

四、注意异常

在默认情况下，synchronized锁在发生异常时会自动释放锁。所以在并发处理的过程中，有异常要多加小心，不然可能会发生不一致的情况。

比如，在一个web app处理过程中，多个servlet 线程共同访问同一个资源，这是如果如果异常处理不合适，在第一个线程中抛出异常，其他线程会进入同步代码块，有可能会访问到异常产生的数据，因此要非常小心的处理同步业务逻辑中的异常。

public class T {int count = 0;synchronized void m() {System.out.println(Thread.currentThread().getName() + " start...");while (true) {count++;System.out.println(Thread.currentThread().getName() + " count = " + count);try {TimeUnit.SECONDS.sleep(1);} catch (InterruptedException e) {e.printStackTrace();}if (count == 5) {int i = 1 / 0;// 此处抛出异常，锁将被释放，要想不释放，可以在这里进行catch，然后让循环继续}}}public static void main(String[] args) {T t = new T();Runnable r = new Runnable() {@Overridepublic void run() {t.m();}};new Thread(r, "t1").start();try {TimeUnit.SECONDS.sleep(3);} catch (InterruptedException e) {e.printStackTrace();}new Thread(r, "t2").start();}
}

执行结果：