转载

JAVA锁之一(synchronized快速记忆法)

# JAVA锁之一(synchronized快速记忆法)

一· 概述

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

二· 介绍

2.1 修饰场景

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

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

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

修饰对象 被锁住对象 是否全局唯一 简单例子
类的类型 类的类型 synchronized(Example.class) {...} , 全局锁,其他线程无法进入
类的实例 类的实例 × synchronized(this){...} 或者
final A a = new A()
synchronized(a){...}
普通成员函数 类的实例 × public synchronized void f() {...} 锁住类的实例
静态成员函数 类的类型 public static synchronized void f() {...} 锁住类的类型
(静态)成员变量 成员对象所指向的实例,一定要用final修饰,不然重新赋值后就不是同一个对象了 ×
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
原文  http://www.easysb.cn/2019/05/341.html
正文到此结束
Loading...