本文深入剖析了多线程环境下共享资源引发的问题，通过具体案例解析竞态条件及解决方案，重点介绍了synchronized关键字的应用及其原理。
4.1 共享带来的问题
线程出现问题的根本原因是因为线程上下文切换，导致线程里的指令没有执行完就切换执行其它线程了，下面举一个例子 Test13.java
两个线程对初始值为 0 的静态变量一个做自增，一个做自减，各做 5000 次，结果是 0 吗？
static int count = 0;
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(()->{
for (int i = 1;i<5000;i++){
count++;
}
});
Thread t2 =new Thread(()->{
for (int i = 1;i<5000;i++){
count--;
}
});
t1.start();
t2.start();
t1.join();
t2.join();
log.debug("count的值是{}",count);
}问题分析
以上的结果可能是正数、负数、零。为什么呢？因为 Java 中对静态变量的自增，自减并不是原子操作，要彻底理解，必须从字节码来进行分析
例如对于 i++ 而言（i 为静态变量），实际会产生如下的 JVM 字节码指令：
getstatic i // 获取静态变量i的值
iconst_1 // 准备常量1
iadd // 自增
putstatic i // 将修改后的值存入静态变量i
getstatic i // 获取静态变量i的值
iconst_1 // 准备常量1
isub // 自减
putstatic i // 将修改后的值存入静态变量i
可以看到count++ 和 count-- 操作实际都是需要这个4个指令完成的，那么这里问题就来了！Java 的内存模型如下，完成静态变量的自增，自减需要在主内存和工作内存中进行数据交换
如果是单线程以上 8 行代码是顺序执行（不会交错）没有问题：
但多线程下这 8 行代码可能交错运行：
出现负数的情况：
出现正数的情况：
多线程的上下文切换，造成的指令混乱
问题的进一步描述
临界区
-
一个程序运行多线程本身是没有问题的
-
问题出现在多个线程访问 共享资源 的时候
- 多个线程同时对共享资源进行读操作本身也没有问题
- 在多个线程对共享资源读写操作时发生指令交错，就会出现问题
-
一段代码块内如果存在对共享资源的多线程读写操作，称这段代码块为临界区
static int counter = 0;
static void increment()
{// 临界区
counter++;
}
static void decrement()
{// 临界区
counter--;
}竞态条件 Race Condition
多个线程在临界区内执行，由于代码的执行序列不同而导致结果无法预测，称之为发生了竞态条件
4.2 synchronized 解决方案
应用之互斥
为了避免临界区的竞态条件发生，有多种手段可以达到目的。
- 阻塞式的解决方案：synchronized，Lock
- 非阻塞式的解决方案：原子变量
本次课使用阻塞式的解决方案：synchronized，来解决上述问题，即俗称的【对象锁】，它采用互斥的方式让同一 时刻至多只有一个线程能持有【对象锁】，其它线程再想获取这个【对象锁】时就会阻塞住。这样就能保证拥有锁 的线程可以安全的执行临界区内的代码，不用担心线程上下文切换
注意
虽然 java 中互斥和同步都可以采用 synchronized 关键字来完成，但它们还是有区别的：
- 互斥是保证临界区的竞态条件发生，同一时刻只能有一个线程执行临界区代码
- 同步是由于线程执行的先后、顺序不同、需要一个线程等待其它线程运行到某个点
synchronized
语法
synchronized(对象) // 线程1获得锁， 那么线程2的状态是(blocked)
{
临界区
}解决方案
static int counter = 0;
static final Object lock = new Object();
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
for (int i = 0; i < 5000; i++) {
synchronized (lock) {
counter++;
}
}
}, "t1");
Thread t2 = new Thread(() -> {
for (int i = 0; i < 5000; i++) {
synchronized (lock) {
counter--;
}
}
}, "t2");
t1.start();
t2.start();
t1.join();
t2.join();
log.debug("{}",counter);
}可以这样进行类比
用图来表示
synchronized实际上利用对象保证了临界区代码的原子性，临界区内的代码在外界看来是不可分割的，不会被线程切换所打断
保护共享资源。必须保护同一个对象，给同一个对象加锁
面向对象改进
把需要保护的共享变量放入一个类
4.3 方法上的 synchronized
class Test{
public synchronized void test() {
}
}
//等价于
class Test{
public void test() {
synchronized(this) {
}
}
}
//------------------------------------------------------------------------------------------------
class Test{
public synchronized static void test() {
}
}
// 等价于
class Test{
public static void test() {
synchronized(Test.class) {
}
}
}
有互斥现象，锁的都是n1
c会多线程并行执行
锁的不是同一个对象
锁的不同对象 ，一个是类对象一个是this对象没有互斥
4.4 变量的线程安全分析
成员变量和静态变量是否线程安全？
如果它们没有共享，则线程安全
如果它们被共享了，根据它们的状态是否能够改变，又分两种情况
- 如果只有读操作，则线程安全
- 如果有读写操作，则这段代码是临界区，需要考虑线程安全
局部变量是否线程安全？
局部变量是线程安全的
但局部变量引用的对象则未必
- 如果该对象没有逃离方法的作用访问，它是线程安全的
- 如果该对象逃离方法的作用范围，需要考虑线程安全
局部变量线程安全分析
局部变量是存在虚拟机栈中，线程私有
局部变量的引用稍有不同
成员变量线程不安全的例子
其中一种情况是，如果线程2 还未 add，线程1 remove 就会报错：
将 list 修改为局部变量，那么就不会有上述问题了
class ThreadSafe {
public final void method1(int loopNumber) {
ArrayList<String> list = new ArrayList<>();//局部变量
for (int i = 0; i < loopNumber; i++) {
method2(list);
method3(list);
}
}
private void method2(ArrayList<String> list) {
list.add("1");
}
private void method3(ArrayList<String> list) {
list.remove(0);
}
}
那么就不会有上述问题了
方法访问修饰符带来的思考，如果把 method2 和 method3 的方法修改为 public 会不会代理线程安全问题？
● 情况1：有其它线程调用 method2 和 method3
● 情况2：在 情况1 的基础上，为 ThreadSafe 类添加子类，子类覆盖 method2 或 method3 方法。会有线程安全问题。
子类父类共享资源
class ThreadSafe {
public final void method1(int loopNumber) {
ArrayList<String> list = new ArrayList<>();
for (int i = 0; i < loopNumber; i++) {
method2(list);
method3(list);
}
}
private void method2(ArrayList<String> list) {
list.add("1");
}
private void method3(ArrayList<String> list) {
list.remove(0);
}
}
class ThreadSafeSubClass extends ThreadSafe{
@Override
public void method3(ArrayList<String> list) {
new Thread(() -> {
list.remove(0);
}).start();
}
}
常见线程安全类
● String
● Integer
● StringBuffer
● Random
● Vector
● Hashtable
● java.util.concurrent 包下的类juc
这里说它们是线程安全的是指，多个线程调用它们同一个实例的某个方法时，是线程安全的。也可以理解为
Hashtable table = new Hashtable();
new Thread(()->{
table.put("key", "value1");
}).start();
new Thread(()->{
table.put("key", "value2");
}).start();
● 它们的每个方法是原子的
● 但注意它们多个方法的组合不是原子的，见后面分析
线程安全类方法的组合
分析下面代码是否线程安全？
Hashtable table = new Hashtable();
// 线程1，线程2
if( table.get("key") == null) {
table.put("key", value);
}
不可变类线程安全性
String、Integer 等都是不可变类，因为其内部的状态不可以改变，因此它们的方法都是线程安全的。或许你有疑问，String 有 replace，substring (创建了一个新的对象)等方法【可以】改变值啊，那么这些方法又是如何保证线程安全的呢?
创建了一个新的字符串对象，没有改变对象的属性
实例分析
例1：Servlet运行在Tomcat环境下并只有一个实例，因此会被Tomcat的多个线程共享使用，因此存在成员变量的共享问题。
属性不能改的是线程安全的
public class MyServlet extends HttpServlet {
// 是否安全？ 否：HashMap不是线程安全的，HashTable是
Map<String,Object> map = new HashMap<>();
// 是否安全？ 是:String 为不可变类，线程安全
String S1 = "...";
// 是否安全？ 是
final String S2 = "...";
// 是否安全？ 否：不是常见的线程安全类
Date D1 = new Date();
// 是否安全？ 否：引用值D2不可变，但是日期里面的其它属性比如年月日可变。与字符串的最大区别是Date里面的属性可变。
final Date D2 = new Date();
public void doGet(HttpServletRequest request, HttpServletResponse response) {
// 使用上述变量
}
}
例2：
不是线程安全的代码
public class MyServlet extends HttpServlet {
// 是否安全？ 否：Servlet只有一份，userService为其成员变量也只有一份，所以会有多个线程共享使用。
private UserService userService = new UserServiceImpl();
public void doGet(HttpServletRequest request, HttpServletResponse response) {
userService.update(...);
}
}
public class UserServiceImpl implements UserService {
// 记录调用次数 否：成员变量只有一份
private int count = 0;
public void update() {
// ... 临界区
count++;
}
}
例3：
@Aspect
@Component
public class MyAspect {
// 是否安全？ 否：Spring中没有加Scope默认为单例，因此为成员变量MyAspect会被共享，其成员变量也会被共享。解决：使用环绕通知，将开始时间和结束时间作为环绕通知的局部变量。
private long start = 0L;
@Before("execution(* *(..))")
public void before() {
start = System.nanoTime();
}
@After("execution(* *(..))")
public void after() {
long end = System.nanoTime();
System.out.println("cost time:" + (end-start));
}
}
例4：
public class MyServlet extends HttpServlet {
// 是否安全 是：UserService不可变，没有地方修改它
private UserService userService = new UserServiceImpl();
public void doGet(HttpServletRequest request, HttpServletResponse response) {
userService.update(...);
}
}
public class UserServiceImpl implements UserService {
// 是否安全 是：Dao不可变
private UserDao userDao = new UserDaoImpl();
public void update() {
userDao.update();
}
}
public class UserDaoImpl implements UserDao {
// 是否安全 是：没有成员变量，无法修改其状态和属性
public void update() {
String sql = "update user set password = ? where username = ?";
// 是否安全 是：不同线程创建的conn各不相同，都在各自的栈内存中
try (Connection conn = DriverManager.getConnection("","","")){
// ...
} catch (Exception e) {
// ...
}
}
}
例5：
public class MyServlet extends HttpServlet {
// 是否安全
private UserService userService = new UserServiceImpl();
public void doGet(HttpServletRequest request, HttpServletResponse response) {
userService.update(...);
}
}
public class UserServiceImpl implements UserService {
// 是否安全
private UserDao userDao = new UserDaoImpl();
public void update() {
userDao.update();
}
}
public class UserDaoImpl implements UserDao {
// 是否安全 否：conn为成员变量被多个线程共享
private Connection conn = null;
public void update() throws SQLException {
String sql = "update user set password = ? where username = ?";
conn = DriverManager.getConnection("","","");
// ...
conn.close();
}
}
例6：
public class MyServlet extends HttpServlet {
// 是否安全 是
private UserService userService = new UserServiceImpl();
public void doGet(HttpServletRequest request, HttpServletResponse response) {
userService.update(...);
}
}
public class UserServiceImpl implements UserService {
public void update() {
//是否安全： 是：因为userDao为局部变量，每个线程创建的都不一样（但不推荐，建议把conn作为线程内的局部变量）
UserDao userDao = new UserDaoImpl();
userDao.update();
}
}
public class UserDaoImpl implements UserDao {
// 是否安全
private Connection = null;
public void update() throws SQLException {
String sql = "update user set password = ? where username = ?";
conn = DriverManager.getConnection("","","");
// ...
conn.close();
}
}
例7：
public abstract class Test {
public void bar() {
// 是否安全 否：虽然sdf 是局部变量，但是还要看是否暴露给其它线程
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
foo(sdf);
}
public abstract foo(SimpleDateFormat sdf);
public static void main(String[] args) {
new Test().bar();
}
}
其中 foo 的行为是不确定的，可能导致不安全的发生，被称之为外星方法。不想往外暴露方法设置为final或者private，String类加final就是防止子类将其属性或者状态覆盖
public void foo(SimpleDateFormat sdf) {
String dateStr = "1999-10-11 00:00:00";
for (int i = 0; i < 20; i++) {
new Thread(() -> {
try {
sdf.parse(dateStr);
} catch (ParseException e) {
e.printStackTrace();
}
}).start();
}
}
例8：
private static Integer i = 0;
public static void main(String[] args) throws InterruptedException {
List<Thread> list = new ArrayList<>();
for (int j = 0; j < 2; j++) {
Thread thread = new Thread(() -> {
for (int k = 0; k < 5000; k++) {
synchronized (i) {
i++;
}
}
}, "" + j);
list.add(thread);
}
list.stream().forEach(t -> t.start());
list.stream().forEach(t -> {
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
});
log.debug("{}", i);
}
4.6 Monitor 概念
Java 对象头
以 32 位虚拟机为例
Integer 8字节+4字节
int 4字节
所以一个对象的结构如下：
Monitor （锁）
Monitor被翻译为监视器或者说管程
每个java对象都可以关联一个Monitor，如果使用synchronized给对象上锁（重量级），该对象头的Mark Word中就被设置为指向Monitor对象的指针
- 刚开始时Monitor中的Owner为null
- 当Thread-2 执行synchronized(obj){}代码时就会将Monitor的所有者Owner 设置为 Thread-2，上锁成功，Monitor中同一时刻只能有一个Owner
- 当Thread-2 占据锁时，如果线程Thread-3，Thread-4也来执行synchronized(obj){}代码，就会进入EntryList中变成BLOCKED状态
- Thread-2 执行完同步代码块的内容，然后唤醒 EntryList 中等待的线程来竞争锁，竞争时是非公平的
- 图中 WaitSet 中的 Thread-0，Thread-1 是之前获得过锁，但条件不满足进入 WAITING 状态的线程，后面讲wait-notify 时会分析
注意：synchronized 必须是进入同一个对象的 monitor 才有上述的效果
不加 synchronized 的对象不会关联监视器，不遵从以上规则
synchronized原理
代码如下 Test17.java
static final Object lock=new Object();
static int counter = 0;
public static void main(String[] args) {
synchronized (lock) {
counter++;
}
}反编译后的部分字节码
0 getstatic #2 <com/concurrent/test/Test17.lock>
# 取得lock的引用（synchronized开始了）
3 dup
# 复制操作数栈栈顶的值放入栈顶，即复制了一份lock的引用
4 astore_1
# 操作数栈栈顶的值弹出，即将lock的引用存到局部变量表中
5 monitorenter
# 将lock对象的Mark Word置为指向Monitor指针
6 getstatic #3 <com/concurrent/test/Test17.counter>
9 iconst_1
10 iadd
11 putstatic #3 <com/concurrent/test/Test17.counter>
14 aload_1
# 从局部变量表中取得lock的引用，放入操作数栈栈顶
15 monitorexit
# 将lock对象的Mark Word重置，唤醒EntryList
16 goto 24 (+8)
# 下面是异常处理指令，可以看到，如果出现异常，也能自动地释放锁
19 astore_2
20 aload_1
21 monitorexit
22 aload_2
23 athrow
24 return注意：方法级别的 synchronized 不会在字节码指令中有所体现
synchronized 原理进阶
轻量级锁
轻量级锁的使用场景是：如果一个对象虽然有多个线程要对它进行加锁，但是加锁的时间是错开的（也就是没有人可以竞争的），那么可以使用轻量级锁来进行优化。
轻量级锁对使用者是透明的，即语法仍然是synchronized
假设有两个方法同步块，利用同一个对象加锁
static final Object obj = new Object();
public static void method1() {
synchronized( obj ) {
// 同步块 A
method2();
}
}
public static void method2() {
synchronized( obj ) {
// 同步块 B
}
}每次指向到synchronized代码块时，都会创建锁记录（Lock Record）对象，每个线程都会包括一个锁记录的结构，锁记录内部可以储存对象的Mark Word和对象引用reference
让锁记录中的Object reference指向对象，并且尝试用cas(compare and sweep)替换Object对象的Mark Word ，将Mark Word 的值存入锁记录中,给对象加轻量级锁00
如果cas替换成功，对象头储存的就是锁记录的地址和状态00，表示由该线程给对象加锁，如下所示
如果cas失败，有两种情况
- 如果是其它线程已经持有了该Object的轻量级锁，那么表示有竞争，将进入锁膨胀阶段
- 如果是自己的线程已经执行了synchronized进行加锁（锁重入），那么那么再添加一条 Lock Record 作为重入的计数
当线程退出synchronized代码块（解锁时）的，如果获取的是取值为 null 的锁记录，表示有重入，这时重置锁记录，表示重入计数减一
当线程退出synchronized代码块（解锁）的时候，如果获取的锁记录取值不为 null，那么使用cas将Mark Word的值恢复给对象
- 成功则解锁成功
- 失败，则说明轻量级锁进行了锁膨胀或已经升级为重量级锁，进入重量级锁解锁流程
锁膨胀
如果在尝试加轻量级锁的过程中，cas操作无法成功，这是有一种情况就是其它线程已经为这个对象加上了轻量级锁，这是就要进行锁膨胀，将轻量级锁变成重量级锁。
1、当 Thread-1 进行轻量级加锁时，Thread-0 已经对该对象加了轻量级锁
这时 Thread-1 加轻量级锁失败，进入锁膨胀流程
- 即为对象申请Monitor锁，让Object指向重量级锁地址
- 然后自己进入Monitor 的EntryList 变成BLOCKED状态
当Thread-0 退出synchronized同步块时，使用cas将Mark Word的值恢复给对象头，失败，那么会进入重量级锁的解锁过程，即按照Monitor的地址找到Monitor对象，将Owner设置为null，唤醒EntryList 中的Thread-1线程
自旋优化
重量级锁竞争的时候，还可以使用自旋来进行优化，如果当前线程自旋成功（即在自旋的时候持锁的线程释放了锁），那么当前线程就可以不用进行上下文切换就获得了锁
自旋重试成功的情况
自旋重试失败的情况，自旋了一定次数还是没有等到持锁的线程释放锁
偏向锁
在轻量级的锁中，我们可以发现，如果同一个线程对同一个对象进行重入锁时，也需要执行CAS操作，这是有点耗时滴
那么java6开始引入了偏向锁的东东，只有第一次使用CAS时将对象的Mark Word头设置为入锁线程ID，之后这个入锁线程再进行重入锁时，发现线程ID是自己的，那么就不用再进行CAS了。以后只要不发生竞争，这个对象就归该线程所有。
偏向状态
biased_lock是否使用了偏向锁
一个对象的创建过程
-
如果开启了偏向锁（默认是开启的），那么对象刚创建之后，Mark Word 最后三位的值101，并且这是它的Thread，epoch，age都是0，在加锁的时候进行设置这些的值.
-
偏向锁默认是延迟的，不会在程序启动的时候立刻生效，如果想避免延迟，可以添加jvm虚拟机参数来禁用延迟：-
XX:BiasedLockingStartupDelay=0来禁用延迟 -
注意：处于偏向锁的对象解锁后，线程 id 仍存储于对象头中
-
实验Test18.java，加上虚拟机参数-XX:BiasedLockingStartupDelay=0进行测试
倒数十位之前的内容都是操作系统分配的线程id
3）测试禁用：如果没有开启偏向锁，那么对象创建后最后三位的值为001，这时候它的hashcode，age都为0，hashcode是第一次用到hashcode时才赋值的。
在上面测试代码运行时在添加 VM 参数-XX:-UseBiasedLocking禁用偏向锁（禁用偏向锁则优先使用轻量级锁），退出synchronized状态变回001
前面都是锁记录的地址
撤销偏向锁
优先状态：偏向锁–>轻量级锁–>重量级锁
撤销偏向锁-hashcode方法
测试 hashCode：当调用对象的hashcode方法的时候就会撤销这个对象的偏向锁，因为使用偏向锁时没有位置存hashcode的值了
1、测试代码如下，使用虚拟机参数-XX:BiasedLockingStartupDelay=0 ，确保我们的程序最开始使用了偏向锁！但是结果显示程序还是使用了轻量级锁。
public static void main(String[] args) throws InterruptedException {
Test1 t = new Test1();
t.hashCode();hash码会禁用这个方法的偏向锁
test.parseObjectHeader(getObjectHeader(t));
synchronized (t){
test.parseObjectHeader(getObjectHeader(t));
}
test.parseObjectHeader(getObjectHeader(t));
}2、输出结果
偏向状态存不了哈希码。因为存放空间不够
撤销偏向锁-其它线程使用对象
这里我们演示的是偏向锁撤销变成轻量级锁的过程，那么就得满足轻量级锁的使用条件，就是没有线程对同一个对象进行锁竞争，我们使用wait 和 notify 来辅助实现
将偏向状态由可偏向变成不可偏向
批量重偏向
刚开始t1线程都是加偏向锁
t2线程撤销了偏向锁的状态，升级为轻量级锁00，最后变成不可偏向的状态
最后不撤销了，偏向了t2，重偏向
批量撤销
t1:全部偏向t1；t2:一半撤销t1的偏向锁，一半偏向t2；t3:一半轻量级锁，一半撤销t2的偏向锁；总共撤销了20次t1的偏向锁，20次t2的偏向锁
第40个对象就是001不可偏向
锁消除
局部变量不可能被共享，所以需要进行优化
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
