java-07 多线程-并发编程(原子变量、CountDownLatch、Future和CompletableFuture、volatile)

已于 2024-10-10 17:13:28 修改
阅读量542 收藏 14
点赞数 11
分类专栏： java基础 文章标签： java
于 2024-10-10 17:02:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wyh106115/article/details/142826747
版权

  并发编程是指在一个程序中同时执行多个任务或线程。这通常涉及到多线程编程、线程同步、并发容器等技术。这些技术可以用来解决多线程环境中的问题，如线程安全、资源竞争、死锁等问题。在实际的Java并发编程中，还需要考虑到线程池、Future、Callable、ExecutorService等概念。

在另一篇文章介绍了多线程、进程、并发、并行等基本概念，并分析了线程安全问题产生的原因，同时也整理了线程实现的4种方式，并做了对比，请参考 java-06 多线程-4种实现方式

如果你觉得我分享的内容或者我的努力对你有帮助，或者你只是想表达对我的支持和鼓励，请考虑给我点赞、评论、收藏。您的鼓励是我前进的动力，让我感到非常感激。

文章目录

1 线程同步

1.1 锁

java-07 多线程-并发编程(锁)

1.2 原子变量

除了 StampedLock 中的乐观读锁，java.util.concurrent.atomic 包下面 AtomicInteger、AtomicLong、AtomicIntegerArray、AtomicReference 等原子变量类也是基于乐观锁的思想实现的。

不过普通的 AtomicInteger 可能会存在 ABA 问题，此时可以使用 AtomicStampedReference，它内部除了一个对象引用，还维护了一个可以自动更新的整数，通过标识版本来避免 ABA 问题。

AtomicInteger 的基本使用示例：

import java.util.concurrent.atomic.AtomicInteger;

public class Main {
    private static final AtomicInteger counter = new AtomicInteger(0);

    public static void main(String[] args) {
        Runnable incrementTask = () -> {
            for (int i = 0; i < 10000; i++) {
                counter.incrementAndGet();
            }
        };

        Thread thread1 = new Thread(incrementTask);
        Thread thread2 = new Thread(incrementTask);

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final counter value: " + counter.get());
    }
}

AtomicReference 的基本使用示例：

import java.util.concurrent.atomic.AtomicReference;

public class Main {
    private static final AtomicReference<Integer> counterRef = new AtomicReference<>(0);

    public static void main(String[] args) {
        Runnable incrementTask = () -> {
            for (int i = 0; i < 10000; i++) {
                while (true) {
                    Integer current = counterRef.get();
                    Integer updated = current + 1;
                    if (counterRef.compareAndSet(current, updated)) {
                        break;
                    }
                }
            }
        };

        Thread thread1 = new Thread(incrementTask);
        Thread thread2 = new Thread(incrementTask);

        thread1.start();
        thread2.start();

        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("Final counter value: " + counterRef.get());
    }
}

1.3 ThreadLocal

1.4 CountDownLatch

CountDownLatch 是一个同步辅助类，它允许一个或多个线程等待其他线程完成操作。CountDownLatch 通过一个计数器来实现一个线程等待其他线程完成某个操作，当计数器的值减为零时，等待的线程被释放。

CountDownLatch 主要提供了以下方法：

  • CountDownLatch(int count)：构造方法，用于初始化计数器，指定计数器的初始值为 count。
  • void await() throws InterruptedException：当调用线程调用此方法时，它会一直等待，直到计数器减为零。如果计数器不为零，线程将被阻塞。
  • boolean await(long timeout, TimeUnit unit) throws InterruptedException：在指定的时间内等待计数器减为零，如果在指定时间内计数器未减至零，线程将被唤醒。
  • void countDown()：每个被等待的线程执行完任务后，都应该调用此方法来减小计数器的值。

以下是一个 CountDownLatch 的简单的示例：

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService es = Executors.newFixedThreadPool(10);
        CountDownLatch latch = new CountDownLatch(10);

        Runnable task = () -> {
            System.out.println("task");
            latch.countDown();
        };

        long begin = System.currentTimeMillis();

        for (int i = 0; i < 10; i++) {
            es.submit(task);
        }
        latch.await();

        long end = System.currentTimeMillis();
        System.out.println("time = " + (end - begin));
    }
}

