JUC-04

最新推荐文章于 2022-03-20 16:57:46 发布
最新推荐文章于 2022-03-20 16:57:46 发布
阅读量211 收藏
点赞数
分类专栏： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/oldwangold/article/details/105671668
版权

16、JMM

请你谈谈你对Volatile的理解

Volatile 是 Java 虚拟机提供的轻量级的同步机制

1、保证可见性

2、不保证原子性

3、禁止指令重排

什么是 JMM

JMM：Java内存模型，不存在的东西，概念！约定！

关于JMM的一些同步的约定：

1、线程解锁前，必须把共享变量立刻刷回主存。

2、线程加锁前，必须读取主存中的最新值到工作内存中！

3、加锁和解锁是同一把锁

线程 工作内存、主内存

在这里插入图片描述

在这里插入图片描述

内存交互操作有8种，虚拟机实现必须保证每一个操作都是原子的，不可在分的（对于double和long类型的变量来说，load、store、read和write操作在某些平台上允许例外）

  • lock （锁定）：作用于主内存的变量，把一个变量标识为线程独占状态
  • unlock （解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定
  • read （读取）：作用于主内存变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用
  • load （载入）：作用于工作内存的变量，它把read操作从主存中变量放入工作内存中
  • use （使用）：作用于工作内存中的变量，它把工作内存中的变量传输给执行引擎，每当虚拟机遇到一个需要使用到变量的值，就会使用到这个指令
  • assign （赋值）：作用于工作内存中的变量，它把一个从执行引擎中接受到的值放入工作内存的变量副本中
  • store （存储）：作用于主内存中的变量，它把一个从工作内存中一个变量的值传送到主内存中，以便后续的write使用
  • write 　（写入）：作用于主内存中的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中

JMM对这八种指令的使用，制定了如下规则：

  • 不允许read和load、store和write操作之一单独出现。即使用了read必须load，使用了store必须write
  • 不允许线程丢弃他最近的assign操作，即工作变量的数据改变了之后，必须告知主存
  • 不允许一个线程将没有assign的数据从工作内存同步回主内存
  • 一个新的变量必须在主内存中诞生，不允许工作内存直接使用一个未被初始化的变量。就是怼变量实施use、store操作之前，必须经过assign和load操作
  • 一个变量同一时间只有一个线程能对其进行lock。多次lock后，必须执行相同次数的unlock才能解锁
  • 如果对一个变量进行lock操作，会清空所有工作内存中此变量的值，在执行引擎使用这个变量前，必须重新load或assign操作初始化变量的值
  • 如果一个变量没有被lock，就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量
  • 对一个变量进行unlock操作之前，必须把此变量同步回主内存
package com.won.tvolatile;

import java.util.concurrent.TimeUnit;

public class JMMDemo {
    private static int num = 0;
    public static void main(String[] args) { // main线程

        new Thread(()->{ // 线程1
            while (num == 0) {

            }
        }).start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        num = 1;
        System.out.println(num);
    }
}

问题：程序不知道主内存中的值已经被修改过了！

在这里插入图片描述

17、Volatile

保证可见性

package com.won.tvolatile;

import java.util.concurrent.TimeUnit;

public class JMMDemo {
    // 不加 volatile 程序就会死循环
    // 加 volatile 可以保证可见性
    private volatile static int num = 0;
    public static void main(String[] args) { // main线程

        new Thread(()->{ // 线程1 对主内存的变化不知道
            while (num == 0) {

            }
        }).start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        num = 1;
        System.out.println(num);
    }
}

不保证原子性

原子性：不可分割

线程A在执行任务的时候，不能被打扰，也不能被分割。要么同时成功，要么同时失败！

package com.won.tvolatile;

// 不保证原子性
public class VDemo02 {
    // volatile 不保证原子性
    private volatile static int num = 0;
    public static void add() {
        num++;
    }
    public static void main(String[] args) {
        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() + " " + num); // main 19791
    }
}

