# 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 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