Java并发编程 (一) 导读

灰太狼 2023-05-29 05:16 28阅读 0赞

## 个人博客网：[https://wushaopei.github.io/][https_wushaopei.github.io]    (你想要这里多有) ##

## 一、并发编程相关技术栈 ##

### 1、内容主要为高并发的解决思路与手段，具体涉及： ###

![20191104163834353.png][]

### 2、涉及的基础知识与核心知识： ###

![20191104163914576.png][]

### 3、并发及并发的线程安全处理 ###

![20191118092003139.png][]

### 4、高并发的思路及手段 ###

![20191118092022310.png][]

### 5、高并发所涉及的技术 ###

*    总体架构： Spring Boot 、Maven、JDK8、MySQL
 *    基础组件： Mybatis、Guava、Lombok、Redis、Kafka
 *    高级组件（类）：Joda-Time、Atomic包、J.U.C、AQS、ThreadLocal、RateLimiter、Hystrix、threadPool、shardbatis、curator、elastic-job、

## 二、并发编程初体验 ##

### 1、简单的业务场景 ###

实现一个计数功能

package com.mmall.concurrency.example.count;
    
    import com.mmall.concurrency.annoations.NotThreadSafe;
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.concurrent.CountDownLatch;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.Semaphore;
    
    @Slf4j
    @NotThreadSafe
    public class CountExample1 {
    
        // 请求总数
        public static int clientTotal = 5000;
    
        // 同时并发执行的线程数
        public static int threadTotal = 200;
    
        public static int count = 0;
    
        public static void main(String[] args) throws Exception {
            ExecutorService executorService = Executors.newCachedThreadPool();
            final Semaphore semaphore = new Semaphore(threadTotal);
            final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
            for (int i = 0; i < clientTotal ; i++) {
                executorService.execute(() -> {
                    try {
                        semaphore.acquire();
                        add();
                        semaphore.release();
                    } catch (Exception e) {
                        log.error("exception", e);
                    }
                    countDownLatch.countDown();
                });
            }
            countDownLatch.await();
            executorService.shutdown();
            log.info("count:{}", count);
        }
    
        private static void add() {
            count++;
        }
    }

执行结果：

10:00:37.322 [main] INFO com.mmall.concurrency.example.count.CountExample1 - count:4994
    
    Process finished with exit code 0

**将线程修改为1时，count为5000:**

// 同时并发执行的线程数
        public static int threadTotal = 1;

结果如下：

10:02:37.170 [main] INFO com.mmall.concurrency.example.count.CountExample1 - count:5000
    
    Process finished with exit code 0

注意：这里可以引发出一个问题，当我们在编写程序时，在本地进行测试时，只有一个进程，并且基本处于单线程环境下，而当项目部署上线后，项目登录、使用的用户绝不止一个用户，此时，会存在并发的情况，即同一服务进程下，多个用户的客户端操作线程进行请求服务器，此时，就可能由于服务器的响应问题等导致对部分客户端的请求响应中断、丢包等问题。

### 2、基本概念 ###

并发： 同时拥有两个或者多个线程，如果程序在**单核处理器**上运行，多个线程将交替地**换入或换出内存**，这些线程是同时 “ 存在” 的 ，每个线程都处于执行过程中的某个状态，如果运行在**多核处理器**上，此时，程序中的**每个线程**都将分配到一个**处理器核**上，因此可以**同时运行**。

高并发：高并发（High Concurrency） 是互联网分布式系统架构设计中必须考虑的因素之一，它通常是指，通过设计保证系统能够**同时并行处理**很多请求。

**并发与高并发的区别：**

> **   并发：** 多个线程操作相同的资源，保证线程安全，合理使用资源
> 
>   **高并发**：服务能同时处理很多请求，提高程序性能

[https_wushaopei.github.io]: https://wushaopei.github.io/
[20191104163834353.png]: https://img-blog.csdnimg.cn/20191104163834353.png
[20191104163914576.png]: https://img-blog.csdnimg.cn/20191104163914576.png
[20191118092003139.png]: https://img-blog.csdnimg.cn/20191118092003139.png
[20191118092022310.png]: https://img-blog.csdnimg.cn/20191118092022310.png