JUC第二课——volatile关键字、锁优化和CAS

最新推荐文章于 2024-06-13 08:37:22 发布
最新推荐文章于 2024-06-13 08:37:22 发布
阅读量93 收藏
点赞数
分类专栏： JUC 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/upset_poor/article/details/120728478
版权

volatile关键字

意思是可变的
作用：

  1. 保证线程可见性（每次写都会被线程读到）
    • MESI：使用CPU的缓存一致性协议
  2. 禁止指令重排序（CPU）
    • DCL单例： Double Check Lock

单例模式加载类对象

饿汉式

package singleton;

/**
 * 饿汉式
 * 类加载到内存后，就实例化一个实例，JVM保证线程安全
 * 简单实用，推荐使用
 * 唯一缺点：不管用不用到，类装载的过程就完成了实例化
 * Class.forName("")
 * @author laimouren
 */
public class singleton01 {
    private static final singleton01 INSTANCE = new singleton01();
    //构造函数被设置为私有，不允许其他方法实例化该类
    private singleton01(){};
    public static singleton01 getInstance(){
        return INSTANCE;
    }
    public void m(){
        System.out.println("m");
    }

    public static void main(String[] args) {
        singleton01 s1 = singleton01.getInstance();
        singleton01 s2 = singleton01.getInstance();
        System.out.println(s1 == s2);
    }
}

懒汉式

package singleton;

/**
 * 懒加载
 * 也称懒汉式
 * 用到的时候再加载
 *但是线程不安全
 * 可以通过synchronized解决，但是效率会下降
 * @author laimouren
 */
public class singleton02 {
    private static singleton02 INSTANCE;
    private singleton02(){};
    public static /*synchronized*/ singleton02 getInstance(){
        if (INSTANCE == null){
            try{
                Thread.sleep(1);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            INSTANCE = new singleton02();
        }
        return INSTANCE;
    }
    public void m(){
        System.out.println("m");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100;i++){
            new Thread(()->{
                System.out.println(singleton02.getInstance().hashCode());
            }).start();
        }
    }
}

优化:双重检查

package singleton;

/**
 * 懒加载
 * 也称懒汉式
 * 用到的时候再加载
 *但是线程不安全
 * 可以通过synchronized解决，但是效率会下降
 * @author laimouren
 */
public class singleton03 {
    private static /*volatile*/ singleton03 INSTANCE;
    private singleton03(){};
    public static singleton03 getInstance(){
    	//业务逻辑代码省略
    	
        if (INSTANCE == null) {
            //双重检查
            synchronized (singleton03.class) {
                if (INSTANCE == null){
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new singleton03();
                }
            }
        }
        return INSTANCE;
    }
    public void m(){
        System.out.println("m");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100;i++){
            new Thread(()->{
                System.out.println(singleton03.getInstance().hashCode());
            }).start();
        }
    }
}

问题：双重检查需不需要加volatile？
要，因为不加会产生指令重排序，
对象初始化一半的情况下，instance对象有默认值，这时候另一个线程返回了instance，导致出现instance还是默认值的情况
（因为JVM去new一个对象，首先要申请内存（成员变量默认值），然后成员变量初始化，最后将内存地址赋给对象）

volatile能否代替synchronized

不能！

package character02;

import java.util.ArrayList;
import java.util.List;

/**
 * volatile并不能保证多个线程共同修改running变量时所带来的不一致问题，也就是volatile不能替代synchronized
 * @author laimouren
 */
public class volatile02 {
    volatile int count = 0;
    /*synchronized*/ void m(){
        for (int i = 0; i < 100000; i++) {
            count++;
        }
    }

    public static void main(String[] args) {
        volatile02 v = new volatile02();
        List<Thread> threads = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            threads.add(new Thread(v::m,"thread-"+i));
        }
        threads.forEach((o)->o.start());
        threads.forEach((o)->{
            try{
                o.join();
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        });
        System.out.println(v.count);
    }
}

锁优化

细锁（FineCoarseLock）
同步代码块的语句越少越好

锁细化

package character02;

import java.util.concurrent.TimeUnit;

/**
 * 锁细化
 * @author laimouren
 */
