Concurrent Program-02：共享问题_Synchronized同步_线程安全_Monitor_Synchronized原理

其他 2020-03-21 22:25:16 阅读次数: 0

文章目录

1. 共享带来的问题

1、分析问题：

下面的代码打印的结果可能为1,0,-1：

@Slf4j(topic = "c.Test17")
public class Test17 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                counter++;
            }
        }, "t1");

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                counter--;
            }
        }, "t2");

        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("{}", counter);
    }
}

以上的结果可能是正数、负数、零。为什么呢？因为 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 行代码是顺序执行（不会交错）没有问题：
在这里插入图片描述但多线程下这 8 行代码可能交错运行：

出现负数的情况：
在这里插入图片描述
出现正数的情况：
在这里插入图片描述
2、临界区 Critical Section：

在这里插入图片描述

static int counter = 0;
static void increment()
// 临界区
{
	counter++;
}
static void decrement()
// 临界区
{
	counter--;
}

3、竞态条件 Race Condition：

多个线程在临界区内执行，由于代码的执行序列不同而导致结果无法预测，称之为发生了竞态条件

2. synchronized 同步代码块

1、互斥：
在这里插入图片描述
2、synchronized

synchronized(对象) // 线程1， 线程2(blocked)
{
	临界区
}

@Slf4j(topic = "c.Test17")
public class Test17 {

    static int counter = 0;
    static 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 实际是用对象锁保证了临界区内代码的原子性，临界区内的代码对外是不可分割的，不会被线程切换所打断。
在这里插入图片描述
3、面向对象改进：

把需要保护的共享变量放入一个类

@Slf4j(topic = "c.Test17")
public class Test17 {

    public static void main(String[] args) throws InterruptedException {
        Room room = new Room();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                room.increment();
            }
        }, "t1");

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                room.decrement();
            }
        }, "t2");

        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("{}", room.getCounter());
    }
}

class Room {
    private int counter = 0;

    public void increment(){
        synchronized (this){
            counter--;
        }
    }

    public void decrement(){
        synchronized (this){
            counter++;
        }
    }

    public int getCounter(){
        synchronized (this){
            return counter;
        }
    }
}

3. synchronized 同步方法

在这里插入图片描述
synchronized只能锁对象，如果放在方法上锁的对象就是this：

@Slf4j(topic = "c.Test17")
public class Test17 {

    public static void main(String[] args) throws InterruptedException {
        Room room = new Room();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                room.increment();
            }
        }, "t1");

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 5000; i++) {
                room.decrement();
            }
        }, "t2");

        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("{}", room.getCounter());
    }
}

class Room {
    private int counter = 0;

    public synchronized void increment() {
        counter++;
    }

    public synchronized void decrement() {
        counter--;
    }

    public synchronized int getCounter() {
        return counter;
    }
}

练习题：

如果两个线程使用同一把锁，存在互斥：

@Slf4j(topic = "c.Test8Locks")
public class Test8Locks {
    public static void main(String[] args) {
        Number n1 = new Number();
        Number n2 = new Number();
        //下面的两个线程使用的是同一个锁对象n1,存在互斥
        new Thread(() -> {
            log.debug("begin");
            n1.a();
        }).start();
        new Thread(() -> {
            log.debug("begin");
            n1.b();
        }).start();
    }
}

@Slf4j(topic = "c.Number")
class Number{
    public synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}

如果不是使用同一把锁，不存在互斥：

@Slf4j(topic = "c.Test8Locks")
public class Test8Locks {
    public static void main(String[] args) {
        Number n1 = new Number();
        Number n2 = new Number();
        //t1的锁对象为n1，t2的锁对象为n2
        new Thread(() -> {
            log.debug("begin");
            n1.a();
        }).start();
        new Thread(() -> {
            log.debug("begin");
            n2.b();
        }).start();
    }
}

@Slf4j(topic = "c.Number")
class Number{
    public synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}

4. 变量的线程安全分析

在这里插入图片描述局部变量线程安全分析：

每个线程调用 test1() 方法的局部变量 i，会在每个线程的栈帧内存中被创建多份，因此不存在共享：

public static void test1() {
	int i = 10;
	i++;
}

通过反编译看下字节码指令：
在这里插入图片描述
1、局部变量的引用稍有不同：

public class TestThreadSafe {

    static final int THREAD_NUMBER = 2;
    static final int LOOP_NUMBER = 200;

    public static void main(String[] args) {

       ThreadUnsafe test = new ThreadUnsafe();

        //循环创建线程
        for (int i = 0; i < THREAD_NUMBER; i++) {
            new Thread(() -> {
                //线程1，线程2，线程3调用的method2()/method3()都是同一个list对象
                test.method1(LOOP_NUMBER);
            },"Thread" + (i+1)).start();
        }
    }
}
class ThreadUnsafe {
    //成员变量list
    ArrayList<String> list = new ArrayList<>();

