synchronized 是 Java 语言中解决并发问题的一种罕用伎俩，它也被咱们亲切的称之为“Java 内置锁”，由此可见其位置之高。然而 synchronized 却有着多种用法，当它润饰不同对象时，其意义也是不同的，上面咱们一起来看。
synchronized 用法
synchronized 能够用来润饰一般办法、静态方法和代码块。
① 润饰一般办法
/** * synchronized 润饰一般办法 */public synchronized void method() { // .......}当 synchronized 润饰一般办法时，被润饰的办法被称为同步办法，其作用范畴是整个办法，作用的对象是调用这个办法的对象。
② 润饰静态方法
/** * synchronized 润饰静态方法 */public static synchronized void staticMethod() { // .......}当 synchronized 润饰动态的办法时，其作用的范畴是整个办法，作用对象是调用这个类的所有对象。
③ 润饰代码块
为了缩小锁的粒度，咱们能够抉择在一个办法中的某个局部应用 synchronized 来润饰（一段代码块），从而实现对一个办法中的局部代码进行加锁，实现代码如下：
public void classMethod() throws InterruptedException { // 前置代码... // 加锁代码 synchronized (SynchronizedExample.class) { // ...... } // 后置代码...}以上代码在执行时，被润饰的代码块称为同步语句块，其作用范畴是大括号“{}”括起来的代码块，作用的对象是调用这个代码块的对象。
但以上代码，除了能够加锁 class 之外，还能够加锁 this，具体示例如下：
public void classMethod() throws InterruptedException { // 前置解决代码... synchronized (this) { // ...... } // 后置解决代码...}那问题来了，应用 synchronized 加锁 this 和 class 的区别是什么？不都是加锁同一个类吗？
答案还真不是，加锁 this 和 class 区别还是很大的。上面咱们通过以下 4 个示例，来看二者之间的区别。
1.加锁 class 共享一个类实例
首先，咱们创立 5 个线程，调用同一个对象下 synchronized 加锁的 class 代码，具体示例如下：
import java.util.Date;import java.util.concurrent.TimeUnit;public class SynchronizedExample { public static void main(String[] args) { // 创立以后类实例 final SynchronizedExample example = new SynchronizedExample(); // 创立 5 个线程执行工作 for (int i = 0; i < 5; i++) { new Thread(new Runnable() { @Override public void run() { try { // 调用 synchronized 润饰的 class 办法 example.classMethod(); } catch (InterruptedException e) { e.printStackTrace(); } } }).start(); } } /** * synchronized 润饰的 class 办法 * @throws InterruptedException */ public void classMethod() throws InterruptedException { synchronized (SynchronizedExample.class) { System.out.println(String.format("以后执行线程:%s,执行工夫:%s", Thread.currentThread().getName(), new Date())); TimeUnit.SECONDS.sleep(1); } }}以上程序的执行后果如下：
从上述后果能够看出，这 5 个线程共享的是同一把锁。
2.加锁 class 创立多个实例
接下来，咱们创立 5 个线程，调用不同对象下 synchronized 加锁的 class 代码，具体示例如下：
import java.util.Date;import java.util.concurrent.TimeUnit;public class SynchronizedExample { public static void main(String[] args) { // 创立 5 个线程执行工作 for (int i = 0; i < 5; i++) { new Thread(new Runnable() { @Override public void run() { try { // 创立类实例 SynchronizedExample example = new SynchronizedExample(); // 调用 synchronized 润饰的 class 办法 example.classMethod(); } catch (InterruptedException e) { e.printStackTrace(); } } }).start(); } } /** * synchronized 润饰的 class 办法 * @throws InterruptedException */ public void classMethod() throws InterruptedException { synchronized (SynchronizedExample.class) { System.out.println(String.format("以后执行线程:%s,执行工夫:%s", Thread.currentThread().getName(), new Date())); TimeUnit.SECONDS.sleep(1); } }}以上程序的执行后果如下：
从上述后果能够看出，尽管是不同的对象，但它们应用的依然是同一把锁。
3.加锁 this 共享一个类实例
接下来，咱们创立 5 个线程，调用 synchronized 加锁 this 的示例。首先咱们这 5 个线程调用同一个对象的加锁办法，示例代码如下：
import java.util.Date;import java.util.concurrent.TimeUnit;public class SynchronizedExample { public static void main(String[] args) { // 创立以后类实例 final SynchronizedExample example = new SynchronizedExample(); // 创立 5 个线程执行工作 for (int i = 0; i < 5; i++) { new Thread(new Runnable() { @Override public void run() { try { // 调用 synchronized 润饰的 this 办法 example.thisMethod(); } catch (InterruptedException e) { e.printStackTrace(); } } }).start(); } } /** * synchronized 润饰的 this 办法 * @throws InterruptedException */ public void thisMethod() throws InterruptedException { synchronized (this) { System.out.println(String.format("以后执行线程:%s,执行工夫:%s", Thread.currentThread().getName(), new Date())); TimeUnit.SECONDS.sleep(1); } }}以上程序的执行后果如下：
从上述后果能够看出，以上线程应用的都是同一把锁。
4.加锁 this 创立多个类实例
最初一个示例最为非凡，咱们应用 synchronized 加锁 this，让这 5 个线程调用各自创建对象的办法，具体示例如下：
import java.util.Date;import java.util.concurrent.TimeUnit;public class SynchronizedExample { public static void main(String[] args) { // 创立 5 个线程执行工作 for (int i = 0; i < 5; i++) { new Thread(new Runnable() { @Override public void run() { try { // 创立（多个）类实例 SynchronizedExample example = new SynchronizedExample(); // 调用 synchronized 润饰的 this 办法 example.thisMethod(); } catch (InterruptedException e) { e.printStackTrace(); } } }).start(); } } /** * synchronized 润饰的 this 办法 * @throws InterruptedException */ public void thisMethod() throws InterruptedException { synchronized (this) { System.out.println(String.format("以后执行线程:%s,执行工夫:%s", Thread.currentThread().getName(), new Date())); TimeUnit.SECONDS.sleep(1); } }}以上程序的执行后果如下：
从上述后果能够看出，当应用 synchronized 加锁 this 时，如果线程调用的不是同一个对象，那么这些线程之间应用的锁都是本人独立的锁，这个后果就和 synchronized 加锁 class 的后果齐全不同了。
总结
通过以上 4 个示例咱们能够得出结论，当应用 synchronized 加锁 class 时，无论共享一个对象还是创立多个对象，它们用的都是同一把锁，而应用 synchronized 加锁 this 时，只有同一个对象会应用同一把锁，不同对象之间的锁是不同的。
本系列举荐文章
- 并发第一课：Thread 详解
- Java中用户线程和守护线程区别这么大？
- 深刻了解线程池 ThreadPool
- 线程池的7种创立形式，强烈推荐你用它...
- 池化技术达到有多牛？看了线程和线程池的比照吓我一跳！
- 并发中的线程同步与锁
- volatile 和 synchronized 的区别
- 轻量级锁肯定比重量级锁快吗？
- 这样终止线程，居然会导致服务宕机？
- SimpleDateFormat线程不平安的5种解决方案！
- ThreadLocal不好用？那是你没用对！
- ThreadLocal内存溢出代码演示和起因剖析！
- Semaphore自白：限流器用我就对了！
- CountDownLatch：别浪，等人齐再团！
- CyclicBarrier：人齐了，司机就能够发车了！
关注公号「Java中文社群」查看更多有意思、涨常识的 Java 并发文章。