多线程系列（七）------ synchronized关键字简单使用以及可重入性

r囧r小猫 2022-02-26 11:26 164阅读 0赞

# 一、简介 #

本文主要介绍synchronize的简单使用以及一些判断锁是否可以并发的例子。最后又分析了一下synchronize的可重入特性。

本文主要参考：

[skywang12345][] 博主的文章  [Java多线程系列--“基础篇”04之 synchronized关键字][Java_--_04_ synchronized]

[noodleprince][] 博主的文章 [ Java可重入锁如何避免死锁][Java]

以及自己的部分整理。

尊重原创，转载声明。

# 二、同步**原理** #

*  **在java中，每一个对象有且仅有一个同步锁。**这也意味着，同步锁是依赖于对象而存在。
 *  **当我们调用某对象的synchronized方法时，就获取了该对象的同步锁。**例如，synchronized(obj)就获取了“obj这个对象”的同步锁。
 *  **不同线程对同步锁的访问是互斥的。**也就是说，某时间点，对象的同步锁只能被一个线程获取到！通过同步锁，我们就能在多线程中，实现对“对象/方法”的互斥访问。 例如，现在有两个线程A和线程B，它们都会访问“对象obj的同步锁”。假设，在某一时刻，线程A获取到“obj的同步锁”并在执行一些操作；而此时，线程B也企图获取“obj的同步锁” —— 线程B会获取失败，它必须等待，直到线程A释放了“该对象的同步锁”之后线程B才能获取到“obj的同步锁”从而才可以运行。

# **三、使用方式** #

## 3.1 写法 ##

*  同步普通方法

public synchronized void fun1() {
        System.out.println("同步普通方法");
    }

*  同步静态方法

public static synchronized void fun2() {
        System.out.println("同步静态方法");
    }

*  同步代码块

public void fun3() {
        synchronized (this) {
            System.out.println("同步代码块");
        }
    }

## 3.2 注意 ##

*  synchronized代码块中的this是指的同步锁。也可以将this替换成其他对象。
 *  如果synchronized修饰的是同步代码块或者非静态的同步方法，则this代表的同步锁是实例锁，即当前对象，如果修饰的是静态的同步方法或者当前对象是单例对象，则同步锁代表的就是类锁，即当前类。
 *  synchronized代码块可以更精确的控制冲突限制访问区域，有时候表现更高效率, 使用时要合理控制同步范围。

# **四、实例锁和全局锁** #

## 4.1 实例锁(对象锁) ##

*  锁在某一个实例对象上；
 *  如果该类是单例，那么该锁也具有全局锁的概念； 
 *   实例锁对应的就是synchronized关键字。

## 4.2 全局锁(类锁) ##

*  该锁针对的是类，无论实例多少个对象，那么线程都共享该锁；
 *  全局锁对应的就是static synchronized（或者是锁在该类的class或者classloader对象上）；

### 4.3 例子 ###

*  有一个类，里面包含了四个同步方法，俩个普通类型，俩个静态类型。请基于该类来判断四种组合是否可以同时访问

