JUC (狂神说笔记三)

最新推荐文章于 2024-07-08 17:25:40 发布
最新推荐文章于 2024-07-08 17:25:40 发布
阅读量133 收藏 1
点赞数
分类专栏： 多线程 文章标签： 多线程
本文链接：https://blog.csdn.net/weixin_45457662/article/details/111643620
版权

16、JMM

什么是JMM？

JMM：Java Memory Model 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操作之前，必须把此变量同步回主内存

对于刚才上面的图示，我们不难发现，当我们其中一个线程修改了主存里面Flag的值以后，其他的线程是没有办法及时获取的，以至于出现了信息不对称的情形。

具体的代码实现：

package pers.mobian.jmm;

import java.util.concurrent.TimeUnit;

public class JMMTest {
    private static int num = 1;
    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            while (num == 1 ) {
                //循环体
            }
        }).start();

        //确保让开启的其他线程先执行
        TimeUnit.SECONDS.sleep(2);
        
        //修改变量的值，观察线程的变化
        num = 0;
        System.out.println(num);
    }
}

总结：我们的结果会打印0以后，就陷入了一个死循环。即可以理解为每一个线程将主存的变量都转换为了自己的私有变量，以至于内部修改，外部依然没有变化。

17、Volatile

请你谈谈你对Volatile的理解

  • Volatile是Java虚拟机提供轻量级的同步机制
  • Volatile保证可见性
  • Volatile不保证原子性
  • 禁止指令重排

17.1、保证可见性

将我们的代码修改为：

package pers.mobian.jmm;

import java.util.concurrent.TimeUnit;

public class JMMTest {
    //添加volatile关键字，保证了变量的可见性
    private static volatile int num = 1;
    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            while (num == 1 ) {
            }
        }).start();
        TimeUnit.SECONDS.sleep(2);
        num = 0;
        System.out.println(num);
    }
}

17.2、不保证原子性

按照JMM的概念分析，理论上只要我们的线程信息交换足够快，那么就可以完成结果为1000的运算。可是现实是很难做到。当我们添加了volatile关键字以后，依然不起作用，即无法保证我们运算的原子性。

测试代码：

package pers.mobian.jmm;

import java.util.concurrent.TimeUnit;

public class VoTest01 {
    private static volatile int num = 0;
    //加synchronized锁肯定是可以的
    private static  void add() {
        num++;
    }
    public static void main(String[] args) throws InterruptedException {

        //开启10个线程，每一个线程中执行100次方法
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                for (int i1 = 0; i1 < 100; i1++) {
                    add();
                }
            }).start();
        }

        //避免我们开启的线程还没有结束就执行主线程
        while (Thread.activeCount() > 2){
            Thread.yield();
        }
        System.out.println(num);
    }
}

我们反编译该类的.class文件javap -c VoTest01.class，可以得到其对应的字节码文件，通过字节码文件分析，一个简单的num++，需要经历三步，所以其不是原子性。

在这里插入图片描述

如果不添加lock锁和synchronized锁，如何保证原子性呢？

我们可以使用原子类

在这里插入图片描述

测试代码：

package pers.mobian.jmm;

import java.util.concurrent.atomic.AtomicInteger;

public class VoTest02 {
    //使用原子类
    private static AtomicInteger num = new AtomicInteger();

    private static void add() {
        //使用原子类的增加方法
        num.getAndIncrement();
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int i1 = 0; i1 < 100; i1++) {
                    add();
                }
            }).start();
        }
        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println(num);
    }
}

使用源自类的对象进行增加就不再是简单的+1了，这些类的底层直接和OS相关，直接在内存中修改值。其底层中很关键的一个类就是Unsafe类，它是一个很特殊的存在

17.3、指令重排

指令重排：我们写的程序，计算机并不一定是按照我们写的顺序执行的。

例如：

int a = 2; //1
int b = 3; //2
a = a + 1; //3
b = a + a; //4

我们编写代码的顺序是：1234。但是执行的顺序却有可能是1324、2134

数据a b c d的默认值都是0

指令重排前的结果：a=0、b=0

线程A线程B
a=cd=c
c=2c=5

指令重排后的结果：a=5、b=2

线程A线程B
d=2a=5
a=cb=d

