Java 多线程：锁（一）
作者：Grey
原文地址：
CAS
比较与交换的意思
举个例子，内存有个值是 3，如果用 Java 通过多线程去访问这个数，每个线程都要把这个值 +1。
之前是需要加锁，即synchronized关键字来控制。但是 JUC 的包出现后，有了 CAS 操作，可以不需要加锁来处理，流程是：
第一个线程：把 3 拿过来，线程本地区域做计算加 1，然后把 4 写回去。
第二个线程：也把 3 这个数拿过来，线程本地区域做计算加 1 后，在回写回去的时候，会做一次比较，如果原来的值还是 3，那么说明这个值之前没有被打扰过，就可以把 4 写回去，如果这个值变了，假设变为了 4，那么说明这个值已经被其他线程修改过了，那么第二个线程需要重新执行一次，即把最新的 4 拿过来继续计算，回写回去的时候，继续做比较，如果内存中的值依然是 4，说明没有其他线程处理过，第二个线程就可以把 5 回写回去了。
流程图如下
CAS 会出现一个 ABA 的问题，即在一个线程回写值的时候，其他线程其实动过那个原始值，只不过其他线程操作后这个值依然是原始值。
如何来解决 ABA 问题呢？
我们可以通过版本号或者时间戳来控制，比如数据原始的版本是 1.0，处理后，我们把这个数据的版本改成变成 2.0 版本, 时间戳来控制也一样。
以 Java 为例，AtomicStampedReference这个类，它内部不仅维护了对象值，还维护了一个时间戳。当AtomicStampedReference对应的数值被修改时，除了更新数据本身外，还必须要更新时间戳。当AtomicStampedReference设置对象值时，对象值以及时间戳都必须满足期望值，写入才会成功。因此，即使对象值被反复读写，写回原值，只要时间戳发生变化，就能防止不恰当的写入。
代码示例
package git.snippets.juc;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicStampedReference;
/**
* @author <a href="mailto:410486047@qq.com">Grey</a>
* @date 2022/9/10
* @since
*/
public class ABATest {
public static void main(String[] args) throws InterruptedException {
abaCorrect();
}
private static void abaCorrect() throws InterruptedException {
AtomicStampedReference<Integer> ref = new AtomicStampedReference<>(10, 0);
Thread threadA = new Thread(() -> {
try {
int[] stamp = new int[1];
Integer value = ref.get(stamp); //同时获取时间戳和数据，防止获取到数据和版本不是一致的
System.out.println(String.format("%s 启动,当前值是:%s,版本:%s", Thread.currentThread().getName(), ref.getReference(), stamp[0]));
TimeUnit.MILLISECONDS.sleep(1000);
int newValue = value + 1;
boolean writeOk = ref.compareAndSet(value, newValue, stamp[0], stamp[0] + 1);
System.out.println(String.format("%s:%s,%s", Thread.currentThread().getName(), "10->11", writeOk ? stamp[0] + 1 : stamp[0]));
stamp = new int[1];
value = ref.get(stamp); //同时获取时间戳和数据，防止获取到数据和版本不是一致的
newValue = value - 1;
writeOk = ref.compareAndSet(value, newValue, stamp[0], stamp[0] + 1);
System.out.println(String.format("%s:%s,%s", Thread.currentThread().getName(), "10->11->10", writeOk ? stamp[0] + 1 : stamp[0]));
} catch (InterruptedException e) {
}
}, "线程A");
Thread threadB = new Thread(() -> {
try {
int[] stamp = new int[1];
Integer value = ref.get(stamp); //同时获取时间戳和数据，防止获取到数据和版本不是一致的
System.out.println(String.format("%s 启动,当前值是:%s,版本:%s", Thread.currentThread().getName(), ref.getReference(), stamp[0]));
TimeUnit.MILLISECONDS.sleep(2000);
int newValue = value + 2;
boolean writeOk = ref.compareAndSet(value, newValue, stamp[0], stamp[0] + 1);
System.out.println(String.format("%s: index是预期的10:%s,新值是:%s,版本:%s", Thread.currentThread().getName(), writeOk, ref.getReference(), writeOk ? stamp[0] + 1 : stamp[0]));
} catch (InterruptedException e) {
e.printStackTrace();
}
}, "线程B");
threadA.start();
threadB.start();
threadA.join();
threadB.join();
}
}
CAS 的底层调用了汇编的 LOCK_IF_MP 方法：
lock cmpxchg
虽然cmpxchg指令不是原子的，但是加了lock指令后，则cmpxhg被上锁，不允许被打断。 在单核 CPU 中，无须加lock，在多核 CPU 中，必须加lock，可以参考 stackoverflow 上的这个回答: is-x86-cmpxchg-atomic-if-so-why-does-it-need-lock
使用 CAS 好处
jdk 早期是重量级别锁 ，通过0x80中断 进行用户态和内核态转换，所以效率比较低，有了 CAS 操作，大大提升了效率。
锁升级
过程如下：
偏向锁
synchronized 代码段多数时间是一个线程在运行，谁先来，这个就偏向谁，用当前线程标记一下。
轻量级锁（自旋锁，无锁）
-
偏向锁撤销，然后竞争，每个线程在自己线程栈中存一个LR（lock record）锁记录
-
偏向锁和轻量级锁都是用户空间完成的，重量级锁需要向操作系统申请。
-
两个线程争抢的方式将lock record的指针，指针指向哪个线程的LR，哪个线程就拿到锁，另外的线程用 CAS 的方式继续竞争
重量级锁
JVM 的 ObjectMonitor 去操作系统申请。
如果发生异常，synchronized会自动释放锁，
示例代码如下：
package git.snippets.juc;
import java.util.concurrent.TimeUnit;
public class ExceptionCauseUnLock {
/*volatile */ boolean stop = false;
public static void main(String[] args) {
ExceptionCauseUnLock t = new ExceptionCauseUnLock();
new Thread(t::m, "t1").start();
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (t.stop) {
int m = 1 / 0;
}
}
synchronized void m() {
while (!stop) {
stop = true;
}
}
}
其中
int m = 1 / 0;
会抛出异常，锁会自动释放。
锁重入
synchronized是可重入锁， 可重入次数必须记录，因为解锁需要对应可重入次数的记录。
偏向锁：记录在线程栈中，每重入一次，LR 加 1，备份原来的markword
轻量级锁：类似偏向锁
重量级锁：记录在ObjectMonitor的一个字段中
自旋锁什么时候升级为重量级锁？
-
有线程超过十次自旋
-
-XX：PreBlockSpin（jdk1.6之前）
-
自旋的线程超过CPU核数一半
-
jdk1.6 以后，JVM自己控制
为什么有偏向锁启动和偏向锁未启动？
未启动：普通对象001 已启动：匿名偏向101
为什么有自旋锁还需要重量级锁？
因为自旋会占用 CPU 时间，消耗 CPU 资源，如果自旋的线程多，CPU 资源会被消耗，所以会升级成重量级锁（队列）例如：ObjectMonitor里面的WaitSet，重量级锁会把线程都丢到WaitSet中冻结, 不需要消耗 CPU 资源
偏向锁是否一定比自旋锁效率高？
明确知道多线程的情况下，不一定。 因为偏向锁在多线程情况下，会涉及到锁撤销，这个时候直接使用自旋锁，JVM 启动过程，会有很多线程竞争，比如启动的时候，肯定是多线程的，所以默认情况，启动时候不打开偏向锁，过一段时间再打开，JVM 有一个参数可以配置：BiasedLockingStartupDelay默认是4s
synchronized
锁定对象
package git.snippets.juc;
/**
* synchronized锁定对象
*
* @author <a href="mailto:410486047@qq.com">Grey</a>
* @date 2021/4/15
* @since
*/
public class SynchronizedObject implements Runnable {
static SynchronizedObject instance = new SynchronizedObject();
final Object object = new Object();
static volatile int i = 0;
@Override
public void run() {
for (int j = 0; j < 1000000; j++) {
// 任何线程要执行下面的代码，必须先拿到object的锁
synchronized (object) {
i++;
}
}
}
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(instance);
Thread t2 = new Thread(instance);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(i);
}
}
锁定方法
锁定静态方法相当于锁定当前类
package git.snippets.juc;
/**
* synchronized锁定静态方法，相当于锁定当前类
*
* @author <a href="mailto:410486047@qq.com">Grey</a>
* @date 2021/4/15
* @since
*/
public class SynchronizedStatic implements Runnable {
static SynchronizedStatic instance = new SynchronizedStatic();
static volatile int i = 0;
@Override
public void run() {
increase();
}
// 相当于synchronized(SynchronizedStatic.class)
synchronized static void increase() {
for (int j = 0; j < 1000000; j++) {
i++;
}
}
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(instance);
Thread t2 = new Thread(instance);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(i);
}
}
锁定非静态方法相当于锁定该对象的实例或
synchronized(this)
package git.snippets.juc;
/**
* synchronized锁定方法
*
* @author <a href="mailto:410486047@qq.com">Grey</a>
* @date 2021/4/15
* @since
*/
public class SynchronizedMethod implements Runnable {
static SynchronizedMethod instance = new SynchronizedMethod();
static volatile int i = 0;
@Override
public void run() {
increase();
}
void increase() {
for (int j = 0; j < 1000000; j++) {
synchronized (this) {
i++;
}
}
}
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(instance);
Thread t2 = new Thread(instance);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(i);
}
}
脏读
package git.snippets.juc;
import java.util.concurrent.TimeUnit;
/**
* 模拟脏读
*
* @author <a href="mailto:410486047@qq.com">Grey</a>
* @date 2021/4/15
* @since
*/
public class DirtyRead {
String name;
double balance;
public static void main(String[] args) {
DirtyRead a = new DirtyRead();
Thread thread = new Thread(() -> a.set("zhangsan", 100.0));
thread.start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(a.getBalance("zhangsan"));
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(a.getBalance("zhangsan"));
}
public synchronized void set(String name, double balance) {
this.name = name;
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
this.balance = balance;
}
// 如果get方法不加synchronized关键字，就会出现脏读情况
public /*synchronized*/ double getBalance(String name) {
return this.balance;
}
}
其中的getBalance方法，如果不加synchronized，就会产生脏读的问题。
可重入锁
一个同步方法可以调用另外一个同步方法，
一个线程已经拥有某个对象的锁，再次申请的时候仍然会得到该对象的锁（可重入锁）
子类synchronized，如果调用父类的synchronize方法：super.method(),如果不可重入，直接就会死锁。
package git.snippets.juc;
import java.io.IOException;
/**
* 一个同步方法可以调用另外一个同步方法，一个线程已经拥有某个对象的锁，再次申请的时候仍然会得到该对象的锁.
*
* @author <a href="mailto:410486047@qq.com">Grey</a>
* @since
*/
public class SynchronizedReentry implements Runnable {
public static void main(String[] args) throws IOException {
SynchronizedReentry myRun = new SynchronizedReentry();
Thread thread = new Thread(myRun, "t1");
Thread thread2 = new Thread(myRun, "t2");
thread.start();
thread2.start();
System.in.read();
}
synchronized void m1(String content) {
System.out.println(this);
System.out.println("m1 get content is " + content);
m2(content);
}
synchronized void m2(String content) {
System.out.println(this);
System.out.println("m2 get content is " + content);
}
@Override
public void run() {
m1(Thread.currentThread().getName());
}
}
程序在执行过程中，如果出现异常，默认情况锁会被释放 ,所以，在并发处理的过程中，有异常要多加小心，不然可能会发生不一致的情况。比如，在一个 web app 处理过程中，多个Servlet线程共同访问同一个资源，这时如果异常处理不合适，在第一个线程中抛出异常，其他线程就会进入同步代码区，有可能会访问到异常产生时的数据。因此要非常小心的处理同步业务逻辑中的异常。
示例代码
package git.snippets.juc;
import java.io.IOException;
import java.util.concurrent.TimeUnit;
/**
* 程序在执行过程中，如果出现异常，默认情况锁会被释放
* 所以，在并发处理的过程中，有异常要多加小心，不然可能会发生不一致的情况。
* 比如，在一个web app处理过程中，多个servlet线程共同访问同一个资源，这时如果异常处理不合适，
* 在第一个线程中抛出异常，其他线程就会进入同步代码区，有可能会访问到异常产生时的数据。
* 因此要非常小心的处理同步业务逻辑中的异常
*/
public class SynchronizedException implements Runnable {
int count = 0;
public static void main(String[] args) throws IOException {
SynchronizedException myRun = new SynchronizedException();
Thread thread = new Thread(myRun, "t1");
Thread thread2 = new Thread(myRun, "t2");
thread.start();
thread2.start();
System.in.read();
}
@Override
public void run() {
synchronized (this) {
while (true) {
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("current thread is " + Thread.currentThread().getName() + " count is " + count);
if (count == 5) {
count++;
int m = 1 / 0;
}
count++;
}
}
}
synchronized void m1(String content) {
System.out.println(this);
System.out.println("m1 get content is " + content);
m2(content);
}
synchronized void m2(String content) {
System.out.println(this);
System.out.println("m2 get content is " + content);
}
}
synchronized 的底层实现
在早期的 JDK 使用的是操作系统级别的重量级锁
后来的改进锁升级的概念：
synchronized (Object)
-
markword 记录这个线程ID （使用偏向锁）
-
如果线程争用：升级为 自旋锁
-
10次自旋以后，升级为重量级锁 – OS
所以，如果
-
执行时间短（加锁代码），线程数少，用自旋。
-
执行时间长，线程数多，用系统锁。
注：synchronized不能锁定String常量，Integer，Long等基础类型
代码示例如下
package git.snippets.juc;
/**
* synchronized不能锁定String常量，Integer，Long等基础类型
* <p>
* 不要以字符串常量作为锁定对象
* 在下面的例子中，m1和m2其实锁定的是同一个对象
* 这种情况还会发生比较诡异的现象，比如你用到了一个类库，在该类库中代码锁定了字符串“Hello”，
* 但是你读不到源码，所以你在自己的代码中也锁定了"Hello",这时候就有可能发生非常诡异的死锁阻塞，
* 因为你的程序和你用到的类库不经意间使用了同一把锁
*
* @author <a href="mailto:410486047@qq.com">Grey</a>
* @since
*/
public class SynchronizedBasicType implements Runnable {
public static Integer i = 0;
static SynchronizedBasicType instance = new SynchronizedBasicType();
static final String lock = "this is a lock";
static final String lock1 = "this is a lock";
public static void main(String[] args) throws InterruptedException {
m();
Thread t1 = new Thread(instance);
Thread t2 = new Thread(instance);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(i);
}
public static void m() throws InterruptedException {
Thread m1 = new Thread(new Runnable() {
@Override
public void run() {
/*synchronized (this)*/
synchronized (lock) {
System.out.println("locked ...");
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
}
System.out.println("unlocked ...");
}
}
});
m1.start();
Thread.sleep(1000);
Thread m2 = new Thread(new Runnable() {
@Override
public void run() {
/*synchronized (this)*/
synchronized (lock1) {
System.out.println("locked lock1 ...");
System.out.println("unlocked lock1 ...");
}
}
});
m2.start();
m1.join();
m2.join();
}
@Override
public void run() {
for (int j = 0; j < 10000000; j++) {
synchronized (i) {
i++;
}
}
}
}
锁定某对象 o，如果 o 的属性发生改变，不影响锁的使用; 但是如果 o 指向另外一个对象，则锁定的对象发生改变, 会影响锁的使用，所以应该避免将锁定对象的引用变成另外的对象。
package git.snippets.juc;
import java.util.concurrent.TimeUnit;
/**
* 锁定某对象o，如果o的属性发生改变，不影响锁的使用
* 但是如果o变成另外一个对象，则锁定的对象发生改变
* 应该避免将锁定对象的引用变成另外的对象
*/
public class SyncSameObject {
Object object = new Object();
public static void main(String[] args) {
SyncSameObject t = new SyncSameObject();
new Thread(t::m).start();
Thread t2 = new Thread(t::m, "t2");
//锁对象发生改变，所以t2线程得以执行，如果注释掉这句话，线程2将永远得不到执行机会
t.object = new Object();
t2.start();
}
void m() {
synchronized (object) {
while (true) {
try {
TimeUnit.SECONDS.sleep(2);
System.out.println("current thread is " + Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
以上代码，如果不执行t.object=new Object()这句，m2 线程将永远得不到执行。
死锁
两个或两个以上的线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去，这就是死锁现象
死锁产生的原因主要有如下几点
-
系统的资源竞争
-
程序在执行过程中申请和释放资源的顺序不当
死锁产生的必要条件
-
互斥条件：进程要求对所分配的资源（如打印机）进行排他性控制，即在一段时间内某资源仅为一个进程所占有。此时若有其他进程请求该资源，则请求进程只能等待。
-
不剥夺条件：进程所获得的资源在未使用完毕之前，不能被其他进程强行夺走，即只能由获得该资源的进程自己来释放（只能是主动释放)。
-
请求和保持条件：进程已经保持了至少一个资源，但又提出了新的资源请求，而该资源已被其他进程占有，此时请求进程被阻塞，但对自己已获得的资源保持不放。
-
循环等待条件：存在一种进程资源的循环等待链，链中每一个进程已获得的资源同时被链中下一个进程所请求。
模拟死锁代码
/**
* 模拟死锁
*/
public class DeadLock implements Runnable {
int flag = 1;
static Object o1 = new Object();
static Object o2 = new Object();
public static void main(String[] args) {
DeadLock lock = new DeadLock();
DeadLock lock2 = new DeadLock();
lock.flag = 1;
lock2.flag = 0;
Thread t1 = new Thread(lock);
Thread t2 = new Thread(lock2);
t1.start();
t2.start();
}
@Override
public void run() {
System.out.println("flag = " + flag);
if (flag == 1) {
synchronized (o2) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (o1) {
System.out.println("1");
}
}
}
if (flag == 0) {
synchronized (o1) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (o2) {
System.out.println("0");
}
}
}
}
}
如何避免死锁？
1、让程序每次至多只能获得一个锁。当然，在多线程环境下，这种情况通常并不现实。
2、设计时考虑清楚锁的顺序，尽量减少嵌在的加锁交互数量。
3、增加时限，比如使用Lock类中的tryLock方法去尝试获取锁，这个方法可以指定一个超时时限，在等待超过该时限之后便会返回一个失败信息。
volatile
-
保持线程之间的可见性(不保证操作的原子性)，依赖 MESI 协议
-
防止指令重排序，CPU的
load fence和store fence原语支持
CPU 原来执行指令一步一步执行，现在是流水线执行，编译以后可能会产生指令的重排序，这样可以提高性能
关于volatile不保证原子性的代码示例
package git.snippets.juc;
/**
* Volatile保持线程之间的可见性(不保证操作的原子性)
*
* @author <a href="mailto:410486047@qq.com">Grey</a>
* @date 2021/4/19
* @since
*/
public class VolatileNOTAtomic {
volatile static Data data;
public static void main(String[] args) {
Thread writer = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
data = new Data(i, i);
}
});
Thread reader = new Thread(() -> {
while (data == null) {
}
int a = data.a;
int b = data.b;
if (a != b) {
// 会出现这种情况是因为new Data(i,i)非原子操作，会产生中间状态的对象，导致a和b的值会不一致
System.out.printf("a = %s, b=%s%n", a, b);
}
});
writer.start();
reader.start();
try {
writer.join();
reader.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("end");
}
public static class Data {
int a;
int b;
Data(int a, int b) {
this.a = a;
this.b = b;
}
}
}
volatile并不能保证多个线程共同修改running变量时所带来的不一致问题，也就是说volatile不能替代synchronized,
示例代码如下：
package git.snippets.juc;
import java.util.ArrayList;
import java.util.List;
/**
* volatile并不能保证多个线程共同修改变量时所带来的不一致问题，也就是说volatile不能替代synchronized
*
* @author <a href="mailto:410486047@qq.com">Grey</a>
* @date 2021/4/19
* @since
*/
public class VolatileCanNotReplaceSynchronized {
volatile int count = 0;
int count2 = 0;
public static void main(String[] args) {
VolatileCanNotReplaceSynchronized t = new VolatileCanNotReplaceSynchronized();
List<Thread> threads = new ArrayList<>();
List<Thread> threads2 = new ArrayList<>();
for (int i = 0; i < 20; i++) {
threads.add(new Thread(t::m));
threads2.add(new Thread(t::m2));
}
threads.forEach(item -> item.start());
threads2.forEach(item -> item.start());
threads.forEach(item -> {
try {
item.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
});
threads2.forEach(item -> {
try {
item.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
});
System.out.println(t.count);
System.out.println(t.count2);
}
void m() {
for (int i = 0; i < 1000; i++) {
count++;
}
}
synchronized void m2() {
for (int i = 0; i < 1000; i++) {
count2++;
}
}
}
DCL 为什么一定要加 volatile？
什么是 DCL，请参考设计模式学习笔记中的单例模式说明。
在New对象的时候，编译完实际上是分了三步
-
对象申请内存，成员变量会被赋初始值
-
成员变量设为真实值
-
成员变量赋给对象
指令重排序可能会导致2和3进行指令重排，导致下一个线程拿到一个半初始化的对象，导致单例被破坏。所以 DCL 必须加volitile
此外，被volatile关键字修饰的对象作为类变量或实例变量时，其对象中携带的类变量和实例变量也相当于被volatile关键字修饰了
示例代码如下
package git.snippets.juc;
import java.util.concurrent.TimeUnit;
/**
* 被volatile关键字修饰的对象作为类变量或实例变量时，其对象中携带的类变量和实例变量也相当于被volatile关键字修饰了
*
* @author <a href="mailto:410486047@qq.com">Grey</a>
* @since 1.8
*/
public class VolatileRef {
volatile M tag = new M();
public static void main(String[] args) {
VolatileRef t = new VolatileRef();
new Thread(t::m, "t1").start();
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
t.tag.n.x.stop = new Boolean(true);
}
void m() {
while (!tag.n.x.stop) {
}
}
}
class M {
N n = new N();
}
class N {
X x = new X();
}
class X {
public Boolean stop = new Boolean(false);
}
说明
本文涉及到的所有代码和图例
更多内容见：Java 多线程
参考资料
原创文章，作者：ItWorker，如若转载，请注明出处：https://blog.ytso.com/288677.html