    //在method1()中调用method2()和method3()
    public void method1(int loopNumber) {
        for (int i = 0; i < loopNumber; i++) {
            method2();
            method3();
        }
    }

    //向list集合中添加一个数
    private void method2() {
        list.add("1");
    }

    //从list集合中移除一个数
    private void method3() {
        list.remove(0);
    }
}

在这里插入图片描述
无论哪个线程中的 method2 引用的都是同一个对象中的 list 成员变量，是非线程安全的。

将list改为局部变量，是线程安全的：

class ThreadSafe {
    //method1()方法内调用method2()和method3()方法
    public final void method1(int loopNumber) {
        //每次调用method1()方法都会创建一个list对象，这个list为局部变量，方法内的变量
        ArrayList<String> list = new ArrayList<>();
        for (int i = 0; i < loopNumber; i++) {
            method2(list);
            method3(list);
        }
    }

    public void method2(ArrayList<String> list) {
        list.add("1");
    }

    private void method3(ArrayList<String> list) {
        list.remove(0);
    }
}

在这里插入图片描述

public class TestThreadSafe {

    static final int THREAD_NUMBER = 2;
    static final int LOOP_NUMBER = 200;

    public static void main(String[] args) {

       ThreadSafe test = new ThreadSafe();
        //循环创建线程
        for (int i = 0; i < THREAD_NUMBER; i++) {
            new Thread(() -> {
                test.method1(LOOP_NUMBER);
            },"Thread" + (i+1)).start();
        }
    }
}
class ThreadSafe {
    public final void method1(int loopNumber) {
        //每次调用method1()方法都会创建一个list对象，这个list为局部变量，方法内的变量
        ArrayList<String> list = new ArrayList<>();
        for (int i = 0; i < loopNumber; i++) {
            method2(list);
            method3(list);
        }
    }

    public void method2(ArrayList<String> list) {
        list.add("1");
    }

    private void method3(ArrayList<String> list) {
        list.remove(0);
    }
}

class ThreadSafeSubClass extends ThreadSafe{
	//这个list变量又变成了共享变量
	//调用method3()方法的线程和这个子类中启动的线程共享list这个变量
    public void method3(ArrayList<String> list) {
        new Thread(() -> {
            list.remove(0);
        }).start();
    }
}

从这个例子可以看出 private 或 final 提供【安全】的意义所在，加了final的类子类是无法重写的，加了private的类中的变量其他类时不能访问的。

2、常见的线程安全类：
在这里插入图片描述它们的每个方法是原子的，但注意它们多个方法的组合不是原子的：
在这里插入图片描述
不可变类线程安全：
String、Integer 等都是不可变类，因为其内部的状态不可以改变，因此它们的方法都是线程安全的
String 有 replace，substring 等方法【可以】改变值啊，那么这些方法又是如何保证线程安全的呢？创建一个新的字符串对象

5. Monitor概念

java对象的对象头格式：
在这里插入图片描述
Monitor原理：

Monitor 被翻译为监视器或管程
每个 Java 对象都可以关联一个 Monitor 对象，如果使用 synchronized 给对象上锁（重量级）之后，该对象头的Mark Word 中就被设置指向 Monitor 对象的指针
在这里插入图片描述
从字节码角度分析Monitor原理：
在这里插入图片描述
将上面的代码反编译为字节码文件：

public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
 stack=2, locals=3, args_size=1
	0: getstatic #2 // <- lock引用 （synchronized开始）
	3: dup
	4: astore_1 // lock引用 -> slot 1
	5: monitorenter // 将 lock对象 MarkWord 置为 Monitor 指针
	6: getstatic #3 // <- i
	9: iconst_1 // 准备常数 1
	10: iadd // +1
	11: putstatic #3 // -> i
	14: aload_1 // <- lock引用
	15: monitorexit // 将 lock对象 MarkWord 重置, 唤醒 EntryList
	16: goto 24
	19: astore_2 // e -> slot 2
	20: aload_1 // <- lock引用
	21: monitorexit // 将 lock对象 MarkWord 重置, 唤醒 EntryList
	22: aload_2 // <- slot 2 (e)
	23: athrow // throw e
	24: return

6. Synchronized原理

一个故事引入各种锁：
在这里插入图片描述

1、轻量级锁

轻量级锁的使用场景：如果一个对象虽然有多线程要加锁，但加锁的时间是错开的（也就是没有竞争），那么可以使用轻量级锁来优化。轻量级锁对使用者是透明的，即语法仍然是 synchronized，如果有竞争会升级为重量级锁。

