Java学习笔记7-线程安全之原子操作

最新推荐文章于 2024-08-01 15:33:26 发布
最新推荐文章于 2024-08-01 15:33:26 发布
阅读量180 收藏
点赞数
分类专栏： Java # 多线程与高并发 文章标签： java 多线程 线程安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jwx90312/article/details/103067391
版权

Java学习笔记7-线程安全之原子操作

讲原子操作之前先说下几个概念 竞态条件、临界区、共享资源及不可变对象。

竞态条件与临界区

多个线程访问了相同的资源，向这些资源做写操作时，对执行顺序有要求。

临界区：incr 方法内部就是临界区域，关键部分代码的多线程并发执行，会对执行结果产生影响。

竟态条件：可能发生在临界区域内的特殊条件。多线程执行incr 方法中的 i++关键代码时，产生了竞态条件。

public void incr() {
    i++;
}
共享资源

如果一段代码是线程安全的，则它不包括竞态条件。只有当多个线程更新共享资源时，才会发生竞态条件。

栈封闭时，不会在线程之间共享的变量，都是线程安全的。

局部对象引用本身不共享，但是引用的对象存储在共享堆中。如果方法内创建的对象，只是在方法中传递，并且不对其他线程可用，那么也是线程安全的。

判定规则：如果创建、使用和处理资源，永远不会逃脱单个线程的控制，该资源的使用是线程安全的。

public void method1() {
    LocalObject localObject = new LocalObject();
    localObject.callMethod();
    method2(localObject);
}
public void method2(LocalObject localObject) {
    localObject.setValue("value");
}
不可变对象

创建不可变的共享对象来保证对象在线程间共享时不会被修改，从而实现线程安全。

实例被创建，value变量就不能再被修改，这就是不可变性，比如final

public class Demo {
    private int value = 0;

    public Demo(int value) {
        this.value = value;
    }

    public int getValue() {
        return value;
    }
}

final：强调不变性

  1. 修饰类：
    • 被final修饰的类不能被继承。
    • 类中的成员方法都会被隐式的指定为final方法。
  2. 修饰方法：
    • 被final修饰的方法不能被重写。
    • 一个类的private方法会被隐式的指定为final方法。
    • 如果父类中有final修饰的方法，那么子类不能去重写。
  3. 修饰成员变量：
    • 被fianl修饰的成员变量必须要赋初始值，有两种方式：1、直接赋值 2、在构造方法中赋值。
    • 如果修饰的成员变量是基本类型，则表示这个变量的值不能改变。
    • 如果修饰的成员变量是一个引用类型，则是说这个引用的地址的值不能修改，但是这个引用所指向的对象里面的内容还是可以改变的。
    • 使用static final修饰：不能被修改，无需实例化，声明必须初始化 。
原子操作

原子操作可以是一个步骤，也可以是多个操作步骤，但是其顺序不可以被打乱，也不可以被分割而只执行其中的一部分（不可中断性）。将整个操作视作一个整体，资源在该次操作中保持一致，这是原子性的核心特征。

测试代码

import java.util.concurrent.TimeUnit;

/**
 * @Author: Wenx
 * @Description:
 * @Date: Created in 2019/11/14 12:55
 * @Modified By：
 */
public class DemoTest {
    volatile int i = 0;

    public void incr() {
        i++;
    }

    public static void main(String[] args) throws InterruptedException {
        DemoTest demoTest = new DemoTest();

        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    demoTest.incr();
                }
            }).start();
        }

        TimeUnit.SECONDS.sleep(2);
        System.out.println("结果为：" + demoTest.i);
    }
}

结果和你期望相同吗？2个线程循环10000次，我的期望是20000，可结果……

解决办法：

Atomic

JDK在java.util.concurrent（JUC并发编程包）中提供了atomic原子操作包，其中有很多原子操作封装类，如AtomicInteger 来不及多说，赶紧上车……

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

/**
 * @Author: Wenx
 * @Description:
 * @Date: Created in 2019/11/14 12:55
 * @Modified By：
 */
public class DemoTest {
    AtomicInteger i = new AtomicInteger(0);

    public void incr() {
        i.incrementAndGet();
    }

