栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

【第75题】JAVA高级技术-多线程9(i++的原子性问题)

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

【第75题】JAVA高级技术-多线程9(i++的原子性问题)

回城传送–》《JAVA筑基100例》

文章目录
  • 零、前言
  • 一、题目描述
  • 二、解题思路
  • 三、代码详解
    • 多学一个知识点
  • 四、推荐专栏
  • 五、示例源码下载

零、前言

​ 今天是学习 JAVA语言 打卡的第75天,每天我会提供一篇文章供群成员阅读( 不需要订阅付钱 ),读完文章之后,按解题思路,自己再实现一遍。在小虚竹JAVA社区 中对应的 【打卡贴】打卡,今天的任务就算完成了。

​ 因为大家都在一起学习同一篇文章,所以有什么问题都可以在群里问,群里的小伙伴可以迅速地帮到你,一个人可以走得很快,一群人可以走得很远,有一起学习交流的战友,是多么幸运的事情。

​ 学完后,自己写篇学习报告的博客,可以发布到小虚竹JAVA社区 ,供学弟学妹们参考。

​ 我的学习策略很简单,题海策略+ 费曼学习法。如果能把这100题都认认真真自己实现一遍,那意味着 JAVA语言 已经筑基成功了。后面的进阶学习,可以继续跟着我,一起走向架构师之路。

一、题目描述

题目:重现i++的原子性问题,并解决原子性问题

二、解题思路

并发程序正确地执行,必须要保证原子性、可见性以及有序性。只要有一个没有被保证,就有可能会导致程序运行不正确。

原子性:一个操作或多个操作要么全部执行完成且执行过程不被中断,要么就不执行。

可见性:当多个线程同时访问同一个变量时,一个线程修改了这个变量的值,其他线程能够立即看得到修改的值。

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

我们先来说i++的原子性问题

 

由上面的例子可知道,i++分为三步:“读–》改–》写”,这个过程就会给并发线程带来风险。

使用Atomic解决原子性问题:

在jdk1.5以后java.util.concurrent.atomic包下,提供了

大量的原子变量,它们内部使用CAS算法。

三、代码详解

重现i++的原子性问题

package com.xiaoxuzhu;

import org.junit.Test;


public class TestAtomicDemo {

    @Test
    public void iAtomic() {
        int i = 10;
        i = i++;
        System.out.println("i=" + i);
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        for (int i = 0; i < 10; i++) {
            new Thread(myThread).start();
        }
    }

    static class MyThread implements Runnable {
        private int serialNumber = 0;

        public void run() {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(getSerialNumber());
        }

        public int getSerialNumber() {
            return serialNumber++;
        }

    }
}



但不是每次都会出现,可以多试几次

使用Atomic解决原子性问题

package com.xiaoxuzhu;

import java.util.concurrent.atomic.AtomicInteger;

import org.junit.Test;



public class TestAtomicDemo1 {

    @Test
    public void iAtomic() {
        int i = 10;
        i = i++;
        System.out.println("i=" + i);
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        for (int i = 0; i < 10; i++) {
            new Thread(myThread).start();
        }
    }

    static class MyThread implements Runnable {
        private AtomicInteger serialNumber = new AtomicInteger();

        public void run() {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(getSerialNumber());
        }

        public int getSerialNumber() {
            return serialNumber.getAndIncrement();
        }

    }
}



多学一个知识点

CAS算法

CAS(Compare-And-Swap)是一种硬件对并发的支持,针对多处理器操作而设计的,处理器中的一种特殊指令,用于管理对共享数据的并发访问。

CAS是一种无锁的非阻塞算法实现,是硬件对于并发操作的支持,保证了数据变量的原子性。

Cas包含了3个操作数:

  1. 内存值 V
  2. 预估值 A
  3. 更新值 B

当且仅当 V == A 时, V = B; 否则,不会执行任何操作。

简单的来说,CAS有3个操作数,要读写的内存值V,旧的预期值A,要修改的新值B。当且仅当预期值A和内存值V相同时,将内存值V修改为B,否则返回V(不做任何操作,然后重新获取主存V值,重新操作。)。

这是一种 乐观锁 的思路,它相信在它修改之前,没有其它线程去修改它。

package com.xiaoxuzhu;



public class CASDemo {

    public static void main(String[] args) {
        final CAS cas = new CAS();

        for (int i = 0; i < 20; i++) {
            new Thread(new Runnable() {
                public void run() {
                    int expectedValue = cas.getValue();
                    boolean b = cas.compareAndSet(expectedValue, (int)(Math.random()*100));
                    System.out.println(b);
                }
            }).start();
        }
    }

    static class CAS {
        //内存值
        private volatile int value = 0;

        //获取返回内存值 获取值一定要加同步锁
        private synchronized int getValue(){
            return value;
        }

        
        public synchronized int compareAndSwap(int expectedValue, int newValue) {
            int oldValue = value;
            System.out.println("old:" + oldValue + ",expectedValue:" + expectedValue + ",newValue:" + newValue);
            if (expectedValue == oldValue) {
                value = newValue;
            }

            return oldValue;
        }

        // 如果更新成功,舊的內內存值和預估值相等。
        public synchronized boolean compareAndSet(int expectedValue, int newValue) {
            return expectedValue == compareAndSwap(expectedValue, newValue);
        }
    }
}

四、推荐专栏

《JAVA从零到壹》

《JAVA筑基100例》

五、示例源码下载

关注下面的公众号,回复筑基+题目号

筑基75

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/952550.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号