指令重排在逻辑上是存在的

volatile如何保证我们的指令重排？

使用内存屏障（可以理解为CPU指令）：

  1. 保证特定的操作执行顺序
  2. 保证某些变量的内存可见性（volatile就是利用了这个特性实现了可见性）

在这里插入图片描述

综上所述：volatile可以保证可见性，不能保证原子性，由于内存屏障，可以保证避免指令重排的现象

18、单例模式

五种单例模式详解

19、CAS

编写一个CAS的测试代码：

package pers.mobian.cas;

import java.util.concurrent.atomic.AtomicInteger;

public class CASTest01 {
    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());
    }
}

点到getAndIncrement方法的源码中：

public class AtomicInteger extends Number implements java.io.Serializable {
    private static final jdk.internal.misc.Unsafe U = jdk.internal.misc.Unsafe.getUnsafe();
    private static final long VALUE = U.objectFieldOffset(AtomicInteger.class, "value");

    public final int getAndIncrement() {
        //参数列表：当前对象，当前对象在内存中的值，数字1
        return U.getAndAddInt(this, VALUE, 1);
    }
}

我们都知道Java无法直接操作内存，但是Java有关键字navite，可以调用C++方法，C++可以可以操作内存。但是Java给自己留了一个后门，可以通过Unsafe类操作内存

Unsafe类的对应源码：这是一个自旋锁

@HotSpotIntrinsicCandidate
//参数列表：当前对象，当前对象在内存中的值，数字1
public final int getAndAddInt(Object o, long offset, int delta) {
    int v;
    do {
        //offset：field/element offset
        //获取对象 o 的地址偏移值，再赋值给 v
        v = getIntVolatile(o, offset);
        //如果我的对象 o 加上地址偏移值还是等于 v ，那么我们就直接+1
    } while (!weakCompareAndSetInt(o, offset, v, v + delta));
    return v;
}

总结：

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

缺点：

  • 循环比较耗费时间
  • 一次性只能保证一个共享变量的原子性
  • ABA问题

ABA问题（狸猫换太子）

可以理解为线程B在很快的时间内执行了两次值的交换，且这一切都是在A线程执行之前。虽然数据进行了交换，但是A线程却不知道。

在这里插入图片描述

package pers.mobian.cas;

import java.util.concurrent.atomic.AtomicInteger;

public class CASTest02 {
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2020);

        // ============== 捣乱的线程 ==================
        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());
    }
}

执行结果：

true
2021
true
2020
true
6666

通过结果，我们可以再次发现，我们修改了值，但是cas依然可以比较交换

20、原子引用

使用这种原子操作，就可以解决CAS中的ABA问题。其思想就是增加一个乐观锁，此处是添加一个版本号

测试代码：

package pers.mobian.cas;

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

public class CASTest03 {
    //实际的业务开发中，我们引用的可能是一个对象
    static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(1, 1);

    public static void main(String[] args) {


        new Thread(() -> {
            int stamp = atomicStampedReference.getStamp(); // 获得版本号
            System.out.println("a1=>" + stamp);
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //参数：期望值，更新值，当前的版本号，增加对应的版本号
            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(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(atomicStampedReference.compareAndSet(1, 6, 
                    stamp, stamp + 1));

            //打印更新值是否成功，返回一个指定的布尔值
            //由于版本信息被悄悄地修改过，所以这里返回的是false
            System.out.println("b2=>" + atomicStampedReference.getStamp());
        }, "b").start();
    }
}

执行结果：

b1=>1
a1=>1
a2=>2
true
a3=>3
false
b2=>3

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

21、各种锁的理解

21.1、公平锁、非公平锁

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

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

//默认使用非公平锁
ReentrantLock reentrantLock = new ReentrantLock();
//传入true，使用公平锁
ReentrantLock reentrantLock2 = new ReentrantLock(true);


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

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

21.2、可重入锁

也叫递归锁。

可以理解为你拿着你家大门的钥匙，你只要打开了大门的锁，就可以自动打开房间里面的不同卧室的锁。

synchronized版本

package pers.mobian.relock;

public class ReLockTest01 {
    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 pers.mobian.relock;

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

public class ReLockTest02 {
    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() {
        //这是第一把锁，用于锁sms方法
        lock.lock();
        
        //这是第二把锁，用于锁call方法
        //当然我们也可以直接在call方法里面添加一把锁
        lock.lock();

        try {
            System.out.println(Thread.currentThread().getName() + "=>sms");
            call();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
            lock.unlock();
        }
    }

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

注意：添加的锁一定要配对出现，不然会出现死锁现象

21.3、自旋锁

前面我们也有提到一个自旋锁（SpinLock）

不断地尝试，直到成功为止

@HotSpotIntrinsicCandidate
//参数列表：当前对象，当前对象在内存中的值，数字1
public final int getAndAddInt(Object o, long offset, int delta) {
    int v;
    do {
        //offset：field/element offset
        //获取对象 o 的地址偏移值，再赋值给 v
        v = getIntVolatile(o, offset);
        //如果我的对象 o 加上地址偏移值还是等于 v ，那么我们就直接+1
    } while (!weakCompareAndSetInt(o, offset, v, v + delta));
    return v;
}

我们自定义一个自旋锁：

package pers.mobian.relock;

import java.util.concurrent.atomic.AtomicReference;

public class SpinLockDemo {
    
