多线程进阶

public class Test {
    public static int count = 0;
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            int i = 0;
            while(i < 5000) {
                count++;
                i++;
            }
        });
        Thread t2 = new Thread(() -> {
            int i = 0;
            while(i < 5000) {
                count++;
                i++;
            }
        });
        t1.start();
        t2.start();
        //如果没有这俩 join , 肯定不行, 线程还没有自增完毕, 就开始打印了,
        //打印出来的count 可能是 0;
        t1.join();
        t2.join();
        //预期结果是 10w
        System.out.println(count);
    }
}

AtomicInteger 基于 CAS 的方式对 int 进行封装, 此时 ++ 就是原子的了

结论: 原子类里面是基于 CAS 来实现的

 public static AtomicInteger count = new AtomicInteger(0);
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for(int i = 0; i < 5000; i++) {
                // count++
                count.getAndIncrement();
//                // ++count
//                count.incrementAndGet();
//                // count--
//                count.getAndDecrement();
//                // --count
//                count.decrementAndGet();
            }
        });
        Thread t2 = new Thread(() -> {
            for(int i = 0; i < 5000; i++) {
                // count++
                count.getAndIncrement();
//                // ++count
//                count.incrementAndGet();
//                // count--
//                count.getAndDecrement();
//                // --count
//                count.decrementAndGet();
            }
        });
        t1.start();
        t2.start();
        //如果没有这俩 join , 肯定不行, 线程还没有自增完毕, 就开始打印了,
        //打印出来的count 可能是 0;
        t1.join();
        t2.join();
        //预期结果是 10w
        System.out.println(count);
    }

实现的基本思路(如下图):

有一个内存 A, 两个寄存器 A, B

CAS (M, A, B)

如果 M 和 A 值相同, M 和 B 的值交换, 整个操作返回 true

如果 M 和 A 值不相同, 无事发生, 整个操作返回 false

我们只关心是否交换之后 M 的情况, B里面是啥不关心

线程不安全本质上是进行自增的过程穿插进行了

CAS 这里的自增不要穿插执行, 核心思路是一样的, 加锁是通过阻塞的方式避免穿插, CAS 是通过重试的方式避免穿插.

这里面是把 A 和 value 比较过程本质是检查在是否有其他线程穿插过来.

CAS 实现的不止 AromicInteger. 还有很多其他的.

实现自旋锁

ABA 问题

CAS 进行关键操作, 使用过值没有发生变化, 来作为其他线程穿插判定依据

这种判定不够严谨, 因为可能出现 A -> B -> A 的情况, 中间变了, 又变回来了, 已经穿插执行了

虽然被穿插执行了, 但是由于值改回来了, 一般不会出现什么bug, 但在极端情况下就不好说了

举个例子:

去 ATM 取钱, 本身的账户 1000, 想要取 500, 但在过程中出现 bug, 按两下取钱按钮, 此时产生了两个线程进行扣款操作!!

但是如果此时在来一个 t3 线程,给我的线程余额充值 500, 这是我的 t1 线程中 value 就会再次增加500 变为 1000, t1 就会在次扣一次钱

解决方案:

只要让判定的数值按照一个方向增长即可. 有增有减, 会出现 ABA 情况, 只是增加(减少) 就不会了, 针对账户余额(必须要能加能减)这样的概念可以引入一个额外的变量----版本号, 每次修改余额让版本号自增即可, 在使用 CAS 判定的时候不是判定余额, 而是版本号了.

在实际开发中, 一般不会直接使用 CAS, 都是封装好的.

synchronized 原理

synchronized 几个重要的机制:

1> 锁升级

2> 锁消除

3> 锁粗化

锁升级

偏向锁:举个例子(线程池优化了 " 找下一任 " 的效率, 偏向锁优化了 " 分手 " 的效率)

我是个妹子

使用偏向锁之前, 看上一个小哥哥, 想和她交往, 培养感情后在一起了, 交往一段时间后就想分手, 就需要想办法, 过程比较低效

使用偏向锁之后, 我看上一个小哥哥, 只是搞暧昧, 把情侣能做的事全做了, 但是不捅破窗户纸, 到最后想分就分.如果搞暧昧的过程中如果有个妹子想接近小哥哥, 那么我直接和小哥哥表白确定情侣关系.

偏向锁只是一个标记, 不是真的加锁, 当锁冲突的时候, 偏向锁就会升级为轻量级加锁, 就是真的加锁了, 偏向锁的核心思想就是" 懒汉模式 " 的另一种体现, 锁升级的过程中就是在性能和线程安全之间进行权衡

锁消除

是一种编译器优化的手段

编译器自动针对你当前写的枷锁的代码做出判定, 如果觉得这个场景不需要加锁, 就会把 synchronized 给优化掉

StringBuilder 不带 synchronized

StringBuffer 带有 synchronized

如果在单个线程中使用 StringBuffer 就会自动优化掉 synchronized (触发概率不高)

锁粗化

锁的粒度

synchronized 里面代码越多认为锁的粒度越粗, 代码越少, 锁的粒度越细

粒度细的时候, 能够并发执行逻辑更多, 更有利于充分调用多核 CPU 资源, 但是如果粒度细的锁, 被反复进行加锁解锁, 实际效果可能不如粒度粗的锁

小结:

理解每个锁的含义, 转化为自己的话

-瞬间的永恒-

关注

34
点赞
踩
33

收藏

觉得还不错? 一键收藏
3
评论
多线程进阶

只要让判定的数值按照一个方向增长即可. 有增有减, 会出现 ABA 情况, 只是增加(减少) 就不会了, 针对账户余额(必须要能加能减)这样的概念可以引入一个额外的变量----版本号, 每次修改余额让版本号自增即可, 在使用 CAS 判定的时候不是判定余额, 而是版本号了.使用偏向锁之后, 我看上一个小哥哥, 只是搞暧昧, 把情侣能做的事全做了, 但是不捅破窗户纸, 到最后想分就分.如果搞暧昧的过程中如果有个妹子想接近小哥哥, 那么我直接和小哥哥表白确定情侣关系.
复制链接

扫一扫