JAVA锁之一（synchronized快速记忆法）

# JAVA锁之一（synchronized快速记忆法）

一· 概述

在 JAVA 中有很多锁，都可以实现多线程编程中实现数据的锁定，防止并发问题，本章节主要简单介绍下 synchronized .

二· 介绍

2.1 修饰场景

synchronized 是用于修饰用的加锁关键词，可以用于方法和代码块中，可以简单理解为锁住对象对应的指针地址，只要区分好指针对象是否同一个地址，就可以判断两个线程的锁是否互斥。

synchronized 是可重入的，意思就是当前线程获得锁之后，其他线程就无法获得锁进入，但是当前线程自己还可以再次获得锁多次进入。

由于使用比较简单，下面就简单列举一张表格，表示锁的应用场景以及说明。

final A a = new A()
synchronized(a){...}

final (static) A a = new A()
synchronized(a){...}

快速记忆法：可以简单理解成锁住对象是对象指针值。

2.2 代码样例

以下的代码，请观察哪些是互斥的

// http://www.easysb.cn/2019/05/341.html

public class LockTest {
    @Getter
    private final A a = new A();

    private static int TICK = 5;

    public void bFun1() {
        synchronized (a) {
            int count = 0;
            while (count++ < TICK) {
                System.out.println("hello from LockTest::bFun1");
                ThreadUtils.sleepQuitely(1000);
            }
        }
    }

    public void bFun2() {
        synchronized (a.getClass()) {
            int count = 0;
            while (count++ < TICK) {
                System.out.println("hello from LockTest::bFun2");
                ThreadUtils.sleepQuitely(1000);
            }
        }
    }

    @Data
    public static class A {
        private final Object a = new Object();

        private synchronized void aFun1() {
            int count = 0;
            while (count++ < TICK) {
                System.out.println("hello from A::aFun1");
                ThreadUtils.sleepQuitely(1000);
            }
        }

        private void aFun2() {
            synchronized(this) {
                int count = 0;
                while (count++ < TICK) {
                    System.out.println("hello from A::aFun2");
                    ThreadUtils.sleepQuitely(1000);
                }
            }
        }

        private synchronized static void aFun3() {
            int count = 0;
            while (count++ < TICK) {
                System.out.println("hello from A::aFun3");
                ThreadUtils.sleepQuitely(1000);
            }
        }
        private synchronized static void aFun4() {
            synchronized (A.class) {
                int count = 0;
                while (count++ < TICK) {
                    System.out.println("hello from A::aFun4");
                    ThreadUtils.sleepQuitely(1000);
                }
            }
        }
    }

    public static void main(String[] args) {
        LockTest t = new LockTest();
        List<Thread> list = Lists.newArrayList();
        list.add(new Thread(() -> {
            t.bFun1();
        }));
        list.add(new Thread(() -> {
            t.bFun2();
        }));
        list.add(new Thread(() -> {
            t.getA().aFun1();
        }));
        list.add(new Thread(() -> {
            t.getA().aFun2();
        }));
        list.add(new Thread(() -> {
            t.getA().aFun3();
        }));
        list.add(new Thread(() -> {
            t.getA().aFun4();
        }));
        for (Thread thread : list) {
            thread.start();
        }
        ThreadUtils.sleepQuitely(1000 * 30);
    }
}

按照上面地址的快速记忆理解方案，那么可以简单归纳如下：

• LockTest::bFun1 锁住的对象是成员变量 a 地址。
• LockTest::bFun2 锁住的对象是A的类对象 a.getClass() ，也就是 A.class 地址，是全局唯一的。
• A::aFun1 修饰普通成员函数，锁住类对象实例的地址，也就是 a 地址。
• A::aFun2 普通成员函数 this ，锁住类对象实例的地址，也就是 a 地址。
• A::aFun3 静态成员函数，锁住A的类对象，也就是 A.class 地址。
• A::aFun4 成员函数，锁住类对象实例的地址 A.class ，全局唯一。

从上可以看出互斥的方法如下：

• 实例 a 地址： LockTest::bFun1 , A::aFun1 , A::aFun2
• 类对象 A.class 地址： LockTest::bFun2 , A::aFun3 , A::aFun4

输出的结果可能有多种，以下是一种输出结果

hello from LockTest::bFun2
hello from LockTest::bFun1
hello from LockTest::bFun2
hello from LockTest::bFun1
hello from LockTest::bFun2
hello from LockTest::bFun1
hello from LockTest::bFun2
hello from LockTest::bFun1
hello from LockTest::bFun1
hello from LockTest::bFun2
hello from A::aFun2
hello from A::aFun4
hello from A::aFun4
hello from A::aFun2
hello from A::aFun4
hello from A::aFun2
hello from A::aFun2
hello from A::aFun4
hello from A::aFun4
hello from A::aFun2
hello from A::aFun1
hello from A::aFun3
hello from A::aFun1
hello from A::aFun3
hello from A::aFun3
hello from A::aFun1
hello from A::aFun3
hello from A::aFun1
hello from A::aFun1
hello from A::aFun3