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

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » JAVA锁之一(synchronized快速记忆法)

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址