    public static void main(String[] args) throws InterruptedException {
        DemoTest demoTest = new DemoTest();

        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    demoTest.incr();
                }
            }).start();
        }

        TimeUnit.SECONDS.sleep(2);
        System.out.println("结果为：" + demoTest.i);
    }
}

结果为20000 这回对了吧，我们来看下AtomicInteger它是怎么实现的，查看源码发现incrementAndGet方法内部实际使用了unsafe.compareAndSwapInt方法，也就是传说中的CAS机制，通过CAS自旋锁实现原子操作 。

CAS机制：

compare and swap 比较和交换。属于硬件同步原语，处理器提供了基本内存操作的原子性保证。

CAS操作需要输入两个数值，一个旧值A（期望操作前的值）和一个新值B，在操作期间先比较下旧值有没有发生变化，如果没有发生变化，才交换成新值，发生了变化则不交换。

我们也用unsafe实现一下原子操作吧，unsafe可以直接操作内存，修改对象，数组内存…简直就是一个字 强！但是看名字就不安全，所以正规方法它是不让你用的，但是我们有黑科技通过反射可以使用。

import sun.misc.Unsafe;

import java.lang.reflect.Field;
import java.util.concurrent.TimeUnit;

public class DemoTest {
    volatile int i = 0;

    static Unsafe unsafe;
    private static long valueOffset;

    static {
        try {
            // 反射技术获取unsafe值
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            unsafe = (Unsafe) field.get(null);

            // 获取到 i 属性偏移量（用于定位 i 属性在内存中的具体地址）
            valueOffset = unsafe.objectFieldOffset(DemoTest.class.getDeclaredField("i"));

        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    public void incr() {
        // CAS自旋：CAS + 循环 重试
        int current;
        do {
            // 操作耗时的话，那么线程就会占用大量的CPU执行时间
            current = unsafe.getIntVolatile(this, valueOffset);
        } while (!unsafe.compareAndSwapInt(this, valueOffset, current, current + 1));
        // 可能会失败
    }

    public static void main(String[] args) throws InterruptedException {
        DemoTest demoTest = new DemoTest();

        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    demoTest.incr();
                }
            }).start();
        }

        TimeUnit.SECONDS.sleep(2);
        System.out.println("结果为：" + demoTest.i);
    }
}

LongAdder：

因为之前CAS自旋的方法，在多线程中操作耗时的话，那么线程就会占用大量的CPU执行时间，在JDK1.8提供了几个专门用来计数的封装类，如LongAdder ，通过各线程独自累加，最后把结果求和的办法，效率有明显提升。

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

/**
 * @Author: Wenx
 * @Description:
 * @Date: Created in 2019/11/14 12:55
 * @Modified By：
 */
public class DemoTest {
    LongAdder i = new LongAdder();

    public void incr() {
        i.increment();
    }

    public static void main(String[] args) throws InterruptedException {
        DemoTest demoTest = new DemoTest();

        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    demoTest.incr();
                }
            }).start();
        }

        TimeUnit.SECONDS.sleep(2);
        System.out.println("结果为：" + demoTest.i.sum());
    }
}
synchronized

同步关键字也可以保证原子性操作

import java.util.concurrent.TimeUnit;

/**
 * @Author: Wenx
 * @Description:
 * @Date: Created in 2019/11/14 12:55
 * @Modified By：
 */
public class DemoTest {
    volatile int i = 0;

    public void incr() {
        synchronized (this) {
            i++;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        DemoTest demoTest = new DemoTest();

        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    demoTest.incr();
                }
            }).start();
        }

        TimeUnit.SECONDS.sleep(2);
        System.out.println("结果为：" + demoTest.i);
    }
}
Lock

加锁也可以实现原子性操作

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

/**
 * @Author: Wenx
 * @Description:
 * @Date: Created in 2019/11/14 12:55
 * @Modified By：
 */
public class DemoTest {
    volatile int i = 0;

    Lock lock = new ReentrantLock();