通过这个代码演示加锁，锁重入，解锁的过程：
在这里插入图片描述（1）创建锁记录（Lock Record）对象，每个线程都的栈帧都会包含一个锁记录的结构，内部可以存储锁定对象的Mark Word
在这里插入图片描述
（2）让锁记录中 Object reference 指向锁对象，并尝试用 cas 替换 Object 的 Mark Word，将 Mark Word 的值存入锁记录
在这里插入图片描述
（3）如果 cas 替换成功，对象头中存储了 锁记录地址和状态 00 ，表示由该线程给对象加锁，这时图示如下：根据Mark Word结构，00代表无锁，01代表轻量级锁
在这里插入图片描述
（4）如果 cas 失败，有两种情况
如果是其它线程已经持有了该 Object 的轻量级锁，这时表明有竞争，进入锁膨胀过程
如果是自己执行了 synchronized 锁重入，那么再添加一条 Lock Record 作为重入的计数
在这里插入图片描述（5）当退出 synchronized 代码块（解锁时）如果有取值为 null 的锁记录，表示有重入，这时重置锁记录，表示重入计数减一
在这里插入图片描述
（6）当退出 synchronized 代码块（解锁时）锁记录的值不为 null，这时使用 cas 将 Mark Word 的值恢复给对象头
　　成功，则解锁成功
　　失败，说明轻量级锁进行了锁膨胀或已经升级为重量级锁，进入重量级锁解锁流

2、锁膨胀

如果在尝试加轻量级锁的过程中，CAS 操作无法成功，这时一种情况就是有其它线程为此对象加上了轻量级锁（有竞争），这时需要进行锁膨胀，将轻量级锁变为重量级锁。

通过下面的代码演示看锁膨胀的过程：
在这里插入图片描述
（1）当 Thread-1 进行轻量级加锁时，Thread-0 已经对该对象加了轻量级锁
在这里插入图片描述
（2）这时 Thread-1 加轻量级锁失败，进入锁膨胀流程：
　　　即为 Object 对象申请 Monitor 锁，让 Object 指向重量级锁地址
　　　然后自己进入 Monitor 的 EntryList BLOCKED
在这里插入图片描述
（3）当 Thread-0 退出同步块解锁时，使用 cas 将 Mark Word 的值恢复给对象头，失败。这时会进入重量级解锁流程，即按照 Monitor 地址找到 Monitor 对象，设置 Owner 为 null，唤醒 EntryList 中 BLOCKED 线程

3、自旋优化

重量级锁竞争的时候，还可以使用自旋来进行优化，如果当前线程自旋成功（即这时候持锁线程已经退出了同步块，释放了锁），这时当前线程就可以避免阻塞。

自旋重试成功的情况：
在这里插入图片描述
自旋重试失败的情况：
在这里插入图片描述

  • 自旋会占用 CPU 时间，单核 CPU 自旋就是浪费，多核 CPU 自旋才能发挥优势。
  • 在 Java 6 之后自旋锁是自适应的，比如对象刚刚的一次自旋操作成功过，那么认为这次自旋成功的可能性会高，就多自旋几次；反之，就少自旋甚至不自旋，总之，比较智能。
  • Java 7 之后不能控制是否开启自旋功能

4、偏向锁

轻量级锁在没有竞争时（就自己这个线程），每次重入仍然需要执行 CAS 操作。

Java 6 中引入了偏向锁来做进一步优化：只有第一次使用 CAS 将线程 ID 设置到对象的 Mark Word 头，之后发现这个线程 ID 是自己的就表示没有竞争，不用重新 CAS。以后只要不发生竞争，这个对象就归该线程所有。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

茶花女--
发布了665 篇原创文章 · 获赞 115 · 访问量 10万+
他的留言板 关注

猜你喜欢

转载自blog.csdn.net/qq_42764468/article/details/104984125
今日推荐
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
开源日报 | 工业开源项目OGG 1.0；姐姐，你要和我一起配置火狐吗；苹果AI遥遥落后？Fedora 40
开放签电子签章：停止新增，优化体验，前进更进（五一假期前工作）
开源日报 | 中学生开源前端动画引擎；全球首个Llama3 8B中文版开源模型；联想电脑恐出局；Linus讽刺AI炒作
“百模大战”必有一战 | 2024中国“百模大战”竞争格局分析
周排行
Family Tree 题解
BZOJ 1093 最大半连通子图 SCC + DP
幂等处理
Spring----学习（2）----XML 配置Bean 自动装配
SQL Server 远程更新目标表数据
HIbernate3.6 环境搭建
特殊符号正则表达式
【Linux】第一章 进程的理解
843. n-皇后问题（dfs+输出各种情况）
空间数据库2
每日归档
更多
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)
2024-04-17(5)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022