JUC高并发编程详解

深碍√TFBOYSˉ_ 2024-04-06 15:18 83阅读 0赞

大家好，欢迎来到这篇关于JUC（Java Util Concurrent）高并发编程的博客！在这个数字时代，我们的软件需求越来越庞大，而对于高并发编程的需求也日益迫切。在Java的世界里，JUC就像一位强大的武士，为我们打开了处理并发编程的大门。今天，我们将深入了解JUC，学习它的各种武器和战术，助你在并发的战场上游刃有余。

![在这里插入图片描述][bd12a74a5325462096f95dfbf15952e0.png]

### 为什么要关注高并发？ ###

在我们的日常生活中，我们经常面对着需要同时处理多个任务的情况。比如，你在一个热门的电商网站购物，同时成千上万的人也在浏览同一件商品；或者你在一个社交平台发布了一条动态，瞬间就被数百人点赞和评论。这时，高并发就成了我们需要面对的挑战。所以，掌握高并发编程是我们作为程序员必备的技能之一。

### JUC简介 ###

首先，让我们认识一下JUC。JUC是Java 5引入的一个包，旨在提供更强大的并发编程支持。可以把它想象成一座丰富多彩的工具库，里面有各种各样的工具，帮助我们轻松应对并发的各种问题。

### 并发基础知识 ###

在深入JUC之前，我们需要掌握一些基础的并发概念。首先是线程，你可以把它想象成程序中的一条执行路径。当多个线程同时执行时，就会涉及到共享资源的访问问题。这时，我们就需要考虑如何保证多个线程之间的安全性。

#### 同步与异步 ####

在并发编程中，同步和异步是两个关键的概念。同步指的是按照程序的顺序依次执行，而异步则是可以同时执行多个任务，不需要等待前一个任务完成。就像你在餐馆等待上菜的时候，服务员会继续为其他桌的客人服务，这就是异步。

// 示例：同步执行
    public synchronized void synchronizedMethod() {
        
        // 一些同步操作
    }
    
    // 示例：异步执行
    public void asynchronousMethod() {
        
        CompletableFuture.runAsync(() -> {
        
            // 一些异步操作
        });
    }

#### 互斥锁 ####

在并发编程中，互斥锁是一种常用的同步机制，用于保护共享资源，防止多个线程同时修改数据造成的问题。在Java中，我们可以使用`synchronized`关键字或`ReentrantLock`类来实现互斥锁。

// 示例：synchronized关键字
    public synchronized void synchronizedMethod() {
        
        // 互斥锁保护的操作
    }
    
    // 示例：ReentrantLock
    private final ReentrantLock lock = new ReentrantLock();
    
    public void lockMethod() {
        
        lock.lock();
        try {
        
            // 互斥锁保护的操作
        } finally {
        
            lock.unlock();
        }
    }

### JUC的利器：线程池 ###

在高并发环境下，创建大量线程会导致系统资源的浪费和性能下降。为了更有效地管理线程，JUC提供了线程池的概念。

#### 线程池的好处 ####

线程池通过维护一定数量的线程，重复利用它们来执行任务，避免了频繁创建和销毁线程的开销。这不仅提高了程序的性能，还避免了线程数量失控可能带来的问题。

#### 使用线程池 ####

JUC提供了`Executor`框架，用于管理线程池。下面是一个简单的线程池的创建和使用示例：

// 示例：创建固定大小的线程池
    ExecutorService executorService = Executors.newFixedThreadPool(5);
    
    // 提交任务
    executorService.submit(() -> {
        
        // 执行任务的代码
    });
    
    // 关闭线程池
    executorService.shutdown();

### 原子操作与CAS ###

在高并发环境中，对共享变量的操作可能会导致数据不一致的问题。为了解决这个问题，JUC提供了原子操作和CAS（Compare and Swap）机制。

#### 原子变量 ####

在JUC中，`Atomic`开头的类如`AtomicInteger`、`AtomicLong`等提供了一系列原子操作，保证了多个线程对变量的操作是原子的。

// 示例：AtomicInteger的使用
    AtomicInteger atomicInteger = new AtomicInteger(0);
    
    int result = atomicInteger.incrementAndGet();

#### CAS机制 ####

CAS是一种乐观锁的实现方式，通过比较并交换的方式来保证操作的原子性。在JUC中，`Atomic`类的原子操作就是基于CAS实现的。

// 示例：CAS的使用
    AtomicInteger atomicInteger = new AtomicInteger(0);
    
    while (true) {
        
        int current = atomicInteger.get();
        int next = current + 1;
    
        if (atomicInteger.compareAndSet(current, next)) {
        
            // 成功修改，退出循环
            break;
        }
    }

### 并发工具类 ###

JUC还提供了一些强大的并发工具类，帮助开发者更方便地处理高并发场景。

#### CountDownLatch ####

`CountDownLatch`是一种同步工具，允许一个或多个线程等待其他线程完成操作。

