【JAVA 多线程】可见性 原子性 并发工具类

于 2024-04-11 11:10:18 发布
阅读量815 收藏 12
点赞数 9
分类专栏： java 文章标签： java jvm 开发语言 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/vdssdf/article/details/137631616
版权

1. 可见性

可见性是指一个线程对共享变量的修改，对于另一个线程来说是否可见。

1.1 不可见问题

程序问题 : 女孩虽然知道结婚基金是十万，但是当基金的余额发生变化的时候，女孩无法知道最新的余额。

public class Money {
    public static int money = 100000;
}
​
public class Girl extends Thread {
    @Override
    public void run() {
        while(Money.money == 100000){
​
        }
        System.out.println("结婚基金已经不是十万了");
    }
}
​
public class Boy extends Thread {
    @Override
    public void run() {
        try {
            Thread.sleep(10);
            Money.money = 90000;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
​
public class Demo {
    public static void main(String[] args) {
        Girl t1 = new Girl();
        t1.setName("小路同学");
        t1.start();
​
        Boy t2 = new Boy();
        t2.setName("小皮同学");
        t2.start();
    }
}

1.2 原因分析

1，堆内存是线程共享的，每一个线程都有自己隔离的本地内存(栈)。

2 ，每一个线程在使用堆里面变量的时候，都会先拷贝一份到变量的副本中。

3 ，在线程中，每一次使用是从变量的副本中获取的。

Volatile : 强制线程每次在使用的时候，都会看一下共享区域最新的值，从而可以解决上述问题。也就是说volatile能保证线程的可见性。

代码实现 :

public class Money {
    public static volatile int money = 100000;
}
​
public class Girl extends Thread {
    @Override
    public void run() {
        while(Money.money == 100000){
​
        }
        System.out.println("结婚基金已经不是十万了");
    }
}
​
public class Boy extends Thread {
    @Override
    public void run() {
        try {
            Thread.sleep(10);
            Money.money = 90000;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
​
public class Demo {
    public static void main(String[] args) {
        Girl t1 = new Girl();
        t1.setName("小路同学");
        t1.start();
​
        Boy t2 = new Boy();
        t2.setName("小皮同学");
        t2.start();
    }
}

1.3 synchronized解决

synchronized解决 :

1 ，线程获得锁

2 ，清空变量副本

3 ，拷贝共享变量最新的值到变量副本中

4 ，执行代码

5 ，将修改后变量副本中的值赋值给共享数据

6 ，释放锁

所以说synchronized 也能保证线程的可见性。

代码实现 :

public class Money {
    public static Object lock = new Object();
    public static int money = 100000;
}
​
public class Girl extends  Thread {
    @Override
    public void run() {
        while(true){
            synchronized (Money.lock){
                if(Money.money != 100000){
                    System.out.println("结婚基金已经不是十万了");
                    break;
                }
            }
        }
    }
}
​
public class Boy extends Thread {
    @Override
    public void run() {
        synchronized (Money.lock) {
            try {
                Thread.sleep(10);
                Money.money = 90000;
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
​
public class Demo {
    public static void main(String[] args) {
        Girl t1 = new Girl();
        t1.setName("小路同学");
        t1.start();
​
        Boy t2 = new Boy();
        t2.setName("小皮同学");
        t2.start();
    }
}

2 原子性

原子性是指在一次操作或者多次操作中，要么所有的操作都成功，要么所有的操作都失败，多个操作是一个不可以分割的整体。

代码实现 :

public class AtomDemo {
    public static void main(String[] args) {
        MyAtomThread atom = new MyAtomThread();
​
        for (int i = 0; i < 100; i++) {
            new Thread(atom).start();
        }
    }
}
class MyAtomThread implements Runnable {
    private int count = 0; //送冰淇淋的数量
​
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            //1,从共享数据中读取数据到本线程栈中.
            //2,修改本线程栈中变量副本的值
            //3,会把本线程栈中变量副本的值赋值给共享数据.
            count++;
            System.out.println("已经送了" + count + "个冰淇淋");
        }
    }
}

代码总结 : count++ 不是一个原子性操作, 他在执行的过程中,有可能被其他线程打断

1.1 volatile关键字不能保证原子性

解决方案 : 我们可以给count++操作添加锁，那么count++操作就是临界区中的代码，临界区中的代码一次只能被一个线程去执行，所以count++就变成了原子操作。

package com.itheima.threadatom2;
​
public class AtomDemo {
    public static void main(String[] args) {
        MyAtomThread atom = new MyAtomThread();
​
        for (int i = 0; i < 100; i++) {
            new Thread(atom).start();
        }
    }
}
class MyAtomThread implements Runnable {
    private volatile int count = 0; //送冰淇淋的数量
    private Object lock = new Object();
​
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            //1,从共享数据中读取数据到本线程栈中.
            //2,修改本线程栈中变量副本的值
            //3,会把本线程栈中变量副本的值赋值给共享数据.
            synchronized (lock) {
                count++;
                System.out.println("已经送了" + count + "个冰淇淋");
            }
        }
    }
}

1.2 原子性_AtomicInteger

java从JDK1.5开始提供了java.util.concurrent.atomic包(简称Atomic包)，这个包中的原子操作类提供了一种用法简单，性能高效，线程安全地更新一个变量的方式。因为变量的类型有很多种，所以在Atomic包里一共提供了13个类，属于4种类型的原子更新方式，分别是原子更新基本类型、原子更新数组、原子更新引用和原子更新属性(字段)。本次我们只讲解

使用原子的方式更新基本类型，使用原子的方式更新基本类型Atomic包提供了以下3个类：

AtomicBoolean： 原子更新布尔类型

AtomicInteger： 原子更新整型

AtomicLong： 原子更新长整型

以上3个类提供的方法几乎一模一样，所以本节仅以AtomicInteger为例进行讲解，AtomicInteger的常用方法如下：

public AtomicInteger()：                 初始化一个默认值为0的原子型Integer
public AtomicInteger(int initialValue)：  初始化一个指定值的原子型Integer
​
int get():                              获取值
int getAndIncrement():                   以原子方式将当前值加1，注意，这里返回的是自增前的值。
int incrementAndGet():                   以原子方式将当前值加1，注意，这里返回的是自增后的值。
int addAndGet(int data):                 以原子方式将输入的数值与实例中的值（AtomicInteger里的value）相加，并返回结果。
int getAndSet(int value):                以原子方式设置为newValue的值，并返回旧值。

代码实现 :

package com.itheima.threadatom3;
​
import java.util.concurrent.atomic.AtomicInteger;
​
public class MyAtomIntergerDemo1 {
//    public AtomicInteger()：                  初始化一个默认值为0的原子型Integer
//    public AtomicInteger(int initialValue)： 初始化一个指定值的原子型Integer
    public static void main(String[] args) {
        AtomicInteger ac = new AtomicInteger();
        System.out.println(ac);
​
        AtomicInteger ac2 = new AtomicInteger(10);
        System.out.println(ac2);
    }
​
}
public class MyAtomIntergerDemo2 {
    public static void main(String[] args) {
        // int get():                    获取值
        AtomicInteger ac1 = new AtomicInteger(10);
        System.out.println(ac1.get());//10
​
        // int getAndIncrement():     以原子方式将当前值加1，注意，这里返回的是自增前的值。
        AtomicInteger ac2 = new AtomicInteger(10);
        int andIncrement = ac2.getAndIncrement();
        System.out.println(andIncrement);//10
        System.out.println(ac2.get());//11
​
        // int incrementAndGet():     以原子方式将当前值加1，注意，这里返回的是自增后的值。
        AtomicInteger ac3 = new AtomicInteger(10);
        int i = ac3.incrementAndGet();
        System.out.println(i);//自增后的值 11
        System.out.println(ac3.get());//11
​
        // int addAndGet(int data):  以原子方式将参数与对象中的值相加，并返回结果。
        AtomicInteger ac4 = new AtomicInteger(10);
        int i2 = ac4.addAndGet(20);
        System.out.println(i2);//30
        System.out.println(ac4.get());//30
​
        // int getAndSet(int value):  以原子方式设置为newValue的值，并返回旧值。
        AtomicInteger ac5 = new AtomicInteger(10);
        int andSet = ac5.getAndSet(20);
        System.out.println(andSet);//10 
        System.out.println(ac5.get());//20
​
        // int getAndAdd(int data):  以原子方式将参数与对象中的值相加，并返回相加前的值。
        AtomicInteger ac6 = new AtomicInteger(10);
        int i3 = ac6.getAndAdd(20);
        System.out.println(i3);//10
        System.out.println(ac6.get());//30
​
    }
}

1.3 AtomicInteger-内存解析

AtomicInteger原理 : 自旋锁 + CAS 算法

CAS算法：

有3个操作数（内存值V， 旧的预期值A，要修改的值B）

当旧的预期值A == 内存值 此时修改成功，将V改为B

当旧的预期值A！=内存值 此时修改失败，不做任何操作

并重新获取现在的最新值（这个重新获取的动作就是自旋）

子类分

1.4 AtomicInteger-源码解析

源码解析 :

​
//先自增，然后获取自增后的结果
public final int incrementAndGet() {
        //+ 1 自增后的结果
        //this 就表示当前的atomicInteger（值）
        //1    自增一次
        return U.getAndAddInt(this, VALUE, 1) + 1;
}
​
public final int getAndAddInt(Object o, long offset, int delta) {
        //v 旧值
        int v;
        //自旋的过程
        do {
            //不断的获取旧值
            v = getIntVolatile(o, offset);
            //如果这个方法的返回值为false，那么继续自旋
            //如果这个方法的返回值为true，那么自旋结束
            //o 表示的就是内存值
            //v 旧值
            //v + delta 修改后的值
        } while (!weakCompareAndSetInt(o, offset, v, v + delta));
            //作用：比较内存中的值，旧值是否相等，如果相等就把修改后的值写到内存中，返回true。表示修改成功。
            //                                 如果不相等，无法把修改后的值写到内存中，返回false。表示修改失败。
            //如果修改失败，那么继续自旋。
        return v;
}

1.5 悲观锁和乐观锁

synchronized和CAS的区别 :

相同点：在多线程情况下，都可以保证共享数据的安全性。

不同点：

synchronized总是从最坏的角度出发，认为每次获取数据的时候，别人都有可能修改。所以在每次操作共享数据之前，都会上锁。（悲观锁）

cas是从乐观的角度出发，假设每次获取数据时，别人都不会修改，所以不会上锁。只不过在修改共享数据的时候，会检查一下，别人有没有修改过这个数据。

如果别人修改过，那么我再次获取现在最新的值。

如果别人没有修改过，那么我现在直接修改共享数据的值.(乐观锁）

3. 并发工具类

3.1 Hashtable

在集合类中HashMap是比较常用的集合对象，但是HashMap是线程不安全的(多线程环境下可能会存在问题)。为了保证数据的安全性我们可以使用Hashtable，但是Hashtable的效率低下。

public class MyHashMapDemo {
    public static void main(String[] args) throws InterruptedException {
        HashMap<String, String> hm = new HashMap<>();
​
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 25; i++) {
                hm.put(i + "", i + "");
            }
        });
​
​
        Thread t2 = new Thread(() -> {
            for (int i = 25; i < 51; i++) {
                hm.put(i + "", i + "");
            }
        });
​
        t1.start();
        t2.start();
​
        System.out.println("----------------------------");
​
        //为了t1和t2能把数据全部添加完毕
        Thread.sleep(1000);
​
        //0-0 1-1 ..... 50- 50
​
        for (int i = 0; i < 51; i++) {
            System.out.println(hm.get(i + ""));
        }//0 1 2 3 .... 50
    }
}
​
public class MyHashtableDemo {
    public static void main(String[] args) throws InterruptedException {
        Hashtable<String, String> hm = new Hashtable<>();
​
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 25; i++) {
                hm.put(i + "", i + "");
            }
        });
​
​
        Thread t2 = new Thread(() -> {
            for (int i = 25; i < 51; i++) {
                hm.put(i + "", i + "");
            }
        });
​
        t1.start();
        t2.start();
​
        System.out.println("----------------------------");
        //为了t1和t2能把数据全部添加完毕
        Thread.sleep(1000);
​
        //0-0 1-1 ..... 50- 50
​
        for (int i = 0; i < 51; i++) {
            System.out.println(hm.get(i + ""));
        }//0 1 2 3 .... 50
​
    }
}

3.2 ConcurrentHashMap基本使用

在集合类中HashMap是比较常用的集合对象，但是HashMap是线程不安全的(多线程环境下可能会存在问题)。为了保证数据的安全性我们可以使用Hashtable，但是Hashtable的效率低下。

基于以上两个原因我们可以使用JDK1.5以后所提供的ConcurrentHashMap。

体系结构 :

总结 :

1 ，HashMap是线程不安全的。多线程环境下会有数据安全问题

2 ，Hashtable是线程安全的，但是会将整张表锁起来，效率低下

3，ConcurrentHashMap是线程安全的，效率较高。 在JDK7和JDK8中，底层原理不一样。

代码实现 :

package com.itheima.mymap;
​
import java.util.Hashtable;
import java.util.concurrent.ConcurrentHashMap;
​
public class MyConcurrentHashMapDemo {
    public static void main(String[] args) throws InterruptedException {
        ConcurrentHashMap<String, String> hm = new ConcurrentHashMap<>(100);
​
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 25; i++) {
                hm.put(i + "", i + "");
            }
        });