public class Synchronzied {
    private int count = 0;
    synchronized void m1(){
        try{
            TimeUnit.SECONDS.sleep(2);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        count++;
        try{
            TimeUnit.SECONDS.sleep(2);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
    void m2(){
        try{
            TimeUnit.SECONDS.sleep(2);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        //业务逻辑只有下面一句话需要sync，这时候不应该给整个方法上锁
        //采用细粒度的锁，可以使线程争用时间变短，从而提高效率
        synchronized(this) {
            count++;
        }
        try{
            TimeUnit.SECONDS.sleep(2);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

但是如果太多线程同时争用锁，可以将锁粗化来减少争用

锁对象需加final修饰

package character02;

import java.util.concurrent.TimeUnit;

/**
 * 锁定某个对象o，如果o的属性发生改变，不影响锁的使用
 * 但是如果o变成了另一个对象，则锁定的对象发生改变
 * 应该避免将锁定对象的引用变成另外的对象
 * @author laimouren
 */
public class Synchronzied02 {
	//使用final来保证对象不可变
    /*final*/ Object o = new Object();
    void m(){
        synchronized (o){
            while (true){
                try {
                    TimeUnit.SECONDS.sleep(1);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            }
        }
    }

    public static void main(String[] args) {
        Synchronzied02 s = new Synchronzied02();
        //启动第一个线程
        new Thread(s::m,"s1").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        //创建第二个线程
        Thread t2 = new Thread(s::m,"s2");
        //锁对象发生改变，所以t2线程能够执行，如果注释掉，t2永远不能执行
        s.o = new Object();
        t2.start();
    }

}

CAS（无锁优化 自旋）

Compare And Swap
cas(V,Expected,NewValue)

  • if v == E
    V = new
    otherwise try again or fail
  • CPU原语支持
    解释：如果v值等于期望（expected）的，则将v修改为newValue值
    是cpu指令级别的操作，不能被打断

java.util.concurrent.atomic.Atomic*的类都是使用CAS来保证线程安全

package character02;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 解决同样问题的更高效的方法，使用AtomXX类
 * AtomXX类本身方法都是原子性的，但不能保证多个方法连续调用是原子性
 * @author laimouren
 */
public class CAS01 {
	/*volatile*/ //int count = 0; 
    AtomicInteger count = new AtomicInteger(0);
    /*synchronized*/void m(){
        for (int i = 0; i < 10000; i++) {
            count.incrementAndGet(); //相当于count++，只是它是线程安全的
        }
    }

    public static void main(String[] args) {
        CAS01 c = new CAS01();
        List<Thread> threads = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            threads.add(new Thread(c::m,"thread-"+i));
        }
        threads.forEach((o)->o.start());
        threads.forEach((o)->{
            try{
                o.join();
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        });
        System.out.println(c.count);
    }
}

内部调用unsafe类里面的CompareAndSet方法

ABA问题

如果基本类型，无所谓
如果引用类型，就像你女朋友跟你复合，已经是别人的形状了
解释：
两个线程t1,t2；
t1执行cas(Object,1,2)，t2先将Object改成了2，再改回1，这时候不影响t1的cas操作，但实际上已经有东西发生了修改
解决：给Object加上一个版本号，修改一次版本号加一
A 1.0
B 2.0
A 3.0

可以使用AtomicStampedReference解决ABA问题

Unsafe类(类似c c++的指针）

不能直接使用

功能：

  1. 直接操作内存
  2. 直接生成类实例
  3. 直接操作类或类变量
  4. CAS相关操作
学而知不足~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JUC最详细思维导图，一次了解读写锁，可重入锁，Cas原理，volatile 关键字原理
06-27
JUC最详细思维导图，一次了解读写锁，可重入锁，Cas原理，volatile 关键字原理
多线程与高并发（二）--volatile与CAS
qq_36741186的博客
08-28 204
一、 volatile关键字 volatile 关键字，使一个变量在多个线程间可见。 特性1：保证线程的可见性 举个例子 /** * volatile 关键字，使一个变量在多个线程间可见 * A B线程都用到一个变量，java默认是A线程中保留一份copy,这样如果B线程修改了该变量，则A线程未 必知道 * 使用volatile关键字，会让所有线程都会读到变量的修改值 ** 在下面的代码中，running是存在于堆内存的t对象中 * 当线程t1开始运行的时候，会把running值从内存中读
JUC包含线程,线程池,CAS,volatile等底层原理,以及相关问题的解决方式以及相关工具类的使用
03-31
JUC包含线程,线程池,CAS,volatile等底层原理,以及相关问题的解决方式以及相关工具类的使用,包含但不限于:synchronize的底层原理,线程的执行流程,lock锁底层原理等,线程不安全的集合以及底层等.
Java——JUC
12-29
用于定义类似于线程的自定义子系统,包括线程池,异步 IO 和轻量级任务框架;包含下载地址
JUC并发编程「公开课第二讲」.pdf
02-02
JUC
JUC相关知识和底层实现原理分析.jpg
09-02
JUC底层实现原理分析，结构多线程更加贯彻同步知识
自制植物大战僵尸：HTML5与JavaScript实现的简单游戏
m0_73367097的博客
06-08 1908
自制植物大战僵尸
简单的项目部署脚本（转载）
u010230019的博客
06-09 604
有些项目团队喜欢使用docker启动java服务,那么我们同样可以将上述脚本稍做改造,来实现基于shell+docker的简单项目部署能力。可以将核心节点的错误或者失败内容通过webhook发送到对应的告警平台,比如钉钉、飞书机器人等。把~/.ssh/id_rsa.pub内容添加到远程仓库的ssh秘钥中。执行start.sh脚本打包部署。start.sh脚本内容。
Java——简单图书管理系统
m0_74100417的博客
06-09 1234
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
修改菜品——后端Java
weixin_53717695的博客
06-09 411
修改菜品——后端Java
（Javascript）AI数字人mp4转canvas播放并去除背景绿幕
lx_nhs的博客
06-12 386
去除前：去除后： 3、可能会出现的报错 （1）视频路径跨域问题：解决：vue开启代理
Spring Boot集成antlr实现词法和语法分析
最新发布
HBLOG
06-13 587
Antlr4 是一款强大的语法生成器工具，可用于读取、处理、执行和翻译结构化的文本或二进制文件。基本上是当前 Java 语言中使用最为广泛的语法生成器工具。Twitter搜索使用ANTLR进行语法分析，每天处理超过20亿次查询；Hadoop生态系统中的Hive、Pig、数据仓库和分析系统所使用的语言都用到了ANTLR；Lex Machina将ANTLR用于分析法律文本；Oracle公司在SQL开发者IDE和迁移工具中使用了ANTLR；NetBeans公司的IDE使用ANTLR来解析C++；
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
KK爱Coding的博客
06-11 267
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
SpringBoot之请求映射原理
好记性不如烂笔头
06-12 919
我们发出的请求，SpringMVC是如何精准定位到那个Controller以及具体方法？其实这都是 HandlerMapping 发挥的作用，这篇博文我们以 RequestMappingHandlerMapping 为例并结合源码一步步进行分析。默认 HandlerMapping 主要定义在和其祖父类中获取所有类型是 Object 的 beans，并且 beanName 不以开头根据 beanName 获取 beanType如果 beanType 上存在注解则进行处理。
微型操作系统内核源码详解系列四（3）：操作系统调度算法（FreeRTOS内核篇上）
2301_77061352的博客
06-12 630
-uxTopPriority，被设定为是代表最大优先级的数字，自减操作代表从就绪列表最后一个链表（优先级最高的链表）开始查找，直到找到任务链表不为空的优先级任务，那么这个任务肯定也是所有任务中优先级最大的任务，然后获取这个任务的TCB并更新pxCurrentTCB（切换的具体函数），最后更新uxTopReadyPriority的值。容笔者说一下个人看法，从c语言和数据结构算法的层面学习，只能说是舍本逐末，透过Freertos这个小型系统，窥见庞大的操作系统架构的一角，这才是我们学习的重点。
Invalid keystore format，获取安全码SHA1值出错
yfy1907的博客
06-11 172
Invalid keystore format 错误
SpringBoot项目启动提示端口号占用
点滴汇聚，智在积累。——Danny
06-07 230
通过netstat查看当前端口号并没有被占用啊，那可能是使用了系统保留端口，通过。1、换个端口（不在系统保留端口的范围）于是换个端口号试试，还是提示占用。2、关闭hyper-v。
【冲刺秋招，许愿offer】第 一 天
Panci_的博客
06-08 425
现在技术还是菜的一批，中等难度的算法题很难一次(一小时)解出来，项目稍微一深挖或者问点视频中没讲到的扩展性问题直接拉跨化身聋哑人，牛客面经越看越焦虑，里面问到的八股也不是都会，哎，感觉给我大厂面试机会也是秒挂，前面摆烂两个月了，秋招将至，再冲击一下，希望能拿到个好点的offer。逻辑过期：加一个字段来表示是否过期，业务逻辑变为，看判断是否过期，过期，获取锁，开启子线程进行缓存重建，其他线程以及主线哼返回旧数据。缓存击穿问题是由于热点Key过期了，导致大量请求到达数据库，可以用互斥锁或者逻辑过期。
解析final原理
2301_79437276的博客
06-10 180
final 变量的赋值通过 putfield 指令来完成，在这条指令之后也会加入写屏障，保证在其它线程读到它的值时。//final保证不能读到两个值。第三种：【不加final都算是在堆中，Getstatic速度小于上面两种】5: bipush 20 // 将值直接放入栈中。之前的修改、赋值操作之后会同步到主内存中去（可见性）大于 short（短整型） 最大值会将其复制到类的。之前的指令不会重排序到后面去（有序性）其他线程访问 final 修饰的变量。，访问时从常量池获取。
juc CAS和AQS了解吗？原理是什么
04-23
是的，我了解juc CAS和AQS。CAS (Compare and Swap) 是一种多线程同步机制，用于更新共享变量的值，只有在变量的值符合预期值的情况下才更新。AQS (AbstractQueuedSynchronizer) 是一个抽象的基础同步工具类，它提供...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值