共享带来的问题
小案例
两个线程对初始值为 0 的静态变量一个做自增，一个做自减，各做 5000 次，结果是 0 吗？
package cn.knightzz.example;
import lombok.extern.slf4j.Slf4j;
@SuppressWarnings("all")
@Slf4j(topic = "c.TestShareValue")
public class TestShareValue {
static int value = 0;
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
for (int i = 0; i < 5000; i++) {
value++;
log.debug("value + 1 = {}", value);
}
}, "t1");
Thread t2 = new Thread(() -> {
for (int i = 0; i < 5000; i++) {
value--;
log.debug("value - 1 = {}", value);
}
}, "t2");
t1.start();
t2.start();
t1.join();
t2.join();
log.debug("value : {} ", value);
}
}
问题分析
以上的结果可能是正数、负数、零。为什么呢？因为 Java 中对静态变量的自增，自减并不是原子操作，要彻底理
解，必须从字节码来进行分析
例如对于 i++ 而言（i 为静态变量），实际会产生如下的 JVM 字节码指令：
getstatic i // 获取静态变量i的值
iconst_1 // 准备常量1
iadd // 自增
putstatic i // 将修改后的值存入静态变量i
而对应 i-- 也是类似：
getstatic i // 获取静态变量i的值
iconst_1 // 准备常量1
isub // 自减
putstatic i // 将修改后的值存入静态变量i
而 Java 的内存模型如下，完成静态变量的自增，自减需要在主存和工作内存中进行数据交换：
如果是单线程以上 8 行代码是顺序执行（不会交错）没有问题：
出现负数的情况 :
临界资源
-
一个程序运行多个线程本身是没有问题的
-
- 问题出在多个线程访问共享资源
-
多个线程读共享资源其实也没有问题
-
- 在多个线程对共享资源读写操作时发生指令交错，就会出现问题
一段代码块内如果存在对共享资源的多线程读写操作，称这段代码块为临界区
static int counter = 0;
public void increment(){
// 临界区
counter++;
}
public void decrement(){
counter--;
}
竞态条件
多个线程在临界区内执行，由于代码的执行序列不同而导致结果无法预测，称之为发生了竞态条件
synchronized 解决方案
互斥
为了避免临界区的竞态条件发生，有多种手段可以达到目的 :
- 阻塞式的解决方案：synchronized，Lock
- 非阻塞式的解决方案：原子变量
synchronized对象锁 , 采用互斥的方式让同一时刻至多只有一个线程能持有对象锁，其它线程再想获取这个对象锁时就会阻塞住。这样就能保证拥有锁的线程可以安全的执行临界区内的代码，不用担心线程上下文切换
虽然 java 中互斥和同步都可以采用 synchronized 关键字来完成，但它们还是有区别的：
- 互斥是保证临界区的竞态条件发生，同一时刻只能有一个线程执行临界区代码
- 同步是由于线程执行的先后、顺序不同、需要一个线程等待其它线程运行到某个点
synchronized(对象) // 线程1， 线程2(blocked)
{
临界区
}
小案例
package cn.knightzz.test;
import lombok.extern.slf4j.Slf4j;
@SuppressWarnings("all")
@Slf4j(topic = "c.TestSynchronized")
public class TestSynchronized {
private static int counter = 0;
public static void main(String[] args) throws InterruptedException {
method2();
}
private static void method1() throws InterruptedException {
Thread t1 = new Thread(() -> {
for (int i = 0; i < 50000; i++) {
log.debug("counter add : {} ", counter);
counter++;
}
log.debug("t1 thread end ... ");
}, "t1");
Thread t2 = new Thread(() -> {
for (int i = 0; i < 50000; i++) {
log.debug("counter sub : {} ", counter);
counter--;
}
log.debug("t2 thread end ... ");
}, "t2");
t1.start();
t2.start();
t1.join();
t2.join();
// 最终结果可能是 正数, 负数或者 0
log.debug("method1 : counter = {}", counter);
// 重置counter
counter = 0;
}
private static void method2() throws InterruptedException {
Thread t1 = new Thread(() -> {
for (int i = 0; i < 500000; i++) {
synchronized (TestSynchronized.class) {
// 使用静态类对象作为 锁
log.debug("counter add : {} ", counter);
counter++;
}
}
log.debug("t1 thread end ... ");
}, "t1");
Thread t2 = new Thread(() -> {
for (int i = 0; i < 500000; i++) {
synchronized (TestSynchronized.class) {
log.debug("counter sub : {} ", counter);
counter--;
}
}
log.debug("t2 thread end ... ");
}, "t2");
t1.start();
t2.start();
t1.join();
t2.join();
// 最终结果可能是 正数, 负数或者 0
log.debug("method2 : counter = {}", counter);
// 重置counter
counter = 0;
}
}
synchronized 可以被认为是一个房间的钥匙, 临界区可以被认为是一个房间
- 当线程拿到锁以后, 会进入房间然后关上门, 此时其他线程无法进入临界区执行临界区的代码
- 如上面的图, 线程2到了门口, 会发现门在关着, 并且线程2无法获取锁, 所以只能被阻塞, 等待线程1执行结束释放锁
- 另外需要注意的是 : 并不是拿到锁就可以一直执行下去, CPU分配给线程1的时间片结束后, 线程1就会被踢出临界区, 然后门重新被锁住.
- 此时线程仍然拿着锁, 等到线程1再次获得CPU时间片后, 执行完临界区的代码, 释放锁后, 线程2才可以获取锁进入临界区去执行临界区的代码
图解如下 :
原子性的理解
for (int i = 0; i < 50000; i++) {
synchronized (TestSynchronized.class) {
// 使用静态类对象作为 锁
log.debug("counter add : {} ", counter);
counter++;
}
}
如上面的代码, 此时 synchronized 包裹的是 counter++; 这行代码 , 操作的是 counter 这个临界资源
counter++ 在jvm里面有四步指令 :
- get static i 获取静态变量i
- iconst 准备常量
- iadd 自增
- putstatic 将i的值写入到 静态变量
原子性就是要保证, 这四步是完整不可分割的整体, 在这四步执行完以前, 任何线程都无法拿到锁 , 一旦这四步执行结束, 那么锁就会被释放， 所以 t1线程和t2线程可以交替混合打印
思考与总结
synchronized 实际是用对象锁保证了临界区内代码的原子性，临界区内的代码对外是不可分割的，不会被线程切
换所打断
思考下面的问题 : ?
- 如果把 synchronized(obj) 放在 for 循环的外面，如何理解？-- 原子性
- 如果 t1 synchronized(obj1) 而 t2 synchronized(obj2) 会怎样运作？-- 锁对象
- 如果 t1 synchronized(obj) 而 t2 没有加会怎么样？如何理解？-- 锁对象
问题1 :
- 如果把 synchronized(obj) 放在 for 循环的外面，如何理解？-- 原子性
上图需要注意的是 ： 当一次counter++ 或者counter--执行结束以后， 对象锁就会被释放， 所以才会出现两个线程交替打印， 如果放在for循环外的话， 那么for循环就是一个整体， 具有原子性， 在执行结束前， 别的线程拿不到锁， 所以 此时是先后打印， 打印完线程1以后， 才会打印线程2
我们可以把存放临界区代码的地方看做一个房子, 这个房子只有一道门, 房子里面存放不同的临界区代码资源
// t1线程
synchronized (TestSynchronized.class) {
// 使用静态类对象作为 锁
log.debug("counter add : {} ", counter);
counter++;
}
// t2 线程
synchronized (TestSynchronized.class) {
log.debug("counter sub : {} ", counter);
counter--;
}
可以看到上面的代码, 使用的都是 TestSynchronized.class 这个类对象, TestSynchronized.class 是锁对象, 这个锁对象对应着一个房间(临界区) , 房间内存放着synchronized 包裹的临界区代码, 每当对应线程想要执行对应的代码的时候, 都要先获取锁.
回到问题 , 如果synchronized在for循环外包裹, 则
for循环是临界代码, 当线程获取锁后, 会直接把for循环执行完, 锁才会释放- 整个for循环会被视为一个整体, 单个线程的for循环执行结束之前, 是不会受到其他线程的干扰
- 直观可以看到的就是 程序会先打印t1或者t2的输出, 等到t1或者t2执行完以后, 才会执行另外的线程的代码
假如是包裹在counter++ 上 :
synchronized (TestSynchronized.class) {
log.debug("counter sub : {} ", counter);
counter--;
}
getstatic i // 获取i变量
iconst_1 // 准备常量1
iadd // i 自增1
putstatic i // 将1写入到i
因为加了 synchronized , 上面的四行JVM指令是一个整体 , 不存在这四行指令尚未执行完毕的时候被其他线程干扰, 比如 : 执行到 **iadd** 后 准备执行 **putstatic i** 时线程上下文切换, 指令中断! , 这四个指令执行完以前, 不会被任何线程打断
可以看到 t1 和 t2 实际上是混合交替运行的
如果是包裹在 for 循环外的话 :
synchronized (TestSynchronized.class) {
for (int i = 0; i < 5000; i++) {
// 使用静态类对象作为 锁
log.debug("counter add : {} ", counter);
counter++;
}
}
如上面的代码, 相当于 for 循环被视为一个整体, 具有原子性,那么, 在for循环执行结束前, 不会受到其他线程的干扰
直观的感受, t1执行完毕以后, t2才获得锁对象开始执行
问题2 :
- 如果 t1 synchronized(obj1) 而 t2 synchronized(obj2) 会怎样运作？-- 锁对象
如果两个锁对象不同, 但是操作的同一个临界资源的话, 就相当于没有锁不会产生互斥 :
如上图所示 : 相当于有两个房间, 因为锁不同, 一把锁可以理解对应一个房间 , 所以当线程1获取 testQuestion1的锁时, 并不会和线程2出现互斥, 不影响线程2获取 testQuestion2 锁, 所以最终结果就和都不加锁是一样的
也可以理解为另外开了一个门, 在同一时间, 两个线程都可以进入房间去修改临界资源
问题3
- 如果 t1 synchronized(obj) 而 t2 没有加会怎么样？如何理解？-- 锁对象
如果一个加锁, 另外一个不加, 也相当于都没加, 因为 t2线程可以随意的执行, 不需要获得锁就可以执行去修改临界资源的值
思考
其实如果想要保证原子性 , 就必须互斥 , 要保证, 所有的临界区代码都在一个房间, 也就是说要都使用同一把锁才可以
否则, 只要有一个临界区不在这个房间, 那么就无法保证原子性, 因为这个临界区的代码执行不受限制, 可以随意修改临界资源的
面向对象改进
把需要保护的共享变量放入一个类
package cn.knightzz.improve;
import lombok.extern.slf4j.Slf4j;
@SuppressWarnings("all")
@Slf4j(topic = "c.Room")
public class Room {
private int counter = 0;
public void increment() {
// 使用当前对象作为锁
synchronized(this) {
log.debug("increment counter : {} " , counter);
counter++;
}
}
public void decrement() {
// 使用当前对象作为锁
synchronized(this) {
log.debug("decrement counter : {} " , counter);
counter--;
}
}
public int getCounter() {
return counter;
}
}
然后使用时直接调用 Room 提供的方法即可
package cn.knightzz.improve;
import cn.knightzz.test.TestSynchronized;
import lombok.extern.slf4j.Slf4j;
/**
* @author 王天赐
* @title: TestObjectImprove
* @projectName hm-juc-codes
* @description: 面向对象改进
* @website <a href="http://knightzz.cn/">http://knightzz.cn/</a>
* @github <a href="https://github.com/knightzz1998">https://github.com/knightzz1998</a>
* @create: 2022-07-03 21:09
*/
@SuppressWarnings("all")
@Slf4j(topic = "c.Room")
public class TestObjectImprove {
public static void main(String[] args) throws InterruptedException {
Room room = new Room();
Thread t1 = new Thread(() -> {
// 在 for 循环执行的过程中, 不会受到其他线程的干扰
for (int i = 0; i < 5000; i++) {
room.increment();
}
log.debug("t1 thread end ... ");
}, "t1");
Thread t2 = new Thread(() -> {
// 在 for 循环执行的过程中, 不会受到其他线程的干扰
for (int i = 0; i < 5000; i++) {
room.decrement();
}
log.debug("t2 thread end ... ");
}, "t2");
t1.start();
t2.start();
t1.join();
t2.join();
log.debug("counter : {} ... ", room.getCounter());
}
}
304
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