// 示例：CountDownLatch的使用
    CountDownLatch countDownLatch = new CountDownLatch(3);
    
    // 线程1
    new Thread(() -> {
        
        // 一些操作
        countDownLatch.countDown();
    }).start();
    
    // 线程2
    new Thread(() -> {
        
        // 一些操作
        countDownLatch.countDown();
    }).start();
    
    // 线程3
    new Thread(() -> {
        
        // 一些操作
        countDownLatch.countDown();
    }).start();
    
    // 主线程等待
    countDownLatch.await();

#### CyclicBarrier ####

`CyclicBarrier`也是一种同步工具，它允许一组线程互相等待，直到所有线程都到达某个公共屏障点。

// 示例：CyclicBarrier的使用
    CyclicBarrier cyclicBarrier = new CyclicBarrier(3);
    
    // 线程1
    new Thread(() -> {
        
        // 一些操作
        try {
        
            cyclicBarrier.await(); // 等待其他线程
        } catch (InterruptedException | BrokenBarrierException e) {
        
            e.printStackTrace();
        }
    }).start();
    
    // 线程2
    new Thread(() -> {
        
        // 一些操作
        try {
        
            cyclicBarrier.await(); // 等待其他线程
        } catch (InterruptedException | BrokenBarrierException e) {
        
            e.printStackTrace();
        }
    }).start();
    
    // 线程3
    new Thread(() -> {
        
        // 一些操作
        try {
        
            cyclicBarrier.await(); // 等待其他线程
        } catch (InterruptedException | BrokenBarrierException e) {
        
            e.printStackTrace();
        }
    }).start();
    
    // 主线程等待
    cyclicBarrier.await();

#### Semaphore ####

`Semaphore`是一种允许多个线程同时访问共享资源的同步工具。

// 示例：Semaphore的使用
    Semaphore semaphore = new Semaphore(3); // 允许3个线程同时访问
    
    // 线程1
    new Thread(() -> {
        
        try {
        
            semaphore.acquire(); // 获取许可
            // 一些操作
        } catch (InterruptedException e) {
        
            e.printStackTrace();
        } finally {
        
            semaphore.release(); // 释放许可
        }
    }).start();
    
    // 线程2、线程3 略...

### 线程安全容器 ###

在多线程环境中，对容器的操作需要考虑线程安全性。JUC提供了一些线程安全的容器，如`ConcurrentHashMap`、`CopyOnWriteArrayList`等。

#### ConcurrentHashMap ####

`ConcurrentHashMap`是`HashMap`的线程安全版本，适用于高并发的场景。

// 示例：ConcurrentHashMap的使用
    ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
    
    map.put("key1", 1);
    map.put("key2", 2);
    
    int result = map.get("key1");

#### CopyOnWriteArrayList ####

`CopyOnWriteArrayList`是`ArrayList`的线程安全版本，它通过在写操作时复制整个容器，避免了写操作影响读操作的性能问题。

// 示例：CopyOnWriteArrayList的使用
    CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
    
    list.add("element1");
    list.add("element2");
    
    String result = list.get(0);

### 异步编程 ###

随着异步编程的兴起，JUC也提供了一些支持异步编程的工具。

#### CompletableFuture ####

`CompletableFuture`是一个强大的工具，用于异步编程。它支持链式调用，可以方便地处理异步任务的结果。

// 示例：CompletableFuture的使用
    CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
        
        // 异步执行的任务
        return "Hello";
    }).thenApplyAsync(result -> {
        
        // 在上一个任务的结果上进行操作
        return result + " World";
    }).thenAcceptAsync(finalResult -> {
        
        // 处理最终结果
        System.out.println(finalResult);
    });
    
    // 主线程等待
    future.join();

### 总结 ###

JUC提供了丰富的工具和框架，帮助开发者更轻松地应对高并发编程的挑战。从线程池、原子操作、并发工具类到线程安全容器和异步编程，每个组件都为我们提供了强大的功能。通过深入理解并合理使用这些工具，我们能够编写出高效、安全且易维护的高并发程序。

高并发编程可能是一项复杂的任务，但通过学习和实践，我们可以逐步掌握其中的要点。希望这篇博客对你在JUC高并发编程的学习和实践中有所帮助。在这个充满挑战的编程领域中，让我们携手前行，不断探索并发的奥秘！ Happy coding！

<table> 
 <tbody> 
  <tr> 
   <td> <strong><font>作者信息</font></strong><br> <br> <font> 作者 ： 繁依Fanyi</font><br> <font>CSDN：</font> <a href="https://blog.csdn.net/qq_21484461?spm=1000.2115.3001.5343" rel="nofollow"><font>https://techfanyi.blog.csdn.net</font></a><br> <font>掘金：</font><a href="https://juejin.cn/user/4154386571867191" rel="nofollow"><font>https://juejin.cn/user/4154386571867191</font></a> </td> 
  </tr> 
 </tbody> 
</table>

[bd12a74a5325462096f95dfbf15952e0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/1c2459c8a62e47479e17c2b2d5550541.png