​
​
        Thread t2 = new Thread(() -> {
            for (int i = 25; i < 51; i++) {
                hm.put(i + "", i + "");
            }
        });
​
        t1.start();
        t2.start();
​
        System.out.println("----------------------------");
        //为了t1和t2能把数据全部添加完毕
        Thread.sleep(1000);
​
        //0-0 1-1 ..... 50- 50
​
        for (int i = 0; i < 51; i++) {
            System.out.println(hm.get(i + ""));
        }//0 1 2 3 .... 50
    }
}

3.3 ConcurrentHashMap1.7原理

3.4 ConcurrentHashMap1.8原理

总结 :

1，如果使用空参构造创建ConcurrentHashMap对象，则什么事情都不做。 在第一次添加元素的时候创建哈希表

2，计算当前元素应存入的索引。

3，如果该索引位置为null，则利用cas算法，将本结点添加到数组中。

4，如果该索引位置不为null，则利用volatile关键字获得当前位置最新的结点地址，挂在他下面，变成链表。

5，当链表的长度大于等于8时，自动转换成红黑树，以链表或者红黑树头结点为锁对象，配合悲观锁保证多线程操作集合时数据的安全性

3.5 CountDownLatch

CountDownLatch类 :

方法解释
public CountDownLatch(int count)参数传递线程数，表示等待线程数量
public void await()让线程等待
public void countDown()当前线程执行完毕