如果不加 lock 和 synchronized，怎样保证原子性？

在文件夹：D:\IdeaProjects\JUC\target\classes\com\won\tvolatile 中 输入 cmd 快捷键，然后反编译指令：javap -c VDemo02.class，可以得到反编译文件。

在这里插入图片描述
使用原子类，解决原子性问题

在这里插入图片描述

package com.won.tvolatile;

import java.util.concurrent.atomic.AtomicInteger;

// 不保证原子性
public class VDemo02 {
    // volatile 不保证原子性
    // 原子类的Integer
    private volatile static AtomicInteger num = new AtomicInteger();
    public static void add() {
        //num++; // 不是一个原子性操作
        num.getAndIncrement(); // AtomicInteger 的+1方法，CAS
    }
    public static void main(String[] args) {
        for (int i = 1; i <= 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    add();
                }
            }).start();
        }
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() + " " + num);
    }
}

这些类的底层都直接和操作系统挂钩！在内存中修改值！Unsafe类是一个很特殊的存在。

指令重排

什么是指令重排：你写的程序，计算机并不是按照你写的那样去执行的。

源代码–>编译器优化的重排–>指令并行也可能会重排–>内存系统也会重排–>执行

处理器在进行指令重排的时候，考虑：数据间的依赖性！

int x = 1; // 1
int y = 2; // 2
x = x + 5; // 3
y = x * x; // 4

我们期望的是：1234 但是可能执行的时候会变成 2134 1324
但不可能是 4123

可能造成影响的结果： a b c d 这四个值默认都是0；

线程A线程B
x = ay = b
b = 1a = 2

正常的结果：x = 0； y = 0；但是可能由于指令重排

线程A线程B
b = 1a = 2
x = ay = b

指令重排导致的诡异结果：x = 2；y = 1；

非计算机专业

volatile可以避免指令重排：

内存屏障，CPU指令，作用：

1、保证特定的操作的执行顺序！

2、可以保证某些变量的内存可见性（利用这些特性volatile实现了可见性）
在这里插入图片描述
volatile是可以保证可见性，不能保证原子性，由于内存屏障，可以保证避免指令重排的现象产生！

18、彻底玩转单例模式

19、深入理解CAS

什么是CAS

大厂必须深入研究底层，有所突破！修内功！

package com.won.cas;

import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo {
    // CAS compareAndSet：比较并交换
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2020);
        // 期望、更新
        // public final boolean compareAndSet(int expect, int update)
        // 如果我期望的值达到了，那么就更新，否则，就不更新，CAS 是 CPU 的并发原语！
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());
        atomicInteger.getAndIncrement();
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());
    }
}

Unsafe类

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

CAS：比较当前工作内存中的值和主内存中的值，如果这个值是期望的，那么则执行操作！如果不是就一直循环！

缺点：

1、循环耗时

2、一次性只会保证一个共享变量的原子性

3、ABA问题

CAS：ABA问题（狸猫换太子）

在这里插入图片描述

package com.won.cas;

import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo {
    // CAS compareAndSet：比较并交换
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2020);
        // 期望、更新
        // public final boolean compareAndSet(int expect, int update)
        // 如果我期望的值达到了，那么就更新，否则，就不更新，CAS 是 CPU 的并发原语！
        // =================捣乱的线程==================
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());
        System.out.println(atomicInteger.compareAndSet(2021, 2020));
        System.out.println(atomicInteger.get());

        // =================期望的线程==================
        System.out.println(atomicInteger.compareAndSet(2020, 6666));
        System.out.println(atomicInteger.get());
    }
}

20、原子引用

解决ABA问题，引入原子引用！对应的思想：乐观锁！

带版本号的原子操作！

注意：

Integer使用了对象缓存机制，默认范围是-128~127，推荐使用静态工厂方法valueOf获取对象实例，而不是new，因为valueOf使用了缓存，而new一定会创建新的对象分配新的内存空间；

package com.won.cas;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicStampedReference;

