精华内容
下载资源
问答
  • 一、Redis 事务的实现原理 一个事务从开始到结束通常会经历以下三个阶段: 1、事务开始 客户端发送 MULTI 命令,服务器执行 MULTI 命令逻辑。 服务器会在客户端状态(redisClient)的 flags 属性打开 REDIS_MULTI ...
  • 同步是最常用的原子性违规修复方法,但通常容易出错。 除了引入死锁之外,程序员还很容易不充分地同步代码。 由于行业中几乎所有的修复检查仍然依赖于昂贵的劳动力,而且并发程序的不确定性是出了名的,因此很难找到...
  • 主要介绍了java 并发中的原子性与可视性实例详解的相关资料,原子性是说一个操作是否可分割。可见性是说操作结果其他线程是否可见。需要的朋友可以参考下
  • 主要介绍了MySQL8.0 DDL原子性特性及实现原理,本文给大家介绍的非常详细,具有一定的参考借鉴价值 ,需要的朋友可以参考下
  • AtomicReact是一个使用原子性概念构建Web应用程序的框架 产品特点 快速入门:安装并运行 强大的生态系统: 构建管理自己状态的封装Atom,然后将它们组合成复杂的UI。 其他开发人员易于使用的Atom 原子是由结构,...
  • 在 Java并发12:并发三特性-原子性、可见性和有序性概述及问题示例中,对并发中的三个特性(原子性、可见性和有序性)进行了初步学习。 本章主要就Java中保障原子性的技术进行更加全面的学习。 1.整体回顾 原子性...

    [超级链接:Java并发学习系列-绪论]

    在Java并发编程中,如果要保证代码的安全性,则必须保证代码的原子性、可见性和有序性。

    Java并发12:并发三特性-原子性、可见性和有序性概述及问题示例中,对并发中的三个特性(原子性、可见性和有序性)进行了初步学习。

    本章主要就Java中保障原子性的技术进行更加全面的学习。

    1.整体回顾

    • 原子性定义:一个或多个操作,要么全部执行且在执行过程中不被任何因素打断,要么全部不执行。
    • Java自带原子性:对基本数据类型的变量读取赋值操作是原子性操作。

    2.原子性问题

    由上面的章节已知,不采取任何的原子性保障措施的自增操作并不是原子性的。
    下面的代码实现了一个自增器(不是原子性的)。

    /**
     * <p>原子性示例:不是原子性</p>
     *
     * @author hanchao 2018/3/10 14:58
     **/
    static class Increment {
        private int count = 1;
    
        public void increment() {
            count++;
        }
    
        public int getCount() {
            return count;
        }
    }

    下面的代码展示了在多线程环境中,调用此自增器进行自增操作。

    int type = 0;//类型
    int num = 50000;//自增次数
    int sleepTime = 5000;//等待计算时间
    int begin;//开始的值
    Increment increment;
    //不进行原子性保护的大范围操作
    increment = new Increment();
    begin = increment.getCount();
    LOGGER.info("Java中普通的自增操作不是原子性操作。");
    LOGGER.info("当前运行类:" +increment.getClass().getSimpleName() +  ",count的初始值是:" + increment.getCount());
    for (int i = 0; i < num; i++) {
        new Thread(() -> {
            increment.increment();
        }).start();
    }
    //等待足够长的时间,以便所有的线程都能够运行完
    Thread.sleep(sleepTime);
    LOGGER.info("进过" + num + "次自增,count应该 = " + (begin + num) + ",实际count = " + increment.getCount());

    某次运行结果:

    2018-03-17 22:52:23 INFO  ConcurrentAtomicityDemo:132 - Java中普通的自增操作不是原子性操作。
    2018-03-17 22:52:23 INFO  ConcurrentAtomicityDemo:133 - 当前运行类:Increment,count的初始值是:1
    2018-03-17 22:52:33 INFO  ConcurrentAtomicityDemo:141 - 进过50000次自增,count应该 = 50001,实际count = 49999

    通过观察结果,发现程序确实存在原子性问题。

    3.原子性技术保障

    在Java中提供了多种原子性保障措施,这里主要涉及三种:

    • 通过synchronized关键字定义同步代码块或者同步方法保障原子性。
    • 通过Lock接口保障原子性。
    • 通过Atomic类型保障原子性。

    3.1.synchronized关键字

    Increment类进行扩展:

    /**
     * <p>原子性示例:通过synchronized保证代码块的原子性</p>
     *
     * @author hanchao 2018/3/10 15:07
     **/
    static class SynchronizedIncrement extends Increment {
        /**
         * <p>添加关键字synchronized,使之成为同步方法</p>
         *
         * @author hanchao 2018/3/10 15:12
         **/
        @Override
        public synchronized void increment() {
            super.count++;
        }
    }

    在多线程环境中进行SynchronizedIncrement 的自增:

    //synchronized关键字能够保证原子性(代码块锁,多线程操作某一对象时,在某个代码块内只能单线程执行)
    increment = new SynchronizedIncrement();
    begin = increment.getCount();
    LOGGER.info("可以通过synchronized关键字保障代码的原子性");
    LOGGER.info("当前运行类:" +increment.getClass().getSimpleName() +  ",count的初始值是:" + increment.getCount());
    for (int i = 0; i < num; i++) {
        new Thread(() -> {
            increment.increment();
        }).start();
    }
    //等待足够长的时间,以便所有的线程都能够运行完
    Thread.sleep(sleepTime);
    LOGGER.info("进过" + num + "次自增,count应该 = " + (begin + num) + ",实际count = " + increment.getCount());

    运行结果(多次):

    2018-03-18 00:41:30 INFO  ConcurrentAtomicityDemo:147 - 可以通过synchronized关键字保障代码的原子性
    2018-03-18 00:41:30 INFO  ConcurrentAtomicityDemo:148 - 当前运行类:SynchronizedIncrement,count的初始值是:1
    2018-03-18 00:41:40 INFO  ConcurrentAtomicityDemo:156 - 进过50000次自增,count应该 = 50001,实际count = 50001

    通过多次运行,发现运行结果一致,所以可以确定synchronized关键字能够保证代码的原子性

    3.2.Lock接口

    Increment类进行扩展:

    /**
    * <p>原子性示例:通过Lock接口保证指定范围代码的原子性</p>
    *
    * @author hanchao 2018/3/10 15:14
    **/
    static class LockIncrement extends Increment {
       //定义个读写锁:锁内运行多线程读,单线程写
       private static final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock(true);
    
       /**
        * <p>运用读写所重写方法</p>
        *
        * @author hanchao 2018/3/10 15:13
        **/
       @Override
       public void increment() {
           //写锁 加锁
           readWriteLock.writeLock().lock();
           try {
               //开始写
               super.count++;
           } finally {
               //将解锁放在finally块中,保证必然执行,防止死锁
               readWriteLock.writeLock().unlock();
           }
       }
    }

    在多线程环境中进行LockIncrement的测试:

    //通过Lock接口保证原子性操作
    increment = new LockIncrement();
    begin = increment.getCount();
    LOGGER.info("可以通过Lock接口保证代码的原子性");
    LOGGER.info("当前运行类:" +increment.getClass().getSimpleName() +  ",count的初始值是:" + increment.getCount());
    for (int i = 0; i < num; i++) {
        new Thread(() -> {
            increment.increment();
        }).start();
    }
    //等待足够长的时间,以便所有的线程都能够运行完
    Thread.sleep(sleepTime);
    LOGGER.info("进过" + num + "次自增,count应该 = " + (begin + num) + ",实际count = " + increment.getCount());

    运行结果(多次):

    2018-03-18 10:12:12 INFO  ConcurrentAtomicityDemo:163 - 可以通过Lock接口保证代码的原子性
    2018-03-18 10:12:12 INFO  ConcurrentAtomicityDemo:164 - 当前运行类:LockIncrement,count的初始值是:1
    2018-03-18 10:12:29 INFO  ConcurrentAtomicityDemo:172 - 进过50000次自增,count应该 = 50001,实际count = 50001

    通过多次运行,发现运行结果一致,所以可以确定Lock接口能够保证代码的原子性

    3.3.Atomic类型

    Increment类进行扩展:

    /**
    * <p>原子性示例:通过Atomic类型保证类型的原子性</p>
    *
    * @author hanchao 2018/3/10 15:19
    **/
    static class AtomicIncrement {
       private AtomicInteger count = new AtomicInteger(1);
    
       /**
        * <p>无需其他处理,直接自增即可</p>
        *
        * @author hanchao 2018/3/10 15:21
        **/
       public void increment() {
           count.getAndIncrement();
       }
    
       public AtomicInteger getCount() {
           return count;
       }
    }

    在多线程环境中进行AtomicIncrement的测试:

    //通过Atomic变量保证变量操作的原子性
    AtomicIncrement increment1 = new AtomicIncrement();
    begin = increment1.getCount().get();
    LOGGER.info("可以通过Atomic类型保证变量的原子性");
    LOGGER.info("当前运行类:" +increment1.getClass().getSimpleName() +  ",count的初始值是:" + increment1.getCount());
    for (int i = 0; i < num; i++) {
        new Thread(() -> {
            increment1.increment();
        }).start();
    }
    //等待足够长的时间,以便所有的线程都能够运行完
    Thread.sleep(sleepTime);
    LOGGER.info("进过" + num + "次自增,count应该 = " + (begin + num) + ",实际count = " + increment1.getCount());

    运行结果(多次):

    2018-03-18 10:14:37 INFO  ConcurrentAtomicityDemo:178 - 可以通过Atomic类型保证变量的原子性
    2018-03-18 10:14:37 INFO  ConcurrentAtomicityDemo:179 - 当前运行类:AtomicIncrement,count的初始值是:1
    2018-03-18 10:14:48 INFO  ConcurrentAtomicityDemo:187 - 进过50000次自增,count应该 = 50001,实际count = 50001

    通过多次运行,发现运行结果一致,所以可以确定Atomic类型能够保证代码的原子性

    4.总结

    经验证,以下三种措施,可以保证Java代码在运行时的原子性:

    • synchronized关键字
    • Lock接口
    • Atomic类型

    并发三特性总结

    特性volatile关键字synchronized关键字Lock接口Atomic变量
    原子性无法保障可以保障可以保障可以保障
    可见性可以保障可以保障可以保障可以保障
    有序性一定程度保障可以保障可以保障无法保障
    展开全文
  • 在并发编程中有三个非常重要的特性:原子性、有序性,、可见性,学妹发现你对它们不是很了解,她很着急,因为理解这三个特性对于能够正确地开发高并发程序有很大的帮助,接下来的面试中也极有可能被问到,小学妹就忍...

    在并发编程中有三个非常重要的特性:原子性、有序性,、可见性,学妹发现你对它们不是很了解,她很着急,因为理解这三个特性对于能够正确地开发高并发程序有很大的帮助,接下来的面试中也极有可能被问到,小学妹就忍不住开始跟你逐一介绍起来。

    Java内存模型

    在讲三大特性之前先简单介绍一下Java内存模型(Java Memory Model,简称JMM),了解了Java内存模型以后,可以更好地理解三大特性。

    Java内存模型是一种抽象的概念,并不是真实存在的,它描述的是一组规范或者规定。JVM运行程序的实体是线程,每一个线程都有自己私有的工作内存。Java内存模型中规定了所有变量都存储在主内存中,主内存是一块共享内存区域,所有线程都可以访问。但是线程对变量的读取赋值等操作必须在自己的工作内存中进行,在操作之前先把变量从主内存中复制到自己的工作内存中,然后对变量进行操作,操作完成后再把变量写回主内存。线程不能直接操作主内存中的变量,线程的工作内存中存放的是主内存中变量的副本。

    原子性(Atomicity)

    什么是原子性

    原子性是指:在一次或者多次操作时,要么所有操作都被执行,要么所有操作都不执行。

    一般说到原子性都会以银行转账作为例子,比如张三向李四转账100块钱,这包含了两个原子操作:在张三的账户上减少100块钱;在李四的账户上增加100块钱。这两个操作必须保证原子性的要求,要么都执行成功,要么都执行失败。不能出现张三的账户减少100块钱而李四的账户没增加100块钱,也不能出现张三的账户没减少100块钱而李四的账户却增加100块钱。

    原子性示例

    示例一
    i = 1;
    

    根据上面介绍的Java内存模型,线程先把i=1写入工作内存中,然后再把它写入主内存,就此赋值语句可以说是具有原子性。

    示例二
    i = j;
    

    这个赋值操作实际上包含两个步骤:线程从主内存中读取j的值,然后把它存入当前线程的工作内存中;线程把工作内存中的i改为j的值,然后把i的值写入主内存中。虽然这两个步骤都是原子性的操作,但是合在一起就不是原子性的操作。

    示例三
    i++;
    

    这个自增操作实际上包含三个步骤:线程从主内存中读取i的值,然后把它存入当前线程的工作内存中;线程把工作内存中的i执行加1操作;线程再把i的值写入主内存中。和上一个示例一样,虽然这三个步骤都是原子性的操作,但是合在一起就不是原子性的操作。

    从上面三个示例中,我们可以发现:简单的读取和赋值操作是原子性的,但把一个变量赋值给另一个变量就不是原子性的了;多个原子性的操作放在一起也不是原子性的。

    如何保证原子性

    在Java内存模型中,只保证了基本读取和赋值的原子性操作。如果想保证多个操作的原子性,需要使用synchronized关键字或者Lock相关的工具类。如果想要使int、long等类型的自增操作具有原子性,可以用java.util.concurrent.atomic包下的工具类,如:AtomicIntegerAtomicLong等。另外需要注意的是,volatile关键字不具有保证原子性的语义。

    可见性(Visibility)

    什么是可见性

    可见性是指:当一个线程对共享变量进行修改后,另外一个线程可以立即看到该变量修改后的最新值。

    可见性示例

    package onemore.study;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    public class VisibilityTest {
        public static int count = 0;
    
        public static void main(String[] args) {
            final SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss.SSS");
    
            //读取count值的线程
            new Thread(() -> {
                System.out.println("开始读取count...");
                int i = count;//存放count的更新前的值
                while (count < 3) {
                    if (count != i) {//当count的值发生改变时,打印count被更新
                        System.out.println(sdf.format(new Date()) + " count被更新为" + count);
                        i = count;//存放count的更新前的值
                    }
                }
            }).start();
    
            //更新count值的线程
            new Thread(() -> {
                for (int i = 1; i <= 3; i++) {
                    //每隔1秒为count赋值一次新的值
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(sdf.format(new Date()) + " 赋值count为" + i);
                    count = i;
    
                }
            }).start();
        }
    }
    

    在运行代码之前,先想一下运行的输出是什么样子的?在更新count值的线程中,每一次更新count以后,在读取count值的线程中都会有一次输出嘛?让我们来看一下运行输出是什么:

    开始读取count...
    17:21:54.796 赋值count为1
    17:21:55.798 赋值count为2
    17:21:56.799 赋值count为3
    

    从运行的输出看出,读取count值的线程一直没有读取到count的最新值,这是为什么呢?因为在读取count值的线程中,第一次读取count值时,从主内存中读取count的值后写入到自己的工作内存中,再从工作内存中读取,之后的读取的count值都是从自己的工作内存中读取,并没有发现更新count值的线程对count值的修改。

    如何保证可见性

    在Java中可以用以下3种方式保证可见性。

    使用volatile关键字

    当一个变量被volatile关键字修饰时,其他线程对该变量进行了修改后,会导致当前线程在工作内存中的变量副本失效,必须从主内存中再次获取,当前线程修改工作内存中的变量后,同时也会立刻将其修改刷新到主内存中。

    使用synchronized关键字

    synchronized关键字能够保证同一时刻只有一个线程获得锁,然后执行同步方法或者代码块,并且确保在锁释放之前,会把变量的修改刷新到主内存中。

    使用Lock相关的工具类

    Lock相关的工具类的lock方法能够保证同一时刻只有一个线程获得锁,然后执行同步代码块,并且确保执行Lock相关的工具类的unlock方法在之前,会把变量的修改刷新到主内存中。

    有序性(Ordering)

    什么是有序性

    有序性指的是:程序执行的顺序按照代码的先后顺序执行。

    在Java中,为了提高程序的运行效率,可能在编译期和运行期会对代码指令进行一定的优化,不会百分之百的保证代码的执行顺序严格按照编写代码中的顺序执行,但也不是随意进行重排序,它会保证程序的最终运算结果是编码时所期望的。这种情况被称之为指令重排(Instruction Reordering)。

    有序性示例

    package onemore.study;
    
    public class Singleton {
        private Singleton (){}
    
        private static boolean isInit = false;
        private static Singleton instance;
    
        public static Singleton getInstance() {
            if (!isInit) {//判断是否初始化过
                instance = new Singleton();//初始化
                isInit = true;//初始化标识赋值为true
            }
            return instance;
        }
    }
    

    这是一个有问题的单例模式示例,假如在编译期或运行期时指令重排,把isInit = true;重新排序到instance = new Singleton();的前面。在单线程运行时,程序重排后的执行结果和代码顺序执行的结果是完全一样的,但是多个线程一起执行时就极有可能出现问题。比如,一个线程先判断isInit为false进行初始化,本应在初始化后再把isInit赋值为true,但是因为指令重排没后初始化就把isInit赋值为true,恰好此时另外一个线程在判断是否初始化过,isInit为true就执行返回了instance,这是一个没有初始化的instance,肯定造成不可预知的错误。

    如何保证有序性

    这里就要提到Java内存模型的一个叫做先行发生(Happens-Before)的原则了。如果两个操作的执行顺序无法从Happens-Before原则推到出来,那么可以对它们进行随意的重排序处理了。Happens-Before原则有哪些呢?

    • 程序次序原则:一段代码在单线程中执行的结果是有序的。
    • 锁定原则:一个锁处于被锁定状态,那么必须先执行unlock操作后面才能进行lock操作。
    • volatile变量原则:同时对volatile变量进行读写操作,写操作一定先于读操作。
    • 线程启动原则:Thread对象的start方法先于此线程的每一个动作。
    • 线程终结原则:线程中的所有操作都先于对此线程的终止检测。
    • 线程中断原则:对线程interrupt方法的调用先于被中断线程的代码检测到中断事件的发生。
    • 对象终结原则:一个对象的初始化完成先于它的finalize方法的开始。
    • 传递原则:操作A先于操作B,操作B先于操作C,那么操作A一定先于操作C。

    除了Happens-Before原则提供的天然有序性,我们还可以用以下几种方式保证有序性:

    • 使用volatile关键字保证有序性。
    • 使用synchronized关键字保证有序性。
    • 使用Lock相关的工具类保证有序性。

    总结

    • 原子性:在一次或者多次操作时,要么所有操作都被执行,要么所有操作都不执行。
    • 可见性:当一个线程对共享变量进行修改后,另外一个线程可以立即看到该变量修改后的最新值。
    • 有序性:程序执行的顺序按照代码的先后顺序执行。

    synchronized关键字和Lock相关的工具类可以保证原子性、可见性和有序性,volatile关键字可以保证可见性和有序性,不能保证原子性。

    文章持续更新,微信搜索「 万猫学社 」第一时间阅读。
    关注后回复「 电子书 」,免费获取12本Java必读技术书籍。

    展开全文
  • 理解什么是线程安全性、原子性

    万次阅读 2019-12-29 11:56:30
    原子性 加锁机制 •写在前面 进程想要执行任务需要依赖线程,换句话说就是进程中的最小执行单位就是线程,并且一个进程中至少有一个线程。提到多线程这里要说两个概念,就是串行和并行,搞清楚这个我们才能更好...

    目录

    •写在前面

    •原子性

    加锁机制


    •写在前面

    进程想要执行任务需要依赖线程,换句话说就是进程中的最小执行单位就是线程,并且一个进程中至少有一个线程。提到多线程这里要说两个概念,就是串行和并行,搞清楚这个我们才能更好的理解多线程。所谓串行其实是相对于单条线程来执行多个任务来说的,我们就拿下载文件来举个例子,我们下载多个文件,在串行中它是按照一定的顺序去进行下载的,也就是说必须等下载完A之后,才能开始下载B,它们在时间上是不可能发生重叠的。

    要编写线程安全的代码,其核心在于要对状态访问操作进行管理,特别是对共享的和可变的状态的访问。要是的对象是线程安全的,需要采用同步机制来协同对对象可变状态的访问,如果无法实现协同,那么可能会导致数据破坏以及其他不该出现的结果。java中的同步机制是关键字synchronized,它提供了独占式的加锁方式,不仅如此还包括volatile类型变量,显式锁Lock以及原子变量。

    单线程近似定义为“所见即所知”,那么定义线程安全性,则当多个线程访问某个类时,这个类始终都能表现出正确的行为,那么就称这个类是线程安全的。一个类在单线程中运行都不正确,那么它肯定是不会是线程安全的。如果正确的实现了某个对象,那么在任何操作中(包括调用对象的公有方法或者对其公有域进行读写操作)都不会违背不变性条件或后验条件。在线程安全类的对象实例上执行的任何串行或并行操作都不会处于无效状态。

    无状态的对象一定是安全的,啥是无状态?这个类既不包括任何域,也不包括任何对其他类中域的引用。举个例子,大多数Servlet都是无状态的,从而极大的降低了在实现Servlet线程安全性时的复杂性,只有当Servlet在处理请求时需要保存一些信息,线程安全性才会成为一个问题。

    •原子性

    其实原子性就是一个不可分割的,我们怎么理解呢?举个例子,当我们在无状态对象中增加一个状态时,会发生什么情况?比我们要计算一个类调用了多少次(这个类可以是Servlet),我们定义一个私有的Long类型的域(命名为count),在方法中没调用一次就将这个值加一(即count++),如下。

       Integer count = 0;
       public void getCount() {
           count ++;
           System.out.println(count);
       }

    由于我们没有对这个类进行任何的同步机制操作,所以这个类是非线程安全的,虽然在单线程环境中能正确运行,但在多线程情况下就会出现问题。我们注意到count++这个操作,这个操作看上去是一个操作,其实这个操作并非原子性的,因为它并不会作为一个不可分割的操作来执行,实际上count++ 包含了三个独立的操作,分为读取count的值,将值加1,然后计算结构写入count中,这是一个“读取-修改-写入”的操作序列,并且其结果依赖于之前的状态。在并发下就会出现问题,我再多线程下跑了上面那段代码,结果如下

    我们可以看到,这里出现了两个26,为什么会出现这种情况,出现这种情况显然表明我们这个方法根本就不是线程安全的,出现这种问题的原因有很多,我们说最常见的一种,就是我们A线程在进入方法后,拿到了count的值,刚把这个值读取出来还没有改变count的值的时候,结果线程B也进来的,那么导致线程A和线程B拿到的count值是一样的。

    在并发编程中,这种由于不恰当的执行时序而出现不正确的结果是一种非常重要的情况,它有一个正式的名字,叫“竞态条件”。竞态条件是啥?当某个计算的正确性取决于多个线程的交替执行时序时,那么就会发生竞态条件,最常见的竞态条件类型就是“先检查后执行”操作,即通过一个可能失效的观察结果来决定下一步的动作。比如首先观察到某个条件为真(例如文件X不存在),然后根据这个观察结果采用相应的动作(创建文件X),但事实上,在你观察到这个结果以及开始创建文件之间,观察结果可能变得无效(另一个线程在这个期间创建了文件X),从而导致各种问题(未预期的异常、数据覆盖、文件被破坏等)。

    与大多数并发错误一样,竞态条件并不总是会产生错误,还需要某种不恰当的执行时序。原子操作是对于访问同一个状态的所有操作(包括该操作本身)来说,这个操作是一个以原子方式执行的操作。而我们前面提到的类似count++的这种操作,叫做复合操作,即包含了一组必须以原子方式执行的操作以确保线程安全性。在实际情况中,应该尽可能的使用现有的线程安全对象来管理类的状态,与非线程安全的对象相比,判断线程安全对象的可能状态及其状态转换情况要更为容易,从而也更容易维护和验证线程安全性。这里值得一提的是,java中给我们弄好了很多原子操作的类型,在这个包下java.util.concurrent.atomic。

    加锁机制

    上面我们说了,我们可以对单个类进行原子性操作,这样可以保证我们程序的安全性,但是,我们想一想,如果当多个原子性的操作同时进行时,而且各个原子性操作之间都存在相互依赖的关系,这种情况下,我们怎么保证程序运行正确(线程安全)?如果还是使用原子性操作的方法,那么我们要保持状态的一致性,就需要在单个原子操作中更新所有相关的状态变量。

    说到这里,我们就不得不提一下java提供的一种内置的锁机制来支持原子性,即同步代码块(synchronized block),同步代码快包括两部分,一个作为锁的对象引用,一个作为由这个锁保护的代码块。以关键字synchronized来修饰的方法就是一种横跨整个方法体的同步代码块,其中该同步代码块的锁就是方法调用所在的对象。每个Java对象都可以用作一个实现同步的锁,这些所被称为内置锁或监视器锁。线程在进入同步代码块之前会自动获得锁,并且在退出同步代码块时自动释放锁,这里要说,获得内置锁的唯一途径就是进入由这个锁保护的同步代码块或方法。值得一提的是,内置锁相当于一种互斥锁,意味着最多只有一个线程能持有这种锁。要注意了,任何一个执行同步代码块的线程,都不能看到有其他线程正在执行由同一锁保护的同步代码块(这里涉及到可见性的问题)。synchronized直接加在方法上,虽然能很方便的解决线程安全的问题,但是也会带来性能低下的问题,所以synchronized怎么使用,也是值得学习的。

    可重入函数可以由多于一个任务并发使用,而不必担心数据错误。相反,不可重入函数不能由超过一个任务所共享,除非能确保函数的互斥(或者使用信号量,或者在代码的关键部分禁用中断)。可重入函数可以在任意时刻被中断,稍后再继续运行,不会丢失数据。可重入函数要么使用本地变量,要么在使用全局变量时保护自己的数据。

    当某个线程请求一个由其他线程持有的锁时,发出请求的线程就会被阻塞,然而,由于内置锁是可重入的,因此如果某个线程试图获得一个已经由它自己持有的锁,那么这个请求就会成功。“重入”意味着获取锁的操作的粒度是线程,而不是调用。重入的一种实现方式是,为每一个锁关联一个获取计数值和一个所有者线程,当计数值为0时,这个锁就被认为是没有被任何线程持有。当线程请求一个未被持有的锁时,JVM将记下锁的持有者,并且将获取计数值置为1,如果同一个线程再次请求获取这个锁,计数值将递增,而当线程退出同步代码块时,计数器会相应的递减,当计数值为0时,这个锁将被释放。

    到此我们就可以将多个复合操作封装到一个同步代码块中,但是这样是不够的,如果用同步代码块来协调对某个变量的访问,那么在访问这个变量的所有位置上都需要使用同步。而且,当使用锁来协调对某个变量的访问是,在访问变量的所有位置上都要使用同一个锁。而且,并不是只有在写入共享变量时才需要使用同步,对于可能被多个线程同时访问的可变状态变量,在访问它时都需要有同一个锁,这种情况下,我们成状态变量时由这个锁保护的。

    在这里值得一提的是,当使用锁时,你应该清楚代码块中实现的功能,以及在执行该代码块时是否需要很长的时间。无论是执行计算密集的操作,还是在执行某个可能阻塞的操作,如果持有锁的时间过长,那么都会带来活跃性或性能的问题。当执行时间较长的计算或者可能无法快速完成的操作时(例如网络IO或控制台IO),一定不要持有锁。

    展开全文
  • 目录什么是原子性操作什么是Volatile关键字为什么需要原子性操作Volatile能不能实现原子性操作?Volatile关键字常用的场景CUDA编程实现原子性操作的方法 什么是原子性操作 原子性操作具有不可分割性。比如 i=0 这个...

    什么是原子性操作

    原子性操作具有不可分割性。比如 i=0 这个操作是不可分割的,那么我们说这个操作时原子操作。再比如:

    i++

    这个操作实际是

    i = i + 1

    是可分割的,所以他不是一个原子操作。非原子操作都会存在线程安全问题,需要我们使用同步技术(sychronized)来让它变成一个原子操作。一个操作是原子操作,那么我们称它具有原子性。

    那么x=y;这个操作是不是原子性操作呢?答案也是否定的,该操作可以向下细分为首先读取y的数据,再赋值给x的过程。

    注意:在32位平台下,对64位数据的读取和赋值是需要通过两个操作来完成的,不能保证其原子性。

    什么是Volatile关键字

    volatile 关键字是一种类型修饰符,被它声明的类型变量表示可以被某些编译器未知的因素更改,比如:操作系统、硬件或者其它线程等。遇到这个关键字声明的变量,编译器对访问该变量的代码就不再进行优化,从而可以提供对特殊地址的稳定访问。声明时语法如下:

     int volatile vInt;
    

    为什么需要原子性操作

    计算机在执行程序时,每条指令都是在CPU中执行的,而在执行指令过程中,会涉及到数据的读取和写入。由于程序运行过程中的临时数据是存放在主存(物理内存)当中的,这时就存在一个问题,由于CPU执行速度很快,而从内存读取数据和向内存写入数据的过程跟CPU执行指令的速度比起来要慢的多,因此如果任何时候对数据的操作都要通过和内存的交互来进行,会大大降低指令执行的速度。因此在CPU里面就有了高速缓存。

    也就是,当程序在运行过程中,会将运算需要的数据从主存复制一份到CPU的高速缓存当中,那么CPU进行计算时就可以直接从它的高速缓存读取数据和向其中写入数据,当运算结束之后,再将高速缓存中的数据刷新到主存当中。

    而当要求使用 volatile 声明的变量的值的时候,系统总是重新从它所在的内存读取数据,即使它前面的指令刚刚从该处读取过数据。而且读取的数据立刻被保存。

    同样针对i++; 操作。当线程执行这个语句时,会先从主存当中读取i的值,然后复制一份到高速缓存当中,然后CPU执行指令对i进行加1操作,然后将数据写入高速缓存,最后将高速缓存中i最新的值刷新到主存当中。

    这个代码在单线程中运行是没有任何问题的,但是在多线程中运行就会有问题了。在多核CPU中,每条线程可能运行于不同的CPU中,因此每个线程运行时有自己的高速缓存(对单核CPU来说,其实也会出现这种问题,只不过是以线程调度的形式来分别执行的)。本文我们以多核CPU为例。

    当同时有2个线程执行这段代码,假如初始时i的值为0,那么我们希望两个线程执行完之后i的值变为2。在实际运行过程中可能存在下面一种情况:最初,两个线程分别读取i的值存入各自所在的CPU的高速缓存当中,然后线程1进行加1操作,然后把i的最新值1写入到内存。此时线程2的高速缓存当中i的值还是0,进行加1操作之后,i的值为1,然后线程2把i的值写入内存。

    最终结果i的值是1,而不是2。这就导致了结果的出错。通常称这种被多个线程访问的变量为共享变量。

    也就是说,如果一个变量在多个CPU中都存在缓存(主要当多线程时),那么就可能存在缓存不一致的问题。

    针对这类问题从硬件角度讲可以通过在总线加LOCK锁或者通过缓存一致性协议的方式实现。软件方面不同的语言存在着不同的操作。

    Volatile能不能实现原子性操作?

    在并发编程中,多进程的一个共享变量被volatile修饰之后,那么就具备了两层语义:

    1)保证了不同线程对这个变量进行操作时的可见性,即一个线程修改了某个变量的值,这新值对其他线程来说是立即可见的。
    2)禁止进行指令重排序。(保证指令的有序性)

    通过例子来说明第一层语义,假设线程1先执行,线程2后执行:

    //线程1
    boolean stop = false;
    while(!stop){
        doSomething();
    }
    
    //线程2
    stop = true;
    

    针对这个程序存在以下的问题:每个线程在运行过程中都有自己的工作内存,那么线程1在运行的时候,会将stop变量的值拷贝一份放在自己的工作内存当中。那么当线程2更改了stop变量的值之后,但是还没来得及写入主存当中,线程2转去做其他事情了,那么线程1由于不知道线程2对stop变量的更改,因此还会一直循环下去。

    但是用volatile修饰之后就变得不一样了:

    首先使用volatile关键字会强制将修改的值立即写入主存;

    之后使用volatile关键字的话,当线程2进行修改时,会导致线程1的工作内存中缓存变量stop的缓存行无效(反映到硬件层的话,就是CPU的L1或者L2缓存中对应的缓存行无效);

    最后由于线程1的工作内存中缓存变量stop的缓存行无效,所以线程1再次读取变量stop的值时会去主存读取。

    那么在线程2修改stop值时(当然这里包括2个操作,修改线程2工作内存中的值,然后将修改后的值写入内存),会使得线程1的工作内存中缓存变量stop的缓存行无效,然后线程1读取时,发现自己的缓存行无效,它会等待缓存行对应的主存地址被更新之后,然后去对应的主存读取最新的值。

    那么线程1读取到的就是最新的正确的值。

    但是Volatile关键字仍然不能保证原子性。

    问题在于volatile关键字能保证可见性没有错,但是上面的程序错在没能保证原子性。可见性只能保证每次读取的是最新的值,但是volatile没办法保证对变量的操作的原子性。

    在前面已经提到过,自增操作是不具备原子性的,它包括读取变量的原始值、进行加1操作、写入工作内存。那么就是说自增操作的三个子操作可能会分割开执行,就有可能导致缓存不同步的情况出现。

    Volatile关键字常用的场景

    通常volatile关键字被用于以下的几个地方:
    1、中断服务程序中修改的供其它部分程序检测的共享变量。
    2、多任务环境下各个任务的共享标志应该加volatile。
    3、存储器的硬件寄存器需要加volaile说明,因为对它的每次读写都有不同的含义。

    CUDA编程实现原子性操作的方法

    在这里简单的提供一个使用倒原子性操作的例程,并记录一些注意事项。

    统计计算一组数据并作出直方图:

    CPU版本:

    #define SIZE (100*1024*1024)
    int main(void){
        unsigned char *buffer = (unsigned char*)big_random_block(SIZE);
        unsigned int histo[256];
        for(int i=0;i<256;i++)
            histo[i]=0;
        for(itn i=0;i<SIZE;i++)
            histo[buffer[i]]++;
    

    atomicAdd(addr,y ) 将生成一个原子操作序列,这个操作序列包括读取地址 addr 处的值,将 y 增加到这个值,以及将结果保存回地址 addr. 底层硬件将保证执行这些操作时,任何其他的线程都不会读取写入 addr 上的值。

    CPU版本的kernel函数部分:

    __global__ void histo_kernel(unsigned char *buffer,long size,unsigned int *histo){
        int i = threadIdx.x + blockIdx.x*blockDim.x;
        int stride = blockDim.x * gridDim.x;
        while(x < size){
            atomicAdd(&(histo[buffer[i]]),1);
            i += stride;
        }
    }
    

    这个方法比 cpu 还要慢,因为几千个线程访问少量的内存,将发生大量的竞争,为了确保递增操作的原子性,对相同内存位置的操作都将被硬件串行化。

    使用共享内存原子操作和全局内存原子操作的直方图kernel函数

    __global__ void histo_kernel(char *buffer,long size,unsinged int *histo){
        int i= threadIdx.x +blockDim.x * blockIdx.x;
        int stride = gridDim.x * blockDim.x;
        __share__ unsigned int temp[256];
        temp[threadIdx.x]=0;
        __syncthreads();
        while(i<size){
            atomicAdd(&(temp[buffer[i]]),1);
            i += stride;
        }
        __syncthreads();
        //最后将所用共享内存上的直方图相加到一个直方图上
        atomicAdd(&(histo[threadIdx.x]),temp[threadIdx.x]);
    }
    

    虽然最初将直方图程序修改为GPU版本使性能下降,但同时使用共享内存与原子性操作仍然能使程序加速。实测程序速度提升了大概7倍左右。

    展开全文
  • 原子性、有序性和可见性解释

    千次阅读 2019-05-17 18:26:53
    原子性(Atomicity) 由 Java 内存模型来直接保证的原子性变量操作包括 read、load、assign、use、store 和 write。大致可以认为基本数据类型的操作是原子性的。同时 lock 和 unlock 可以保证更大范围操作的原子性。而...
  • Redis 事务是否具备原子性

    千次阅读 2020-04-25 18:25:20
    源码解读 Redis 事务的底层设计与实现,让 Redis 事务是否具备原子性一见分晓!
  • 线程安全性详解(原子性、可见性、有序性)

    千次阅读 多人点赞 2019-10-22 10:00:52
    一、定义:什么是线程安全性 当多个线程访问某个类时,不管运行时环境采用 何种调度方式 或者这些进程将如何交替执行,并且在主调代码中不需要任何额外的同步或...原子性:提供互斥访问,同一时刻只能有一个线程对数...
  • 2.原子性 2.1 原子性 2.2 volatile 非原子性 2.3 synchronized 原子性 3.有序性 3.1 有序性 3.2 volatile有序性 3.3 synchronized有序性 4.程序员学习方法心得 5.总结 0.简介 前一篇文章《Synchronized...
  • 互联网金融信息安全实务 第六章 事务处理 知识点原子性 目录页 原子性需求 分布式事务处理模型 1 2 原子性保证 冲正 3 4 原子性 指事务是系统的逻辑工作单位事务中包括的诸操作要么都做要么都不做将一组操作进行打包...
  • 本章主要学习Java并发中的三个特性:原子性、可见性和有序性。 在Java并发编程中,如果要保证代码的安全性,则必须保证代码的原子性、可见性和有序性。 本章的很多概念可以参考:Java并发11:Java内存模型、指令...
  • 前言 我在上一篇文章简单的介绍了一些synchronized关键字的知识点和用法(有兴趣的可以点这里,传送门biubiu),而这篇文章主要介绍synchronized底层实现,还有它是如何保证原子性、有序性和可见性的。 在进入正题...
  • 并发程序正确地执行,必须要保证原子性、可见性以及有序性。只要有一个没有被保证,就有可能会导致程序运行不正确。 原子性:一个操作或多个操作要么全部执行完成且执行过程不被中断,要么就不执行。 可见性:当多...
  • 在并发编程中分析线程安全的问题时往往需要切入点,那就是两大核心:JMM抽象内存模型以及happens-before规则(在这篇文章中已经经过了),三条性质:原子性,有序性和可见性。关于synchronized和volatile已经讨论过...
  • 解析AtomicInteger为什么能保证原子性

    千次阅读 2019-10-26 21:59:39
    文章浅谈volatile的最后留下了疑问,为什么AtomicInteger能保证原子性,AtomicInteger是如何做到保证原子性的,本篇文章就是来答疑解惑的。 AtomicInteger源码分析 private static final Unsafe unsafe = Unsafe....
  • Java的原子性&&可见性&&有序性

    万次阅读 2017-06-21 10:16:53
    Java的原子性&&可见性&&有序性原子性定义:原子性:是指一个操作或多个操作要么全部执行,且执行的过程不会被任何因素打断,要么就都不执行。原子操作原理(处理器是如何实现原子操作的)处理器实现原子操作有3种...
  • 如何解决线程切换带来的原子性问题呢?答案是**保证多线程之间的互斥性。也就是说,在同一时刻只有一个线程在执行!**如果我们能够保证对共享变量的修改是互斥的,那么,无论是单核CPU还是多核CPU,都能保证多线程...
  • volatile不保证原子性

    千次阅读 2019-05-04 22:38:08
    volatile不保证原子性 大厂面试题: 1、请你谈谈对volatile的理解? 2、CAS你知道吗? 3、原子类AtomicInteger的ABA问题谈谈?原子更新引用知道吗? 4、我们都知道ArrayList是线程不安全的,请编码写一个不安全...
  • 数据库的事务必须满足4个特性:原子性, 一致性, 隔离性, 持久性,它们英文单词首字母合起来就是:ACID 在这些事务特性中,数据“一致性”为最终目标,其他特性都是为达到这个目标而采取的措施和手段。数据库...
  • JAVA的原子性和可见性的理解 这篇博客主要解决两个问题: 1. 原子性和可见性的区别 (1)原子性是拒绝多线程操作的,不论是多核还是单核,具有原子性的量,同一时刻只能有一个线程来对它进行操作。简而言之,在整个...
  • 在第一篇文章01并发编程的Bug源头当中,讲到了把一个或者多个操作在 CPU 执行的过程中不被中断的特性称为原子性,那么原子性的问题该如何解决。 同一时刻只有一个线程执行这个条件非常重要,我们称为互斥,如果能...
  • Java多线程之原子性操作

    千次阅读 2018-03-09 21:59:48
    何谓原子性操作,即为最小的操作单元,比如i=1,就是一个原子性操作,这个过程只涉及一个赋值操作。又如i++就不是一个原子操作,它相当于语句i=i+1;这里包括读取i,i+1,结果写入内存三个操作单元。因此如果操作不...
  • 程序的原子性操作

    万次阅读 2020-08-14 00:21:09
    作为开发人员经常会用到锁, 因为锁通常来说具有原子性,那原子性又是什么? 有些人说,原子性就是同一个代码块在任何时刻只能被一个线程访问执行,其他线程则等待(阻塞). 细想一下这句话应该属于排它性. 也有人说不可...
  • 也就是说ACID四大特性之中,C(一致性)是目的,A(原子性)、I(隔离性)、D(持久性)是手段,是为了保证一致性,数据库提供的手段。数据库必须要实现AID三大特性,才有可能实现一致性。例如,原子性无法保证,显然一致性...
  • 1、原子性概念 原子性是指**一个操作是不可中断的,要么全部执行成功,要么全部执行失败,有着“同生共死”的感觉。**即使在多个线程一起执行的时候,一个操作一旦开始,就不会被其它的线程干扰。 例如语句(a++)实际...
  • 线程安全是我们在进行 Java 并发编程的时候必须要先考虑清楚的一个问题。这个类在单线程环境下是没有问题的,那么我们就能确保它在多线程并发的情况下表现出正确的行为吗? 我这个人,在没有副业之前,一心扑在...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 368,536
精华内容 147,414
关键字:

原子性