使用场景： 让某一个线程等待其他线程执行完毕之后再执行

代码实现 :

public class ChileThread1 extends Thread {
​
    private CountDownLatch countDownLatch;
    public ChileThread1(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }
​
    @Override
    public void run() {
        //1.吃饺子
        for (int i = 1; i <= 10; i++) {
            System.out.println(getName() + "在吃第" + i + "个饺子");
        }
        //2.吃完说一声
        //每一次countDown方法的时候，就让计数器-1
        countDownLatch.countDown();
    }
}
​
public class ChileThread2 extends Thread {
​
    private CountDownLatch countDownLatch;
    public ChileThread2(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }
    @Override
    public void run() {
        //1.吃饺子
        for (int i = 1; i <= 15; i++) {
            System.out.println(getName() + "在吃第" + i + "个饺子");
        }
        //2.吃完说一声
        //每一次countDown方法的时候，就让计数器-1
        countDownLatch.countDown();
    }
}
​
public class ChileThread3 extends Thread {
​
    private CountDownLatch countDownLatch;
    public ChileThread3(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }
    @Override
    public void run() {
        //1.吃饺子
        for (int i = 1; i <= 20; i++) {
            System.out.println(getName() + "在吃第" + i + "个饺子");
        }
        //2.吃完说一声
        //每一次countDown方法的时候，就让计数器-1
        countDownLatch.countDown();
    }
}
​
public class MotherThread extends Thread {
    private CountDownLatch countDownLatch;
    public MotherThread(CountDownLatch countDownLatch) {
        this.countDownLatch = countDownLatch;
    }
​
    @Override
    public void run() {
        //1.等待
        try {
            //当计数器变成0的时候，会自动唤醒这里等待的线程。
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //2.收拾碗筷
        System.out.println("妈妈在收拾碗筷");
    }
}
​
public class MyCountDownLatchDemo {
    public static void main(String[] args) {
        //1.创建CountDownLatch的对象，需要传递给四个线程。
        //在底层就定义了一个计数器，此时计数器的值就是3
        CountDownLatch countDownLatch = new CountDownLatch(3);
        //2.创建四个线程对象并开启他们。
        MotherThread motherThread = new MotherThread(countDownLatch);
        motherThread.start();
​
        ChileThread1 t1 = new ChileThread1(countDownLatch);
        t1.setName("小明");
​
        ChileThread2 t2 = new ChileThread2(countDownLatch);
        t2.setName("小红");
​
        ChileThread3 t3 = new ChileThread3(countDownLatch);
        t3.setName("小刚");
​
        t1.start();
        t2.start();
        t3.start();
    }
}

总结 :

1. CountDownLatch(int count)：count参数表示等待线程的数量,并定义为一个计数器。

2. await()：让线程等待，当计数器为0时，会唤醒等待的线程

3. countDown()： 线程执行完毕时调用，会将计数器-1。

3.6 Semaphore

使用场景 :

可以控制访问特定资源的线程数量。

实现步骤 :

1，需要有人管理这个通道

2，当有车进来了，发通行许可证

3，当车出去了，收回通行许可证

4，如果通行许可证发完了，那么其他车辆只能等着

代码实现 :

package com.itheima.mysemaphore;
​
import java.util.concurrent.Semaphore;
​
public class MyRunnable implements Runnable {
    //1.获得管理员对象，
    private Semaphore semaphore = new Semaphore(2);
    @Override
    public void run() {
        //2.获得通行证
        try {
            semaphore.acquire();
            //3.开始行驶
            System.out.println("获得了通行证开始行驶");
            Thread.sleep(2000);
            System.out.println("归还通行证");
            //4.归还通行证
            semaphore.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
​
package com.itheima.mysemaphore;
​
public class MySemaphoreDemo {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();
​
        for (int i = 0; i < 100; i++) {
            new Thread(mr).start();
        }
    }
}

海海向前冲
关注
  • 9
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
java多线程开发的可见性问题
天外水火的专栏
08-06 797
java多线程开发可见性问题在于多线程之间使用共享的变量，如果其他线程也在修改变量，因为执行顺序问题，在当前线程中不一定会得到真实的值，比如下面的代码，看看是否达到了可以修改共享变量，并且在线程中成功应用。 package test.commontest; public class TestThread { //共享变量flag public static Boolean ...
Java多线程之内存可见性
热门推荐
Yuwen's Hero
11-03 1万+
1、什么是JAVA 内存模型 Java Memory Model (JAVA 内存模型）描述线程之间如何通过内存(memory)来进行交互。 具体说来， JVM中存在一个主存区（Main Memory或Java Heap Memory），对于所有线程进行共享，而每个线程又有自己的工作内存（Working Memory），工作内存中保存的是主存中某些变量的拷贝，线程对所有变量的操作并非发生在主存区
java多线程可见性
咏樟的博客
07-30 485
java多线程可见性1、可见性介绍1.1、可见性1.2、java内存模型JMM1.3、两条规定1.4、共享变量可见性实现的原理2、synchronized实现可见性2.1、JMM关于synchronized的两条规定2.2、线程执行互斥代码的过程2.3、了解重排序和as-if-serial2.4、可见性分析3、volatile实现可见性4、synchronized和volatile比较 1、可见性介绍 1.1、可见性 1.2、java内存模型JMM **java内存模型（ Java Memory Mode
java多线程进阶（三）可见性
jiayibingdong的博客
05-09 1444
执行程序，会发现程序无法自动结束，因为修改的stop值无法被线程thread感知到，这就是不同线程共享变量的可见性问题。
多线程中的可见性
qq_44113347的博客
07-01 234
JMM 这样的规定可能会导致 在线程修改了本地内存中的共享变量的副本之后，并没有及时的更新到主内存，或者线程没能即时将共享变量的最新值同步到本地内存中，从而使得线程在使用共享变量时的值不是最新值。JMM 定义了线程和主内存之间的抽象关系：线程之间的共享变量存储在主内存中，每个线程都有一个私有的本地内存，本地内存中存储了该线程以读/写共享变量的副本。JMM模型描述的是共享变量存储在主内存中，而每个线程都有一个自己的本地内存，在这个里面存储了共享变量的副本。我们怎么保证多线程的情况下保证共享变量的可见性呢？
Java多线程 - 可见性和有序性原理
你今天真好看呀
03-02 861
文章目录1. 缓存一致性协议解决可见性问题1. CPU物理缓存结构2. 内存的可见性问题3. 总线锁和缓存锁2. 内存屏障解决可见性和有序性问题3. volatile的底层原理 问题：violatile 关键字的作用？ 1. 缓存一致性协议解决可见性问题 1. CPU物理缓存结构 由于CPU的运算速度比主存的存取速度快很多，为了提高处理速度，现代CPU不直接和主存进行通信，而是在CPU和主存之间设计了多层的Cache（高速缓存），越靠近CPU的高速缓存越快，容量也越小。 按照数据读取顺序和与CPU内核结合的
java多线程安全性基础介绍.pptx
07-25
java多线程安全性基础介绍 线程安全 正确性 什么是线程安全性 原子性 竞态条件 i++ 读i ++ 值写回i 可见性 JMM 由于cpu和内存加载速度的差距，在两者之间增加了多级缓存导致，内存并不能直接对cpu可见。 ...
【2018最新最详细】并发多线程教程
11-15
【2018最新最详细】并发多线程教程，课程结构如下 ...25.大白话说java并发工具类-CountDownLatch，CyclicBarrier 26.大白话说java并发工具类-Semaphore，Exchanger 27.一篇文章，让你彻底弄懂生产者--消费者问题
【JAVA】多线程之内存可见性
阳阳的博客
08-29 9436
多线程之内存可见性 一、什么是可见性？ 一个线程对共享变量值的修改，能够及时地被其他线程所看到。 共享变量：如果一个变量在多个线程的工作内存中都存在副本，那么这个变量就是这几个线程的共享变量。 工作内存：每个线程拥有自己的工作内存，只能对自己工作内存中的变量副本进行修改，而不能直接修改主内存中的变量。 变量副本：主内...
Java多线程 可见性问题出现的原因
Java持续实践
09-05 800
文章目录可见性问题出现的原因 可见性问题出现的原因 主要的原因可以从下图中分析出来. 此图中, 最下层为ram, 也就是内存, 而内存离CPU之间 ,是有多级的缓存的. L3 cache为内存的一部分, 会把内存中高频用到的部分缓存起来. L2 cache为L3 cache的一部分, 会把L3 cache高频用到的部分缓存起来. L1 cache为L2 cache的一部分, 会把L2 cache高频用到的部分缓存起来. 每一层缓存的大小在缩小, 但读取速度在不断的增加. 到了Register 是寄存器,
java多线程——线程之间的可见性
guduyishuai的博客
09-19 2507
目录 一、简介 二、volatile 三、synchronized 四、不会从主内存拉取的操作 五、从主内存中拉取的操作 一、简介        我们知道线程在工作的时候有自己的私有内存，工作内存。程序运行的时候从主内存拉取需要的变量到工作内存，处理完再返回主内存。这篇文章总结哪些代码会使线程去主内存拉取变量。 二、volatile        volatile修饰的变量，不论...
并发编程——原子性，可见性和有序性
eff666的博客
03-26 1万+
在并发编程中，我们通常会遇到以下三个问题：原子性问题，可见性问题，有序性问题。1、原子性即一个操作或者多个操作，要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。原子性就像数据库里面的事务一样，他们是一个团队，同生共死。一个很经典的例子就是银行账户转账问题：比如从账户A向账户B转1000元，那么必然包括2个操作：从账户A减去1000元，往账户B加上1000元。试想一下，如果这2个操作不具
浅谈Java多线程之内存可见性
aodubi0638的博客
10-31 333
目录 学习目标： 可见性介绍： synchronized实现可见性原理： synchronized实现可见性代码： volatile实现可见性： volatile不能保证原子性： 再谈谈CPU： CPU的Cache模型： CPU缓存一致性问题： 关于内存屏障： 学习目标： 可见性介绍： synchr...
Java多线程可见性（一）
沐沐的博客
12-05 1075
一：内存可见性 线程对共享变量的修改，可以及时的被其他线程看到。 那何为共享变量呢？就是在多个线程的工作内存中存在 如下图所示：所谓的共享变量就是主内存中名为S的变量，程序中所有的变量都会存储在主内存中；其他线程也会有自己的工作内存，此工作内存的作用是为线程与主内存之间建立桥梁 由此图总结如下： 1：其他线程不可以直接访问主内存中的变量，必须先与自己的工作内存进行交互再由工作内存与主内
java多线程之可见性
zhengholien的java净土
09-05 1872
可见性：一个线程对共享变量值的修改能够及时地被其他线程看到 JMM（java memory model）描述了java程序中各种变量的访问规则，以及在JVM中将变量（线程共享变量）存储到内存和从内存中取出变量这样的底层细节。JMM是一种规范，这也是导致java多线程会出现可见性问题的原因，所以了解一下java内存模型还是很有必要的。 所有变量都存储在主内存中（分配给进程的内存）
java线程内存可见性_Java多线程之内存可见性
weixin_34122532的博客
02-24 100
阅读本文约“3分钟”共享变量在线程间的可见性synchronized实现可见性volatile实现可见性—指令重排序—as-if-serial语义—volatile使用注意事项synchronized和volatile比较可见性：一个线程对共享变量值的修改，能够及时地被其他线程看到共享变量：如果一个变量在多个线程的工作内存中都存在副本，那么这个变量就是这几个线程的共享变量Java内存模型(JMM)...
java线程可见性
epitomizelu的专栏
07-03 562
一，为什么有线程可见性的问题 先看看下面这段简单的代码： public class VolatileTest { public static void main(String[] args) { MyThread myThread = new MyThread(); myThread.start(); while (true) { if (myThread.flag) { System
java解决多线程安全问题
最新发布
08-25
### 回答1： Java中可以使用synchronized关键字来解决多线程安全问题。synchronized可以用在方法上或者代码块上，表示当前线程独占这段代码，其他线程在这段代码执行期间不能访问。另外Java还提供了ReentrantLock类来实现同步，这个类比synchronized更灵活，支持更多的功能。 ### 回答2： Java中提供了多种方式来解决多线程安全问题。 1. 使用synchronized关键字：通过在关键代码块或者方法前加上synchronized关键字，确保同一时间只有一个线程可以执行该代码块或者方法。这样可以有效地解决竞态条件和数据不一致的问题。 2. 使用ReentrantLock类：ReentrantLock是一种可重入的互斥锁，通过使用lock()和unlock()方法来实现线程间的互斥访问。与synchronized关键字相比，ReentrantLock类提供了更大的灵活性，例如可中断的锁、超时获取锁等。 3. 使用volatile关键字：当多个线程访问共享变量时，通过使用volatile关键字可以保证变量的可见性，即一个线程对变量的修改对其他线程是可见的。但是volatile关键字无法保证变量的操作的原子性。 4. 使用Atomic类：Java提供了一系列的原子类，例如AtomicInteger、AtomicLong等，这些原子类提供了比volatile关键字更强的原子性保证。通过使用这些原子类，可以避免使用synchronized关键字，提高多线程程序的性能。 5. 使用线程安全的数据结构：Java提供了一些线程安全的数据结构，例如ConcurrentHashMap、ConcurrentLinkedQueue等，对于多线程并发访问的场景，可以使用这些线程安全的数据结构来保证数据的一致性和线程安全性。 综上所述，Java提供了多种方式来解决多线程安全问题，开发者可以根据具体的需求和场景来选择合适的方式。 ### 回答3： Java提供了多种机制来解决多线程安全问题。 1. 同步方法：在方法声明前加上synchronized关键字，可以确保在同一时间只有一个线程可以进入方法。这样可以保证共享资源的状态一致性。 2. 同步代码块：使用synchronized关键字来标记代码块，只有获取到锁的线程才能执行该代码块中的代码。这样可以对特定的代码块进行同步控制，避免多线程同时对共享资源进行访问。 3. volatile关键字：使用volatile关键字修饰的变量，会保证对它的读写操作都是原子性的。对volatile变量的写操作会立即刷新到主内存，对volatile变量的读操作会从主内存中获取最新的值，避免了线程之间的可见性问题。 4. 使用锁：Java提供了多种锁机制，如ReentrantLock、ReadWriteLock等，它们可以用来实现更细粒度的同步控制。使用锁可以提供更高级的功能，如可重入、可中断、公平/非公平、读写分离等。 5. 使用并发容器：Java提供了一些并发安全的容器，如ConcurrentHashMap、ConcurrentLinkedQueue等，这些容器内部实现了线程安全的同步机制，可以在多线程环境下安全地访问和修改容器内的数据。 总的来说，Java通过synchronized关键字、volatile关键字、锁和并发容器等机制，提供了丰富的工具来解决多线程安全问题。开发人员可以根据具体需求选择适合的机制来保证多线程环境下的数据一致性和线程安全性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

海海向前冲

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值