    //传递的参数类型是引用数据类型：默认值为null
    //传递的参数类型是基本数据类型int：默认值是0
    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 pers.mobian.relock;

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

public class SpinLockTest01 {
    public static void main(String[] args) throws InterruptedException {
//        我们传统的使用别人的锁的方式
//        ReentrantLock reentrantLock = new ReentrantLock();
//        reentrantLock.lock();
//        reentrantLock.unlock();

        //使用我们自定义锁
        SpinLockDemo lock = new SpinLockDemo();
        new Thread(() -> {
            lock.myLock();
            try {
                TimeUnit.SECONDS.sleep(4);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.myUnLock();
            }
        }, "T1").start();
        TimeUnit.SECONDS.sleep(2);
        
        new Thread(() -> {
            lock.myLock();
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.myUnLock();
            }
        }, "T2").start();
    }
}

执行结果：

T1=>myLock
T2=>myLock
T1=>myUnLock
T2=>myUnLock

总结：我们的T1会先进去拿到锁，然后又修改对应的信息为thread的下一个版本号，此时不需要进入自旋锁。就在此时，T2又拿到了它的锁，但是此时我们的自旋锁里面的thread的版本号已经不再是null，所以会进入自旋锁，不断循环。当T1释放锁时，其对应地解锁会将thread的版本号再次变成null，此时在自旋锁里面的T2就可以离开，最终释放锁。

21.4、死锁

在这里插入图片描述

测试案例：

package pers.mobian.relock;

import java.util.concurrent.TimeUnit;

public class DeadLockTest01 {

    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、在IDEA的使用jsp -l查看对应的进程号

在这里插入图片描述

2、使用jstack 进程号找到死锁的问题

在这里插入图片描述

继而达到排错的效果

排错的方式：查看日志、查看堆栈信息

孙小圣98
关注
专栏目录
JUC并发编程入门学习笔记（狂神说）
Free的午后
08-06 1167
因为热爱所以坚持，因为热爱所以等待。熬过漫长无戏可演的日子，终于换来了人生的春天，共勉！！！ 1. 什么是JUC JUC就是java.util.concurrent下面的类包，专门用于多线程的开发。 2. 线程和进程 进程是操作系统中的应用程序、是资源分配的基本单位，线程是用来执行具体的任务和功能，是CPU调度和分派的最小单位 一个进程往往可以包含多个线程，至少包含一个 1）进程 一个程序，QQ.EXE Music.EXE；数据+代码+pcb 一个进程可以包含多个线程，至少包含一个线..
Java面试--Java线程--Volatile关键字
AlbertWC的博客
11-02 204
我们先从java内存开始讲起。 JMM。 什么是JMM？ JMM即为JAVA 内存模型（java memory model）。因为在不同的硬件生产商和不同的操作系统下，内存的访问逻辑有一定的差异，结果就是当你的代码在某个系统环境下运行良好，并且线程安全，但是换了个系统就出现各种问题。Java内存模型，就是为了屏蔽系统和硬件的差异，让一套代码在不同平台下能到达相同的访问结果。 内存划分 JMM规定了内存主要划分为主内存和工作内存两种。此处的主内存和工作内存跟JVM内存划分(栈、堆、方法区)是在不同的
《深入理解Java虚拟机》(七) volatile 变量
bokerr的博客
10-29 231
@[TOC](《深入理解Java虚拟机》(七) volatile 变量) 学习JVM有一段时间了，现在开始进入并发阶段的学习；之前集中写博客是内存自动管理阶段，这部分有一个相当重要的问题JVM调优，这不仅增长见闻，与工作也有很大关系。之后的部分：虚拟机执行子系统、程序编译与代码调优就只是默默学习了一下概念。现在到了并发了，我知道是时候写博客记录下我的“李姐”了。没写博客的部分不是不重要，而是我还没实际触碰到，必然有一天那些忽视的东西还会重新捡起来。 概述 今天的主角是volatile变量，在讲它之前我会稍微
Java 开发， volatile 你必须了解一下
weixin_33912246的博客
05-22 307
上一篇文章说了 CAS 原理，其中说到了 Atomic* 类，他们实现原子操作的机制就依靠了 volatile 的内存可见性特性。如果还不了解 CAS 和 Atomic*，建议看一下我们说的 CAS 自旋锁是什么 并发的三个特性 首先说我们如果要使用 volatile 了，那肯定是在多线程并发的环境下。我们常说的并发场景下有三个重要特性：原子性、可见性、有序性。只有在满足了这三个特性，才能保证并发...
深入理解Java虚拟机（六）volatile关键字
meng_lemon的博客
04-14 264
关键字volatile是JVM提供的最轻量级的同步机制，但是他不容易被正确理解和使用。JVM内存模型对volatile转么定义了一些特殊的访问规则。 一旦一个共享变量被volatile修饰之后，那么它就具有了两层含义： 保证此变量对所有线程的可见性： “可见性” 指的是：当一条线程修改了这个变量的值，新值对于其他线程来说可以立即得知的。 禁止进行指令重排序 volatile的可见性   我们可...
狂神说笔记md文件与pdf
11-17
内含 javascript, java web, java基础, mybatis, MySQL, Redis, spring, spring boot, spring mvc, vue的md格式笔记与pdf文件
狂神说笔记_全.zip
01-11
【狂神说笔记_全.zip】是一个包含狂神说系列的Java学习资源的压缩包，主要涉及了Java基础、Spring Boot、JavaWeb、微服务、分布式系统、消息队列、并发编程、前端技术、数据库以及容器化技术等多个IT领域的核心知识...
狂神笔记，b站狂神说课程笔记大全
09-19
b站狂神说课程笔记大全，每个部分都有
【狂神说】笔记（史上最全）含各类md笔记.zip
01-22
【狂神说】笔记系列是全面且深入的IT学习资源，涵盖了从基础到进阶的各种技术领域。这个压缩包包含了JavaScript、JavaWeb、Java基础、MyBatis、MySQL、Redis、Spring、Spring Boot以及SpringMVC和Vue等多个关键知识...
《深入理解Java虚拟机》笔记：volatile的实现原理
stringKai的博客
09-17 166
volatile在并发程序中有两个特点： 1、保证其修饰变量的线程间可见性；2、禁止对其修饰变量的指令重排。 这两个特点都与volatile底层实现有关。 通过观察汇编代码可以发现，在对volatile变量赋值后，会多执行一条指令： lock add1 $0x0,(%esp) 这条指令的作用是：将本处理器的缓存写入内存，并使其他处理器的缓存无效。 显然通过这条命令可以让前面对volatile变量的修改对其他处理器立即可见。 因为在Java中， ...
狂神JUC并发笔记大全+Linux等资料
08-07
狂神JUC并发笔记大全+Linux等资料
深入理解java虚拟机之volatile关键字
异阁的专栏
03-05 331
volatile关键字 保证多线程间进行变量操作时的可见性 禁止指令重排序优化 首先了解下什么是原子操作：原子操作可以是一个步骤，也可以是多个操作步骤，但是其顺序不可以被打乱，也不可以被切割而只执行其中的一部分。将整个操作视作一个整体是原子性的核心特征。 比如，变量的自增操作 k++，分为三个步骤: 1. 从内存中读取出变量 j 的值； 2. 将变量j 的值加1； 3 .
狂神说juc笔记
m0_51654746的博客
09-06 1122
JUC就是java.util.concurrent包及其子包java默认有两个线程，一个是main线程，一个是GC线程对于java而言有三中开启线程的方式：Thread，Runnable，Callable，但是实际上并不是java开启的线程，调用的是底层的C++开启线程并发：多个线程操作同一个资源并行：多个线程同时进行,只有多核cpu才能并行java获取CPU核心数量 并发编程的本质：充分利用CPU的资源线程的状态：来自不同类，wait来自Object，sleep来自Thread企业中休眠使用的是TimeU
Java 中 volatile 的深入讲解
最新发布
小飞机爱旅游的博客
07-08 624
内存屏障是一种指令，用于限制指令重排序和确保内存操作的可见性。原子性：volatile 变量的读写操作是原子的，但复合操作（如 i++）不是原子的，需要使用 synchronized 或 Atomic 类来保证复合操作的原子性。禁止指令重排序优化：volatile 变量在写操作之前的操作不会被重排序到写操作之后，同样地，volatile 变量在读操作之后的操作不会被重排序到读操作之前。读操作：当一个线程读取一个 volatile 变量时，JMM 会将该线程的本地内存设置为无效，并从主内存中读取最新的值。
14、ForkJoin
c19990515的博客
02-11 198
14、ForkJoin ForkJoin 在 JDK 1.7 ， 并行执行任务！提高效率。大数据量！ 大数据：Map Reduce （把大任务拆分为小任务） ForkJoin 特点：工作窃取 这个里面维护的都是双端队列 ** * 求和计算的任务！ * 3000 6000（ForkJoin） 9000（Stream并行流） * // 如何使用 forkjoin * // 1、forkjoinPool 通过它来执行 * // 2、计算任务 forkjoinPool.execute(Fork
深入理解Java虚拟机笔记---volatile变量的特殊规则
云原生之家
12-15 1931
当一个变量定义成volatile之后，它将具备两种特性：第一是保证此变量对所有线程的可见性，这里的“可见性”是指当一条线程修改了这个变量的值，新值对于其它线程是可以立即得知的，变量值在线程间传递均需要通过主内存来完成，如：线程A修改一个普通变量的值，然后向主内存进行回写，另外一条线程B在线程A回写完成了之后再从主内存进行读取操作，新变量的值才会对线程B可见。    关于volatile变量的可见
深入理解java中volatile的特性
myjess’s blog
09-15 306
一、 对volatile的理解 1. volatile是java虚拟机提供的轻量级的同步机制。 保证可见性 不保证原子性 禁止指令重排 保证可见性 什么是可见性？ JMM（java内存模型） JMM是一个抽象的概念本身不存在，它描述的是一组规范，通过这组规范定义了程序中各个变量的访问方式。 可见性 原子性 有序性 由于JVM运行程序的实体是线程，而每个线程创建时JVM都会为其创建一个工作内存(有些地方称为栈空间)，工作内存是每个线程的私有数据区域，而Java内存模型中规定所有变量都存储在主内存，
《深入理解java虚拟机》volatile代码案例的一个bug？
Abysscarry的博客
11-28 827
背景： 最近在读周志明的《深入理解 java虚拟机》第二版，发现第367页的 volatile演示例子（代码清单 12-1）无法运行出相应结果，在此记录下原因及解决办法 ~ 注：代码运行环境为 win64 - jdk1.8 - IntelliJ IDEA 书中代码如下： import java.util.Map; /** * @Author: yuanj * @Date: 2018/11/...
深入理解 JVM（9）volatile 关键字
HappyFeet的博客
09-08 545
本文主要介绍了 volatile 关键字的特性和用法。
狂神说java-juc并发编程
09-23
狂神说java-juc并发编程是指狂神在讲解Java并发编程时提到了Java Util Concurrent（简称JUC）这个包。JUC是Java中用于处理并发编程的三个包之一，它包含了一系列的并发工具类和线程安全的集合类。其中，java.util....
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值