1.5 Future 和 CompletableFuture

Future 是一个接口，允许我们提交一个任务给线程池或其他异步执行机制，并且在未来获取该任务的结果。它通常用于处理耗时的操作，以便不阻塞主线程，从而提高程序的性能和响应性。

Future 接口相关方法：

  • get()：用来获取异步任务的结果，如果任务尚未完成，调用 get() 将会阻塞当前线程，直到任务完成并返回结果。
  • isDone()：用来检查异步任务是否已经完成，如果任务已经完成，它将返回 true，否则返回 false。
  • cancel(boolean mayInterruptIfRunning)：用于取消异步任务的执行，mayInterruptIfRunning 参数用于指定是否应该中断正在执行的任务。如果任务成功取消，get() 方法将会抛出 CancellationException。

Future 接口通常通过 ExecutorService 接口的实现来使用，ExecutorService 提供了一种提交任务并获取 Future 的方式，从而管理线程池中的任务。

此外，Java 8 中还引入了 CompletableFuture 类，它实现了 Future 接口并提供了更丰富的功能，包括支持函数式编程、组合多个异步任务等。

Future 异步执行任务示例：

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

class Solution {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(2);

        Future<Integer> future = executor.submit(() -> {
            Thread.sleep(2000);  // 模拟一个耗时操作
            return 42;
        });

        try {
            System.out.println("等待任务完成...");
            Integer result = future.get();
            System.out.println("任务完成，结果为：" + result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
        executor.shutdown();
    }
}

CompletableFuture 异步执行任务示例：
分批处理数据

批量删除数据

@Async("commonCmdbExecutor")
public CompletableFuture<CmdbResultVo> multiDeleteObjInstance(CmdbDeleteObjInstanceReqVo body,
    CountDownLatch latch) {
    String url = cmdbHost + CmdbConstants.MULTI_DELETE_OBJ_INSTANCE_URL;
    ResponseEntity<CmdbResultVo> exchange = null;
    try {
        exchange = restTemplate.exchange(url, HttpMethod.POST, new HttpEntity<Object>(body, new HttpHeaders()),
            CmdbResultVo.class);
    } catch (Exception e) {
        LOG.error("delete data error", e);
    } finally {
        latch.countDown();
    }
    return exchange == null ? null : CompletableFuture.completedFuture(exchange.getBody());
}


public int deleteCmdbDataAsync(String objCode, List<String> ids) {
    int groupQty = ids.size() / DELETE_MAX_SIZE;
    int resultCode = 1;
    CountDownLatch latch = new CountDownLatch(groupQty + 1);
    List<CompletableFuture<CmdbResultVo>> futures = new CopyOnWriteArrayList<>();
    for (int i = 0; i <= groupQty; i++) {
        CmdbDeleteObjInstanceReqVo deleteBody = new CmdbDeleteObjInstanceReqVo();
        deleteBody.setObjCode(objCode);
        List<String> curGroup = getCurGroup(i, DELETE_MAX_SIZE, ids);
        deleteBody.setInstanceIdList(curGroup);
        CompletableFuture<CmdbResultVo> cmdbResultVoCompletableFuture =
            cmdbClient.multiDeleteObjInstance(deleteBody, latch);
        futures.add(cmdbResultVoCompletableFuture);
    }
    try {
        latch.await(3, TimeUnit.MINUTES);
    } catch (InterruptedException e) {
        LOG.error("InterruptedException:", e);
        Thread.currentThread().interrupt();
    } catch (Exception e) {
        LOG.error("Exception:", e);
    }
    for (CompletableFuture<CmdbResultVo> future : futures) {
        try {
            CmdbResultVo response = future.get();
            if (response.getResultCode() == 0) {
                resultCode = 0;
            }
        } catch (Exception e) {
            LOG.error("Exception:", e);
        }
    }
    return resultCode;
}

批量更新数据