public class CASDemo {
    //  AtomicStampedReference 注意，如果泛型是一个包装类，注意对象的引用问题
    //  正常在业务操作，这里比较的都是一个个对象
    static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(1,1);
    public static void main(String[] args) {
        //AtomicInteger atomicInteger = new AtomicInteger(2020);

        new Thread(()->{
            int stamp = atomicStampedReference.getStamp(); // 获得版本号
            System.out.println("a1=>" + stamp);

            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(atomicStampedReference.compareAndSet(1, 2,
                    atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
            System.out.println("a2=>" + atomicStampedReference.getStamp());
            System.out.println(atomicStampedReference.compareAndSet(2, 1,
                    atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
            System.out.println("a3=>" + atomicStampedReference.getStamp());
        },"a").start();

        // 乐观锁的原理相同！
        new Thread(()->{
            int stamp = atomicStampedReference.getStamp(); // 获得版本号
            System.out.println("b1=>" + stamp);
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(atomicStampedReference.compareAndSet(1, 6, stamp, stamp + 1));
            System.out.println("b2=>" + atomicStampedReference.getStamp());

        },"b").start();

    }
}

在这里插入图片描述

21、各种锁的理解

1、公平锁

公平锁：非常公平，不能够插队，必须先来后到！

非公平锁：非常不公平，可以插队（默认都是非公平）

public ReentrantLock() {
    sync = new NonfairSync();
}

public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

2、可重入锁

可重入锁（递归锁）

在这里插入图片描述

synchronized

package com.won.lock;

// synchronized
public class Demo01 {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(()->{
            phone.sms();
        },"A").start();

        new Thread(()->{
            phone.sms();
        },"B").start();


    }
}

class Phone{
    public synchronized void sms() {
        System.out.println(Thread.currentThread().getName() + " sms");
        call(); // 这里也有锁
    }

    public synchronized void call() {
        System.out.println(Thread.currentThread().getName() + " call");
    }
}

Lock 版

package com.won.lock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

// lock
public class Demo02 {
    public static void main(String[] args) {
        Phone2 phone = new Phone2();

        new Thread(()->{
            phone.sms();
        },"A").start();

        new Thread(()->{
            phone.sms();
        },"B").start();
    }
}

class Phone2{
    Lock lock = new ReentrantLock();
    public void sms() {
        // 锁必须配对，否则就会死在里面
        lock.lock(); // 细节问题：lock.lock();lock.unlock();
        try {
            System.out.println(Thread.currentThread().getName() + " sms");
            call(); // 这里也有锁
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public synchronized void call() {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + " call");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

3、自旋锁

spinlock
在这里插入图片描述
我们来自定义一个锁测试

package com.won.lock;

import java.util.concurrent.atomic.AtomicReference;

/**
 * 自旋锁
 */
public class SpinlockDemo {
    // int 0
    // Thread null
    AtomicReference<Thread> atomicReference = new AtomicReference<>();

    // 加锁
    public void myLock() {
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName() + "==> myLock");
        // 自旋锁
        while (!atomicReference.compareAndSet(null,thread)) {

        }
    }

    // 解锁
    public void myUnLock() {
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName() + "==> myUnLock");
        atomicReference.compareAndSet(thread,null);
    }
}

测试

package com.won.lock;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

public class TestSpinLock {
    public static void main(String[] args) throws InterruptedException {
        //ReentrantLock reentrantLock = new ReentrantLock();
        //reentrantLock.lock();
        //reentrantLock.unlock();

        // 底层使用的自旋锁 CAS
        SpinlockDemo lock = new SpinlockDemo();
        new Thread(()->{
            lock.myLock();
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.myUnLock();
            }
        },"T1").start();

        TimeUnit.SECONDS.sleep(1);

        new Thread(()->{
            lock.myLock();
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.myUnLock();
            }
        },"T2").start();
    }
}

在这里插入图片描述

4、死锁

死锁是什么？

在这里插入图片描述
死锁测试，怎么排除死锁？

package com.won.lock;

import java.util.concurrent.TimeUnit;

public class DeadLockDemo {
    public static void main(String[] args) {
        String lockA = "lockA";
        String lockB = "lockB";

        new Thread(new MyThread(lockA,lockB),"T1").start();
        new Thread(new MyThread(lockB,lockA),"T2").start();
    }
}

class MyThread implements Runnable{
    private String lockA;
    private String lockB;

    public MyThread(String lockA, String lockB) {
        this.lockA = lockA;
        this.lockB = lockB;
    }

    @Override
    public void run() {
        synchronized (lockA) {
            System.out.println(Thread.currentThread().getName()+" lock:"+lockA+" =>get "+lockB);

            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            synchronized (lockB) {
                System.out.println(Thread.currentThread().getName()+" lock:"+lockB+" =>get "+lockA);
            }
        }
    }
}

解决问题

1、使用 jps -l 定位进程号
在这里插入图片描述
2、使用 jstack 进程号 找到死锁问题
在这里插入图片描述
面试，工作中，排查问题：

1、日志

2、堆栈信息

王加油
关注
专栏目录
JUC学习 - 深入剖析线程池（ThreadPoolExecutor）（补）
TyuIn的博客
12-05 589
接上一篇博客 https://blog.csdn.net/qq_43605444/article/details/121727738?spm=1001.2014.3001.5501 6、Worker 类 下面的是在 Worker 类上的官方的一段注释： /** * Class Worker mainly maintains interrupt control state for * threads running tasks, along with other minor bookkeeping.
04.JUC 锁- AQS - CLH 队列
一把空心菜
02-22 1623
基本概念首先我们需要知道两个概念：AQS、CHL 队列。 AQS：即 AbstractQueuedSynchronizer 类，它是整个 J.U.C 框架的核心所在。其中之一的功能就是将线程封装在一个节点里面，不同的节点通过连接形成了一个 CHL 队列。 CHL 队列：它是一个非阻塞的 FIFO 队列，也就是说在并发条件下往此队列做插入或移除操作不会阻塞，它通过自旋锁和 CAS 保证节点插入和移除的
Android JMM8大原子操作
zenmela2011的专栏
03-20 1735
1.java内存模型的8大原子操作 Java内存模型(Java Memory Model, JMM)的8大原子操作： ①lock(锁定)：作用于主内存的变量，它把一个变量标识为一条线程独占的状态。 ②unlock(解锁)：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量 才可以被其他线程锁定。 ③read(读取)：作用于主内存的变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用。 ④load(载入)：作用于工作内存的变量，它把read操作从主内存中
JMM和Lock
qq_40764952的博客
02-23 324
一 .**CPU CPU怎么保证并发控制 (1) 关中断 (2)缓存一致性协议 每个硬件厂商 协议不同 常见的interl 的 MESI 通过四种状态 判断如上图 CPU的速度和内存的速度（100 ：1） 这里的速度值得是ALU访问寄存器的速度比访问内存的速度快100倍 为了充分利用CPU的计算能力，在CPU和内存中间引入缓存的概念（工业上的妥协，考虑性价比） 现在的工业实践，多采用三级缓存的架构 缓存行：一次性读取的数据块 程序的局部性原理：空间局部性 时间局部性 如果缓存行大：命中率高，但读取效率低
JMM内存区域及常见锁
weixin_43502533的博客
05-29 480
目录JMM内存模型概述内存间交互volatile关键字三大特性可见性有序性原子性先行发生原则常见锁1 JMM内存模型 概述 为了保证CPU高速运算与内存速度不匹配问题，引入了缓存的概念，JMM屏蔽了底层细节展现的分为主内存、工作内存、线程。 主内存 存储在运行中可被多个线程共享的数据。 工作内存 各线程无法直接操作主内存中数据，只能将主内存数据放置工作内存，操作完成后在写回。 内存间交互 规定了主内存和工作内存交互方式，共包括lock、unlock、read、load、use、assign、store
总结：对Java内存模型JMM的理解
RipL的专栏
08-08 4092
JMM规定了线程的工作内存和主内存的交互关系，以及线程之间的可见性和程序的执行顺序。一方面，要为程序员提供足够强的内存可见性保证；另一方面，对编译器和处理器的限制要尽可能地放松。JMM对程序员屏蔽了CPU以及OS内存的使用问题，能够使程序在不同的CPU和OS内存上都能够达到预期的效果。 在jsr-133中是这么定义的 A memory model describes, given a
【深入理解JVM】：Java内存模型JMM
热门推荐
smile4lee的博客
05-07 2万+
多任务和高并发的内存交互多任务和高并发是衡量一台计算机处理器的能力重要指标之一。一般衡量一个服务器性能的高低好坏，使用每秒事务处理数（Transactions Per Second，TPS）这个指标比较能说明问题，它代表着一秒内服务器平均能响应的请求数，而TPS值与程序的并发能力有着非常密切的关系。物理机的并发问题与虚拟机中的情况有很多相似之处，物理机对并发的处理方案对于虚拟机的实现也有相当大的参考
juc-12-线程池2-线程池的使用
qq_20633779的博客
12-01 363
这是线程池第二篇文章，上一篇文章写了如何创建线程池，这篇文章用代码来演示通过 ThreadPoolExecutor 和 Executors的静态工厂方法创建线程池，以及这些线程池的基本使用，然后重点讲解 ThreadPoolExecutor 的实现接口 ExecutorService 中的常用API，如何通过这些API来管理线程池。 1、ThreadPoolExecutor 创建线程池 从上篇文章《juc-12-线程池2-线程池的使用》中，我们学习到 ThreadPoolExecutor 几个重载的构造
把数字80H-8FH中的内容0-F改为ASC码，存放到90H-9FH的汇编语言及机器码 JUC-II微程序设计
05-20
机器码 JUC-II 微程序设计： ``` 地址 微指令 00H 1110 0000 1000 0000 ; 将 80H 存入 MAR 02H 1100 0000 0000 0010 ; 将 MDR 的值存入 SI 04H 1110 0000 1001 0000 ; 将 90H 存入 MAR 06H 1100 0000 0000 0010 ; ...
JUC-II微程序设计 把数字80H-8FH中的内容0-F改为ASC码，存放到90H-9FH的汇编语言及机器码
05-20
汇编语言代码如下： ``` MOV SI, 0080H ;将数据起始地址存入SI寄存器 MOV DI, 0090H ;将目标地址存入DI寄存器 MOV CX, 0010H ;循环10次，处理16个数据 LOOP_START: ...04 30 88 07 46 47 E2 F8 F4 ```
jmm与并发
Duncan_dsf的博客
03-13 266
JMM 主内存和工作内存 主内存 包括：实例字段、静态字段、和构成数组对象的元素；但不包括局部变量和方法参数，因为他们是线程私有的 所有变量都存储在主内存 工作内存是线程使用到的变量的主内存的副本，线程对变量的操作必须在工作内存中进行 内存交互操作 lock unlock read load use assign store write 操作规则： volatile ——jv...
Java并发之类型修饰符volatile
makersy的博客
12-07 410
今天看Java并发时，看到了一个新的关键字volatile，觉得有必要记一下。 基础概念 ​ 先补充一下概念：Java 内存模型中的可见性、原子性和有序性。 可见性： 　　可见性是一种复杂的属性，因为可见性中的错误总是会违背我们的直觉。通常，我们无法确保执行读操作的线程能适时地看到其他线程写入的值，有时甚至是根本不可能的事情。为了确保多个线程之间对内存写入操作的可见性，必须使用同步机制。 可见...
Java的JMM内存模型
whx_0612的博客
09-10 152
要说清楚JMM的工作原理首先清楚Happens-Before规则。 Happens-Before定义 如果一个操作Happens-Before另一个操作，那么第一个操作的执行结果将对第二个操作可见，而且第一个操作的执行顺序排在第二个操作之前。 两个操作之间存在Happens-Before关系，并不意味着一定要按照Happens-Before原则制定的顺序来执行。如果重排序之后的执行结果与按照Happens-Before关系来执行的结果一致，那么这种重排序并不非法。 注意：不能将Happens-Befor
Java内存模型JMM中有哪些原子操作？
Zebe
04-04 1149
JMM八大原子操作是：lock（锁定）、unlock（解锁）、read（读取）、load（载入）、use（使用）、assign（赋值）、store（存储）、write（写入）。 以上操作对应具体含义如下：1、lock：作用于主内存的变量，把一个变量标记为一条线程独占状态。 2、unlock：作用于主内存的变量，把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。 3、read：作用于主内存的变量，把一个变量值从主内存传输到线程的工作内存中，以便随后的load动作使用。
JVM内存模型（JMM）
Hi_Red_Beetle的博客
05-19 890
目录 一、概念 二、线程间如何交换数据？ 一、概念 JMM——Java Memeory Model，即Java内存模型，也可以说是JVM内存模型。它的主要作用就是用于定义变量的访问规则。这里的变量是指所有线程可以共享的变量，比如成员变量，不能是局部变量。因为局部变量（在方法内）是放在栈中的，而每个线程都有属于自己的栈，所以局部变量不是线程共享的。 JMM将内存划分为两个区：主内存区和工作内存区。可能这里你会问内存空间不是分为堆、栈、方法区等这些区域吗？其实都没有错，只是从不同的角度进心的划分而已。
并发编程-进阶[volatile篇](java内存模型、Volatile、可见性、有序性、happens-before)
JolyouLu的博客
02-03 518
并发编程-进阶[volatile篇] CPU如何工作 在了解锁之前我们先需要知道CPU是如何工作的，为什么我们使用多线程时会出现不同步的问题 CPU是如何工作的，CPU到我们的硬盘粗略讲是需要经过 一级二级三级缓存=>内存=>硬盘，为什么CPU不能直接对硬盘IO操作呢，首先我们先了解一下CPU，缓存，内存，硬盘运算速度 CPU的运算速度一般是GHz，GHz=1000MHz，像2.0，就表示CPU的运算速度是2000000000次/秒（速度极快） 缓存是才CPU内部的相当于一条流水线，C
JMM入门
多一天，多一点
06-17 228
在说JMM之前我们先来看一下CPU的缓存简单架构图 CPU缓存架构 ​ 因为CPU的速度和RAM的速度不是一个量级，如果CPU与内存直接交互的话，会造成CPU饥饿（CPU处理完了，长时间等待状态）。为了解决CPU与RAM速度不匹配问题，就产生了缓存（cache）的概念，缓存又分为一级缓存（L1）、二级缓存（L2）、三节缓存（L3）等。CPU是从缓存中获取数据进行处理，处理完后刷回缓存中，而缓存从RAM中获取数据，在收到CPU处理完的数据后刷回RAM中，这样就尽可能的解决了CPU饥饿问题。 JMM内存模型
Java高级-线程同步lock与unlock使用
weixin_34358092的博客
11-11 387
2019独角兽企业重金招聘Python工程师标准>>> ...
_Command_line_settings_desktop_wallpaper_tool,_Su_command-wallpa
最新发布
09-17
_Command_line_settings_desktop_wallpaper_tool,_Su_command-wallpaper
"Java-JUC-多线程 进阶：遇见狂神说的JUC并发编程进阶版概要
Java-JUC-多线程进阶是一门关于Java并发编程的课程，来源于B站的《遇见狂神说》。这门课程于2019年5月31日发布，主要涵盖了以下主题：JUC的概念，进程和线程的回顾，Lock锁的使用，生产者和消费者模式，8锁的现象，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值