    public void incr() {
        lock.lock();
        try {
            i++;
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        DemoTest demoTest = new DemoTest();

        for (int i = 0; i < 2; i++) {
            new Thread(() -> {
                for (int j = 0; j < 10000; j++) {
                    demoTest.incr();
                }
            }).start();
        }

        TimeUnit.SECONDS.sleep(2);
        System.out.println("结果为：" + demoTest.i);
    }
}
Wenx408
关注
专栏目录
Java学习笔记----如何保证线程安全
weiqu4386的博客
01-04 1333
如何保证线程安全 文章目录如何保证线程安全前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import n
OC atomic 一定能保证线程安全吗
csdn_coder_zxq的博客
05-23 848
OC atomic 一定能保证线程安全吗 atomic 修饰的属性，编译器会在编译期间在 setter, getter 方法里加入一些互斥锁，保证在多线程开发，读取变量的值正确 atomic 只能保证 setter, getter 线程安全，如 self.name = xxx。但对于 [array objectAtIndex:index] 无法保证多线程安全。 ...
从volatile说到,i++原子操作,线程安全问题
Learning
12-01 1万+
1、可见性(Visibility)         可见性是指，当一个线程修改了某一个全局共享变量的数值，其他线程是否能够知道这个修改。         显然，在串行程序来说可见性的问题是不存在的。因为你在任何一个地方操作修改了某个变量，那么在后续的程序里面，读取这个变量的数值，一定是修改后的数值。         但是，这个问题在并行程序里面就不见得了。在并行程序里面，如果一个线程修改了某
Java学习笔记-线程安全
cyh0503的博客
07-08 2606
线程安全 如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。 现在通过一个案例来延时线程的安全问题： 电影院卖票，一共100张票数，我们现在通过3个窗口来卖100张票： 模拟票： public class Ticket implements Runnable { private in...
Java学习笔记---多线程并发
weixin_44823875的博客
03-22 1599
Java学习笔记---多线程并发认识线程和进程java中线程的实现继承Thread类（多线程实现类）实现Runnable接口（==推荐使用==）Thread类和Runnable接口线程的状态线程操作的方法同步与死锁使用同步解决使用死锁解决 认识线程和进程 进程是线程一次动态执行过程，它需要经历从代码加载、代码执行到执行完毕的一个完整过程，这个过程也是进程本身从产生、发展到最终消亡的过程。因为每个进...
java多线程并发之原子操作-CAS以及原子类atomic
2401_84411776的博客
04-18 901
切莫死记硬背，小心面试官直接让你出门右拐1000道互联网Java面试题：
Java多线程学习笔记 - 二、自增（减）不是原子操作
学以致用 知行合一
03-15 1226
1、Java自增（减）不是原子操作。自增自减不是原子性操作，也就是说不是线程安全的运算。因此，在多线程下，如果你要对共享变量实现自增自减操作，就要加锁，或者使用JDK提供的原子操作类（如AtomincInteger，AtomicLong等）提供的原子性自增自减方法。 2、使用原子类和synchronized都能保证线程安全，但是其实现原理不同。 3、Synchronized 是仅适用于方法和块但不适用于变量和类的修饰符。
Java多线程实战-从零手搓一个简易线程池(一)定义任务等待队列
热门推荐
qq_35716689的博客
03-25 24万+
开个新坑-手搓简易线程池。本系列文章将从零开始,一步步手工编码实现一个简单但功能完备的线程池。我们将逐步介绍线程池的各个核心组件,并分析它们的作用和实现思路。通过这个过程,我们可以更好地掌握多线程编程的技巧,并培养编码能力和系统性思维。
Java多线程学习笔记
最新发布
qq_44903634的博客
08-01 1603
wait()会使“当前线程”等待，因为线程进入等待状态，所以线程应该释放它锁持有的“同步锁”，否则其它线程获取不到该“同步锁”而无法运行！其他线程获取“该对象的同步锁”(
JAVA学习笔记 -- 多线程之共享资源
u012964281的专栏
07-31 1817
在多线程程序运行过程中，可能会涉及到两个或者多个线程试图同时访问同一个资源。为了防止这种情况的发生，必须在线程使用共享资源时给资源“上锁”，以阻挡其它线程的访问。而这种机制也常常被称为互斥量，本文主要介绍它的两种方式synchronized和Lock 。 1、synchronized 当任务要执行被synchronized关键字保护的代码片段的时候，它会检查锁是否可用，然后获取锁，执行代码，释
JAVA并发编程实践-线程安全-学习笔记
07-20
另外，Java的并发包`java.util.concurrent`引入了显式锁（如`Lock`接口及其实现类），以及原语操作（如Atomic类），这些都为开发者提供了更细粒度的控制，可以在不使用synchronized的情况下实现线程安全。...
多线程-狂神说Java学习笔记
07-19
本学习笔记将深入探讨Java多线程的相关知识，包括其原理、实现方式、同步机制以及常见问题。 ### 一、多线程的基本概念 多线程是指在一个程序中存在两个或更多的执行线程，这些线程共享同一内存空间，但各自拥有...
Java 并发学习笔记：进程和线程，并发理论，并发关键字，Lock 体系，原子操作类，发容器 & 并发工具，线程池，并发实践
12-26
Java 并发学习笔记： 进程和线程， 并发理论， 并发关键字， Lock 体系， 原子操作类， 发容器 & 并发工具， 线程池， 并发实践 Java是一种面向对象的编程语言，由Sun Microsystems于1995年推出。它是一种跨平台的...
Java中线程同步和线程协作学习笔记
05-27
事务是数据库操作中的另一个关键概念，它保证了数据库操作的隔离性、一致性、原子性和持久性。事务的隔离性是防止多个事务之间相互干扰，常见的隔离级别包括读未提交、读已提交、可重复读和串行化。悲观锁和乐观锁是...
静态工具类中使用@Autowired的方法
Wenx
01-13 4353
静态工具类中使用@Autowired的方法 在Spring项目中我习惯使用@Autowired来注入Service层或者Dao层，在一次偶然我在静态方法中查询数据库数据，而报了NullPointerException，一路找来发现Mapper为Null，分析原因发现Spring不支持依赖注入static静态变量，静态变量/类变量不是对象的属性而是一个类的属性，spring则是基于对象层面上的依赖注...
Java学习笔记16-Netty缓冲区ByteBuf详解
Wenx
11-26 2464
Java学习笔记16-Netty缓冲区ByteBuf详解 Netty自己的ByteBuf ByteBuf是为解决ByteBuffer的问题和满足网络应用程序开发人员的日常需求而设计的。 JDK ByteBuffer的缺点： 无法动态扩容：长度是固定的，不能动态扩展和收缩，当数据大于ByteBuffer容量时，会发生索引越界异常。 API使用复杂：读写的时候需要手工调用flip()和rewind(...
Jedis连接池配置详解
Wenx
12-16 1479
Jedis连接池配置详解 写代码是日益精进的不是一蹴而就的，以前写代码就是各处借鉴，然后完成项目的需要就放在那里了，时间长了接触的多了，再来看之前代码总觉得哪里不太对劲（简直垃圾，这能是我写的？），觉得需要改变，这次顺便记录下来，也分享给大家，相当于优化轨迹、版本控制等等，以后还有可能改变，但是最终有迹可循~ 不会麻爪~ application.yml redis: host: 127.0.0...
logback-spring日志配置详解
Wenx
12-16 1270
logback-spring日志配置详解 以前研究过日志相关配置，自己针对当时项目草草配置了一个，为了高逼格又把注释什么都删掉了，后来新的项目也就是拿来就用，这次需要针对项目进行配置将日志再细化等，注释没有了，抓瞎了。。。所以这次特意收集相关资料，分析测试整理一份配置文件，并记录下来~ 防止以后又忘记了还找不到了 logback-spring.xml <?xml version="1.0" ...
Spring框架实现策略模式+工厂模式小技巧
Wenx
05-13 832
Spring框架实现策略模式+工厂模式小技巧 翻翻代码无意中发现这个写法还挺有意思，整理下写个Demo发出来供大家一起玩耍~ 大致原理就是通过Spring的@Component和@Autowired注解将策略Service自动装配到工厂中一个Map中，为了方便管理使用了一个策略类型的常量类（你也可以写成配置文件，我记得有些注解内是支持EL表达式的，请自行尝试），在工厂中把常量类的值传进来就可以通过Map定位到策略Service了。 不说废话了，直接上代码~ 策略服务接口： /** * 送礼服务 * *
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值