    @Async("commonCmdbExecutor")
    public <T> CompletableFuture<CmdbResultVo> multiUpdateObjInstanceAsync(CmdbUpdateObjInstanceReqVo<T> body,
        CountDownLatch latch) {
        String url = cmdbHost + CmdbConstants.MULTI_UPDATE_OBJ_INSTANCE_URL;
        ResponseEntity<CmdbResultVo> exchange = null;
        try {
            exchange = restTemplate.exchange(url, HttpMethod.POST, new HttpEntity<Object>(body, new HttpHeaders()),
                CmdbResultVo.class);
        } catch (Exception e) {
            LOG.error("update data error", e);
        } finally {
            latch.countDown();
        }
        return exchange == null ? null : CompletableFuture.completedFuture(exchange.getBody());

    }

1.6 volatile

volatile 关键字主要有两层语义：

  • 保证多线程环境下共享变量操作的可见性：参考 Java 内存模型（JMM）中先行发生（Happens-Before）原则对 volatile 变量规则的描述，对于一个 volatile 变量，如果对于这个变量的写操作先行发生于这个变量的读操作，那么这个写操作所产的影响对于后续的读操作是可见的。

  • 禁止指令重排序：编译器在编译时会在生成的字节码中插入特定的内存屏障指令，确保在 volatile 变量读写操作前后的代码不会被重排序。具体来说，会在 volatile 变量写操作之后，读操作之前插入屏障，因此执行到 volatile 变量读写操作时，前面的操作一定已经执行完成，后面的操作一定还未开始。
    voliatile有三大特性：