/**
     * @author qjwyss
     * @date 2019/4/1
     * @description
     */
    
    public class Something {
    
        public synchronized void isSyncA() {
            method();
        }
    
        public synchronized void isSyncB() {
            method();
        }
    
        public static synchronized void cSyncA() {
            method();
        }
    
        public static synchronized void cSyncB() {
            method();
        }
    
        private static void method() {
            try {
                for (int i = 0; i < 5; i++) {
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + "输出的值：" + i);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

*  组合一：俩个线程共用同一个锁，分别访问俩个非静态的同步方法

public class Demo0-1 {
    
        public static void main(String[] args) {
    
            Something x = new Something();
            Something y = new Something();
    
            Thread thread1 = new Thread(() -> {
                x.isSyncA();
            });
    
            Thread thread2 = new Thread(() -> {
                x.isSyncB();
            });
    
            thread1.start();
            thread2.start();
        }
    
    }

输出结果：

Thread-0输出的值：0
    Thread-0输出的值：1
    Thread-0输出的值：2
    Thread-0输出的值：3
    Thread-0输出的值：4
    Thread-1输出的值：0
    Thread-1输出的值：1
    Thread-1输出的值：2
    Thread-1输出的值：3
    Thread-1输出的值：4

结果说明： 不能同时访问，因为isSyncA()和isSyncB()都是访问同一个对象(对象x)的同步锁！

*  组合二：俩个线程使用不同的对象锁，分别访问同一个非静态的同步方法

public class Demo0-2 {
    
        public static void main(String[] args) {
    
            Something x = new Something();
            Something y = new Something();
    
            Thread thread1 = new Thread(() -> {
                x.isSyncA();
            });
    
            Thread thread2 = new Thread(() -> {
                y.isSyncA();
            });
    
            thread1.start();
            thread2.start();
        }
    
    }

输出结果：

Thread-1输出的值：0
    Thread-0输出的值：0
    Thread-1输出的值：1
    Thread-0输出的值：1
    Thread-1输出的值：2
    Thread-0输出的值：2
    Thread-0输出的值：3
    Thread-1输出的值：3
    Thread-1输出的值：4
    Thread-0输出的值：4

结果说明： 可以同时访问，因为是俩个不同的对象锁。

*  组合三： 俩个线程分别访问俩个不同的静态同步方法，使用俩个不同对象

public class Demo4-3 {
    
        public static void main(String[] args) {
    
            Something x = new Something();
            Something y = new Something();
    
            Thread thread1 = new Thread(() -> {
                x.cSyncA();
            });
    
            Thread thread2 = new Thread(() -> {
                y.cSyncB();
            });
    
            thread1.start();
            thread2.start();
        }
    
    }

输出结果：

结果说明： 不能同时访问。因为虽说使用的是俩个不同的对象，可是此处访问的是俩个同步的静态方法，此时的锁是全局锁/类锁，都是Something这个类。另外，也不推荐使用实例对象来调用静态方法，此处仅仅是为了模拟这种情况。

*  组合四：俩个线程一个调用非静态的同步方法，一个调用静态的同步方法，前者使用对象做锁，后者使用类做锁

public class Demo4-4 {
    
        public static void main(String[] args) {
    
            Something x = new Something();
    
            Thread thread1 = new Thread(() -> {
                x.isSyncA();
            });
    
            Thread thread2 = new Thread(() -> {
                Something.cSyncB();
            });
    
            thread1.start();
            thread2.start();
        }
    
    }

输出结果：

Thread-0输出的值：0
    Thread-1输出的值：0
    Thread-1输出的值：1
    Thread-0输出的值：1
    Thread-0输出的值：2
    Thread-1输出的值：2
    Thread-1输出的值：3
    Thread-0输出的值：3
    Thread-0输出的值：4
    Thread-1输出的值：4

结果说明：可以同时访问。因为一个是对象锁，一个是全局锁  对象锁和全局锁不一样。

## **4.4 原则** ##

### **4.4.1 原则** ###

*  当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时，其他线程对**“该对象”的该“synchronized方法”或者“synchronized代码块”的访问**将被阻塞。
 *  当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时，其他线程仍然**可以访问“该对象”的非同步代码方法或非同步代码块**。
 *  当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时，其他线程对**“该对象”的其他的“synchronized方法”或者“synchronized代码块”的访问**将被阻塞。

### 4.4.2 例子 ###

*  俩个**共用一把锁**(此处this就是同一个runnable对象)的线程访问同一个synchronized方法或代码块，先持有锁的线程先访问，等第一个线程释放锁之后第二个线程才可以访问该同步方法或代码块。

/**
     * @author qjwyss
     * @date 2019/3/30
     * @description
     */
    public class Demo1-1 {
    
        public static void main(String[] args) {
    
            Runnable runnable = new Runnable() {
                @Override
                public void run() {
                    synchronized (this) {
                        try {
                            for (int i = 0; i < 5; i++) {
                                Thread.sleep(100);
                                System.out.println(Thread.currentThread().getName() + "输出的值：" + i);
                            }
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            };
    
    
            Thread thread1 = new Thread(runnable);
            Thread thread2 = new Thread(runnable);
    
            thread1.start();
            thread2.start();
    
        }
    
    }

输出结果如下，始终不会出现交叉输出的情况：

如果你真的理解了的话，请看下面这种情况，看看输出结果是否和你预想的一样，如果一样，那就是真的理解了：

/**
     * @author qjwyss
     * @date 2019/3/30
     * @description
     */
    class MyThread extends Thread {
        @Override
        public void run() {
            synchronized (this) {
                try {
                    for (int i = 0; i < 5; i++) {
                        Thread.sleep(100);
                        System.out.println(Thread.currentThread().getName() + "输出的值：" + i);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    
    public class Demo1-2 {
    
        public static void main(String[] args) {
    
            Thread thread1 = new MyThread();
            Thread thread2 = new MyThread();
    
            thread1.start();
            thread2.start();
        }
    }

输出结果如下：

Thread-1输出的值：0
    Thread-0输出的值：0
    Thread-1输出的值：1
    Thread-0输出的值：1
    Thread-0输出的值：2
    Thread-1输出的值：2
    Thread-0输出的值：3
    Thread-1输出的值：3
    Thread-1输出的值：4
    Thread-0输出的值：4

此处为什么又会交叉输出呢？  因为： 他们并非公用同一把锁，线程thread1使用的锁是thread1对象，即this是thread1对象，线程thread2使用的锁是thread2对象，即this是thread2对象。现在清楚的话那就是真的理解了。

*  当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时，其他线程仍然**可以访问“该对象”的非同步代码方法或非同步代码块**。

/**
     * @author qjwyss
     * @date 2019/4/1
     * @description
     */
    
    class Count {
    
        public synchronized void syncMethod() {
            try {
                for (int i = 0; i < 5; i++) {
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + "输出的值：" + i);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
        public void nonSyncMethod() {
            try {
                for (int i = 0; i < 6; i++) {
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + "输出的值：" + i);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
    }
    
    public class Demo2 {
    
        public static void main(String[] args) {
    
            Count count = new Count();
    
            Thread thread1 = new Thread(() -> {
                count.syncMethod();
            });
    
            Thread thread2 = new Thread(() -> {
                count.nonSyncMethod();
            });
    
            thread1.start();
            thread2.start();
        }
    
    }

输出结果如下：

Thread-1输出的值：0
    Thread-0输出的值：0
    Thread-1输出的值：1
    Thread-0输出的值：1
    Thread-0输出的值：2
    Thread-1输出的值：2
    Thread-0输出的值：3
    Thread-1输出的值：3
    Thread-0输出的值：4
    Thread-1输出的值：4
    Thread-1输出的值：5

结果如上。虽然俩个线程共用了同一把锁，但是线程1对同步方法持有锁之后并不影响线程2对该对象的非同步方法的访问。

*  当一个线程访问“某对象”的“synchronized方法”或者“synchronized代码块”时，其他线程对**“该对象”的其他的“synchronized方法”或者“synchronized代码块”的访问**将被阻塞。

/**
     * @author qjwyss
     * @date 2019/4/1
     * @description
     */
    
    class Count {
    
        public synchronized void syncMethodA() {
            try {
                for (int i = 0; i < 5; i++) {
                    Thread.sleep(100);
                    System.out.println(Thread.currentThread().getName() + "输出的值：" + i);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
        public void syncMethodB() {
            synchronized (this) {
                try {
                    for (int i = 0; i < 6; i++) {
                        Thread.sleep(100);
                        System.out.println(Thread.currentThread().getName() + "输出的值：" + i);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    
    }
    
    public class Demo3 {
    
        public static void main(String[] args) {
    
            Count count = new Count();
    
            Thread thread1 = new Thread(() -> {
                count.syncMethodA();
            });
    
            Thread thread2 = new Thread(() -> {
                count.syncMethodB();
            });
    
            thread1.start();
            thread2.start();
        }
    
    }

输出结果：

Thread-0输出的值：0
    Thread-0输出的值：1
    Thread-0输出的值：2
    Thread-0输出的值：3
    Thread-0输出的值：4
    Thread-1输出的值：0
    Thread-1输出的值：1
    Thread-1输出的值：2
    Thread-1输出的值：3
    Thread-1输出的值：4
    Thread-1输出的值：5

如上，始终不会出现交叉的情况。

# 五、可重入性  #

## 5.1 例子 ##

public class Widget {
        public synchronized void doSomething(){
            // do something
        }
    }
    public class LoggingWidget extends Widget {
        public synchronized void doSomething() {
            super.doSomething();
        }
    }

这是《java并发编程实例》一书中的例子，并且书中说：“如果synchronized 不是可重入锁，那么LoggingWidget 的super.dosomething();无法获得Widget对象的锁，因为会死锁。”

## 5.2 原理 ##

乍一看好像不是这么回事，就算synchronized 不是可重入锁，可是synchronized 关键字一个在父类Widget 的方法上，另一个在子类LoggingWidget 的方法上，怎么会有死锁产生呢。

这里其实牵涉到了Java的重写。我们看子类LoggingWidget 的doSomething方法，重写了父类Widget 的doSomething方法，但是子类对象如果要调用父类的doSomething方法，那么就需要用到super关键字了。因为实例方法的调用是Java虚拟机在运行时动态绑定的，子类LoggingWidget 的对象调用doSomething方法，一定是绑定到子类自身的doSomething方法，必须用super关键字告诉虚拟机，这里要调用的是父类的doSomething方法。

子类对象，其实是持有父类Widget 的doSomething方法的，只需要使用super关键字告诉虚拟机要运行的是父类的doSomething方法，虚拟机会去调用子类对象中的父类Widget 的doSomething方法的。所以，**super关键字并没有新建一个父类的对象，比如说widget，然后再去调用widget.doSomething方法，实际上调用父类doSomething方法的还是我们的子类对象**。

那么这样就很好理解了，如果一个线程有子类对象的引用loggingWidget，然后调用loggingWidget.doSomething方法的时候，会请求子类对象loggingWidget 的对象锁；又因为loggingWidget 的doSomething方法中调用的父类的doSomething方法，**实际上还是要请求子类对象loggingWidget 的对象锁**，那么如果synchronized 关键字不是个可重入锁的话，就会在子类对象持有的父类doSomething方法上产生死锁了。正因为synchronized 关键字的可重入锁，当前线程因为已经持有了子类对象loggingWidget 的对象锁，后面再遇到请求loggingWidget 的对象锁就可以畅通无阻地执行同步方法了。

更进一步，将上面的示例代码改写一下，那么就算**synchronized** 不是可重入锁，也不会产生死锁的问题了。代码如下：

public class Widget {
        public synchronized void doSomething(){
            // do something
        }
    }
    public class LoggingWidget extends Widget {
        public synchronized void doSomething() {
            Widget widget = new Widget();
            widget.doSomething();
        }
    }

在子类的doSomething方法中，直接新建了一个父类的对象widget，然后用这个父类对象来调用父类的doSomething方法，实际上请求的是这个父类对象widget的对象锁，就不涉及到可重入锁的问题了。

# **六、**多线程系列链接 #

1.  [多线程系列（一）------ 线程的状态及转换][------]
2.  [多线程系列（二）------ 线程的创建方式][------ 1]
3.  [多线程系列（三）------ 线程常用方法][------ 2]
4.  多线程系列（四）------ 线程优先级和守护线程和终止线程的方式
5.  [多线程系列（五）------ 死锁案例以及检测方法][------ 3]
6.  多线程系列（六）------ 生产者消费者案例
7.  [多线程系列（七）------ synchronized关键字简单使用以及可重入性 ][------ synchronized]
8.  [多线程系列（八）------ synchronized关键字原理以及锁优化][------_synchronized]
9.  volatile相关
10. ThreadLocal相关
11. 锁LOCK相关系列
12. 原子类相关系列
13. 并发集合相关系列
14. 线程池相关系列

[skywang12345]: https://www.cnblogs.com/skywang12345/
[Java_--_04_ synchronized]: http://www.cnblogs.com/skywang12345/p/3479202.html
[noodleprince]: https://blog.csdn.net/noodleprince
[Java]: https://blog.csdn.net/noodleprince/article/details/79826050
[------]: https://blog.csdn.net/qq_35206261/article/details/88873820
[------ 1]: https://blog.csdn.net/qq_35206261/article/details/88887998
[------ 2]: https://blog.csdn.net/qq_35206261/article/details/89096428
[------ 3]: https://blog.csdn.net/qq_35206261/article/details/88944414
[------ synchronized]: https://blog.csdn.net/qq_35206261/article/details/88897523
[------_synchronized]: https://blog.csdn.net/qq_35206261/article/details/88953363