  1. 保证可见性。
  2. 不保证原子性。
  3. 禁止指令重排。

因此，voliatile解决不了线程安全问题

wyh106115
关注
专栏目录
java并发编程艺术源码-The-Art-of-Java-Concurrency-Programming:Java并发编程的艺术
05-25
5. **Future和Callable接口**：这些接口允许我们异步执行任务并获取结果，是Java 5引入的并发编程新特性。 6. **线程池**：通过`ExecutorService`和`ThreadPoolExecutor`，我们可以创建自定义的线程池来管理和调度...
java多线程并发编程 核心技术应用实践
06-21
总之，《java多线程并发编程核心技术应用实践》将带领我们全面掌握Java并发编程的核心概念和实践技巧，使我们能够在实际项目中更好地利用多线程，提升系统的并发能力和响应速度。通过阅读源码java-thread-ghy-master...
java-07 多线程-并发编程(synchronized、原子变量、ThreadLocal、CountDownLatch、Future和CompletableFuture、volatile、线程池)
最新发布
wyh106115的博客
10-10 412
并发编程是指在一个程序中同时执行多个任务或线程。这通常涉及到多线程编程、线程同步、并发容器等技术。这些技术可以用来解决多线程环境中的问题，如线程安全、资源竞争、死锁等问题。在实际的Java并发编程中，还需要考虑到线程池、Future、Callable、ExecutorService等概念。
java并发编程和多线程总结
卓越之识论道，平常之识论事，狭隘之识论人
07-17 1514
java并发编程和多线程总结
Java多线程并发编程知识体系(附大图-持续更新)
CodeMavs的博客
08-22 2903
Java并发编程 并发编程的优势 提升CPU资源利用率 CPU缓存 操作系统分时复用 指令流水线优化 提升吞吐量 提升程序响应速度 更好的编程模型 并发带来的问题 安全性问题 定义：多线程读写共享变量时出现不正确的行为 原因 原子性问题 CPU时钟中断带来的线程切换 可见性问题 多核CPU高速缓存之间不可见 重排序问题 CPU和编译器会进行重排序指令 典型问题：单例模式DCL 解决方案 解决可见性问题和重排序 Java内存模型(JMM) 按需.
Java核心技术之- 多线程并发-JUC总结-并发编程
Aili的博客
05-24 521
1. 线程基础线程的创建与启动方式- 线程生命周期管理- 线程的状态转换- 线程同步与互斥- 程优先级设置2. 线程间通信- synchronized 关键字及其实现原理- wait() ， notify() ，notifyAll()，join()方法的使用- Lock 和 Condition 的使用- volatile 关键字的使用 - 原子类的使用- ConcurrentHashMap 和 ConcurrentLinkedQueue 的使用- CountD
Java-线程篇-多线程并发下的锁
const_wu的博客
08-18 958
在计算机体系结构中，多线程是中央处理器 (CPU)（或多核处理器中的单核）在操作系统支持下并发提供多个执行线程的能力。这种方法不同于多处理。在多线程应用程序中，线程共享单个或多个内核的资源，包括计算单元、CPU 缓存和转换后备缓冲区 (TLB)。Java程序是需要运行在Java虚拟机上面的，Java内存模型（Java Memory Model ,JMM）就是一种符合内存模型规范的，屏蔽了各种硬件和操作系统的访问差异的，保证了Java程序在各种平台下对内存的访问都能保证效果一致的机制及规范。
Java 多线程并发编程(一) -总结
精◈彩◈猿◈笔◈记
07-18 405
Java 面试题基础（二） 下面列出这份 Java 面试问题列表包含的主题 多线程，并发及线程基础 数据类型转换的基本原则 垃圾回收（GC） Java 集合框架 数组 字符串 GOF 设计模式 SOLID 抽象类与接口 Java 基础，如 equals 和 hashcode 泛型与枚举 Java IO 与 NIO 常用网络协议 Java 中的数据结构和算法 正则表达式 JVM 底层 Java 最佳实践 JDBC Date, Time 与 Calendar Java
Java并发编程实战-多线程和锁
cafeshadow的博客
08-22 417
Java并发-多线程和锁一.概念进程和线程进程和线程的区别？多进程多线程并发要考虑的问题二.线程安全性概念竞态条件三.对象的共享可见性volatile线程封闭（ThreadLocal）Final四.Java内存模型（JMM）happenBefore
Java多线程与并发-原理
lydms的博客
06-21 1551
​ 那么这里会出现一种情况，有些线程任务队列的任务已经完成，有的队列还有任务没有完成，这就造成已完成任务线程会被闲置，为了提高效率，完成自己任务而处于空闲的线程能够从其它仍处于busy状态的工作线程处窃取等待执行的任务。（1）在代码进入同步块的时候，如果同步对象锁状态为无锁状态（锁标志位为"01"状态），虚拟机首先将在当前线程的栈帧中建立一个名为锁记录（Lock Record）的空间，用于存储锁对象目前的 Mark Word的拷贝，官方称之为Displaced Mark Word。
Java并发编程-多线程个人笔记
weixin_53836048的博客
06-25 1744
参考自JavaGuide
java并发编程实战源码-concurrent-programming:《Java并发编程实战》源码整理
05-25
《Java并发编程实战》这本书是Java并发编程领域的一本经典之作，它深入浅出地讲解了如何在Java环境中高效、安全地进行多线程编程。源码整理集合`concurrent-programming-master`提供了书中示例代码，对于学习和理解...
Java并发编程和多线程的区别
10-15
除了多线程，Java并发编程还涉及其他并发模型，如使用Future和Callable接口来异步执行任务，或者使用并发集合（如ConcurrentHashMap和CopyOnWriteArrayList）来减少线程同步的需求。此外，Java的并发工具类如...
java-multi-thread:《 Java多线程编程核心技术》源代码-java source code
03-25
《Java多线程编程核心技术》源代码集合是一个珍贵的学习资源，包含了书中讲解的各种多线程技术的实际示例。这个开源项目旨在帮助读者深入理解和实践Java中的并发编程概念。以下是一些核心知识点的详细说明： 1. **...
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 932
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1223
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
JDK1.0主要特性
FoolRabbit的专栏
10-06 364
JDK1.0主要特性。
字符函数和字符串函数和内存函数
Java_fenxiang的博客
10-05 705
strtok函数原型与功能概述在 C 语言中，strtok函数的原型为char *strtok(char *str, const char *delim)。它的主要功能是将字符串str按照delim中指定的分隔符进行分割，返回被分割出来的子字符串。工作原理首次调用：当第一次调用strtok时，需要将待分割的字符串str作为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值