高并发编程（The Executive Framework）

最新推荐文章于 2024-09-03 21:31:15 发布
最新推荐文章于 2024-09-03 21:31:15 发布
阅读量295 收藏 1
点赞数 1
文章标签： java jvm servlet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51523399/article/details/126431171
版权
本文介绍了Java中线程池的原理与应用，包括使用Executors创建线程池、Callable与Future接口的异步任务处理，以及CompletableFuture、Asynchronous API、异步链、异常处理和结果转换等高级特性。通过实例演示了如何优化高并发场景和提升程序响应速度。
摘要由CSDN通过智能技术生成

​
​

活动地址：CSDN21天学习挑战赛

7.1 线程池

高并发编程要解决的核心问题：由于创建单独的线程是需要消耗一定的系统资源的，因此线程的数量在一定时间是有限的。

使用一个单独的线程执行任务：

  • 需要向系统申请一定的空间资源

  • 同时，这个过程（创建和销毁）也需要耗费一定时间

从JDK 5开始，提供了线程池（Thread Pool）来解决这个问题。线程池，就是存放多个线程的一个容器，这里面的线程可以反复使用。线程池的工作模式具有以下特点：

  • 当一个线程执行完任务后，会重新放回到线程池（而不是销毁），这样它可以继续在执行后续的任务中得到重用。

  • 线程池中的线程是相对固定和有限的，因此不会因为依据太多的任务创建太多的线程而导致Out Of Memory，OOM。

  • 同时，线程池还会管理如何将任务分配给执行的线程来执行：当所有线程都处于繁忙时，那么任务将会被放在一个队列（Queue）中等待，只要有一个线程空闲了，就会从队列中取出一个任务分配给这个空闲的线程来执行。

有了线程池，我们就不需要直接来创建线程，而只需要向线程池提交任务，有线程池来进行管理任务的具体分配。

7.2 Executors

public class Main {
    public static void main(String[] args) {
        var service = Executors.newFixedThreadPool(2);
        try {
            for (int i = 0; i < 5; i++) {
                service.submit(() -> System.out.println(Thread.currentThread().getName()));
            }
        } finally {
            service.shutdown();
        }
    }
}

7.3 Callable & Future

我们还可以使用Callable接口来提交有返回值的任务，得到Feature作为结果

public class LongTask {
    public static void simulate(int ms){
        try {
            Thread.sleep(ms);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
​
public class Main {
    public static void main(String[] args) {
        var service = Executors.newFixedThreadPool(2);
        try {
            var future = service.submit(() -> {
                LongTask.simulate(3_000);
                return 1;
            });
            System.out.println("...");
            var result = future.get();
            System.out.println(result);
        } catch (ExecutionException | InterruptedException e) {
            e.printStackTrace();
        } finally {
            service.shutdown();
        }
    }
}

在提交任务之后，程序会立即返回Future对象作为返回值，但是任务的返回结果并没有得到，一直等到任务执行完毕，我们才能获取到任务执行的结果。（submit方法并不会阻塞程序，但是get方法会阻塞直至任务执行完毕得到返回值）。

7.4 异步编程

在上述案例中，由于最终获取到任务执行结果是需要消耗时间的，因此在此期间，get方法会一直处于阻塞状态。在主线程上，阻塞状态是非常不理想的，因为，它会降低整个程序的响应速度，比如主线程还有其它的事情要做：接收用户的点击事件，同步更新页面上其它数据，等等。这种场景，程序就处于同步状态（synchronous）。为了提高整个应用程序的响应速度和用户体验，我们需要继续对上述代码进行异步化处理（asynchronous）。

7.4.1 CompletableFuture

public class Main {
    public static void main(String[] args) {
//        Runnable task = () -> System.out.println("a");
//        var future = CompletableFuture.runAsync(task);
​
        Supplier<Integer> supplier = () -> 1;
        var future = CompletableFuture.supplyAsync(supplier);
        try {
            var result = future.get();
            System.out.println(result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

7.4.2 Asynchronous API

常规异步案例：

public class MailService {
    public void send() {
        System.out.println("发送邮件ing...");
        LongTask.simulate(3_000);
        System.out.println("发送完毕...");
    }
​
    public CompletableFuture<Void> sendAsync() {
        return CompletableFuture.runAsync(this::send);
    }
}
​
public class Main {
    public static void main(String[] args) {
        var service = new MailService();
        service.sendAsync();
        System.out.println("...");
        LongTask.simulate(5_000);
    }
}

7.4.3 异步链

public class Main {
    public static void main(String[] args) {
        var future = CompletableFuture.supplyAsync(() -> {
            System.out.println("异步逻辑");
            return 1;
        });
        future.thenRunAsync(() -> {
            System.out.println(Thread.currentThread().getName());
            System.out.println("后续逻辑.");
        });
    }
}

异步任务有返回值，在后续任务中获取异步任务处理结果：

public class Main {
    public static void main(String[] args) {
        var future = CompletableFuture.supplyAsync(() -> {
            System.out.println("异步逻辑");
            return 1;
        });
        future.thenRunAsync(() -> {
            System.out.println(Thread.currentThread().getName());
            System.out.println("后续逻辑.");
        });
    }
}

7.4.4 异常处理

public class Main {
    public static void main(String[] args) {
        var future = CompletableFuture.supplyAsync(() -> {
            System.out.println("异步逻辑");
            throw new IllegalStateException();
        });
    }
}

在上述案例中，如果异步任务中如果发生异常的话，那么在主线程中是获取不到的（因为异常是在另一个新的线程中发生的），如果要获取的异常信息并进行相应处理的话，需要如下编码：

public class Main {
    public static void main(String[] args) {
        var future = CompletableFuture.supplyAsync(() -> {
            System.out.println("异步逻辑");
            throw new IllegalStateException();
        });
​
        try {
//            var result = future.get();
            var result = future.exceptionally(ex -> "默认值").get();
            System.out.println(result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

如果直接在future上调用get()，我们将会得到异常；如果在此之前，调用exceptionally()将会得到一个新的CompletableFuture对象，我们可以在其中返回一个当异常发生时的默认值作为处理手段。

7.4.5 转换返回结果

对上一次的异步任务的返回结果进行数据类型的转换：

public class Main {
    public static void main(String[] args) {
        var future = CompletableFuture.supplyAsync(() -> 26);
        future.thenApply(c -> Float.toString(c * 1.8f + 32))
                .thenAccept(System.out::println);
​
    }
}

7.4.6 Compose组合

public class Main {
    public static CompletableFuture<String> findEmailByIdAsync(int id) {
        return CompletableFuture.supplyAsync(() -> {
            System.out.println("根据id：" + id + "查询DB");
            return "a@b.com";
        });
    }
​
    public static CompletableFuture<String> findListByEmailAsync(String email) {
        return CompletableFuture.supplyAsync(() -> {
            System.out.println("根据email：" + email + "查询列表");
            return "播放列表";
        });
    }
​
    public static void main(String[] args) {
        findEmailByIdAsync(1)
                .thenCompose(Main::findListByEmailAsync)
                .thenAccept(System.out::println);
        LongTask.simulate(1000);
    }
}

7.4.7 Combine结果组合

public class Main {
    public static void main(String[] args) {
        var task1 = CompletableFuture.supplyAsync(() -> {
            System.out.println("获取结算金额（美元）");
            return 20;
        });
        var task2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("获取结算汇率");
            return 0.9;
        });
        task1.thenCombine(task2, (price, rate) -> price * rate)
                .thenAcceptAsync(System.out::println);
    }
}

7.4.8 多任务等待

等待所有任务：

public class Main {
    public static void main(String[] args) {
        var task1 = CompletableFuture.supplyAsync(() -> 1);
        var task2 = CompletableFuture.supplyAsync(() -> 2);
        var task3 = CompletableFuture.supplyAsync(() -> 3);
        var all = CompletableFuture.allOf(task1, task2, task3);
        all.thenRun(() -> {
            System.out.println("后续逻辑");
            try {
                var res1 = task1.get();
                System.out.println(res1);
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
        });
    }
}

等待首个完成的任务（竞争问题）：

public class Main {
    public static void main(String[] args) {
        var task1 = CompletableFuture.supplyAsync(() -> {
            LongTask.simulate(1000);
            return 1;
        });
        var task2 = CompletableFuture.supplyAsync(() -> 2);
        CompletableFuture.anyOf(task1, task2)
                .thenAccept(System.out::println);
    }
}

7.4.9 超时任务

public class Main {
    public static void main(String[] args) {
        var future = CompletableFuture.supplyAsync(() -> {
            LongTask.simulate(3000);
            return 1;
        });
        try {
            var result = future.completeOnTimeout(0, 1, TimeUnit.SECONDS)
                    .get();
            System.out.println(result);
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

7.5 Project 询价

向各个航空公司售票代理询价，一旦有询价结果，便输出显示

public class Quote {
    private String name;
    private int price;

    public Quote(String name, int price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public String toString() {
        return "Quote{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

public class FlightService {
    private final Random random = new Random();

    public Stream<CompletableFuture<Quote>> query() {
        var list = List.of("a", "b", "c");
        return list.stream()
                .map(this::query);
    }

    public CompletableFuture<Quote> query(String name) {
        return CompletableFuture.supplyAsync(() -> {
            System.out.println("询价：" + name);
            var delay = random.nextInt(2_000) + 1_000;
            LongTask.simulate(delay);
            var price = random.nextInt(10) + 100;
            return new Quote(name, price);
        });
    }
}

public class Main {
    public static void main(String[] args) {
        var start = LocalTime.now();
        var service = new FlightService();
        var arr = service
                .query()
                .map(future -> future.thenAccept(System.out::println))
                .toArray(CompletableFuture[]::new);

        var all = CompletableFuture.allOf(arr);
        all.thenRun(() -> {
            var end = LocalTime.now();
            var duration = Duration.between(start, end);
            System.out.println("总耗时：" + duration.toMillis());
        });
        LongTask.simulate(3_000);
    }
}

Java哈奇士
关注
高并发和并发编程
zuo_h_dr的博客
04-10 360
第一章 1.并发编程：线程安全+线程封闭+线程调度 +同步容器+并发容器+AQS+JUC 2.高并发解决思路与手段：扩容+缓存+队列+拆分 +服务降级与熔断+数据库切分+分库分表 3.基础知识讲解与核心知识准备： A．cpu多级缓存+缓存一致性+乱序顺序优化 B．java内存模型+jmm规定+抽象结构+同步操作与规则 C．并发优势与风险 D．并发模拟+postman、jmeter...
编程术语英汉对照
大番薯
08-23 2万+
abstract 抽象的 抽象的 　　abstraction 抽象体、抽象物、抽象性 抽象体、抽象物、抽象性 　　access 存取、取用 存取、访问 　　access level 存取级别 访问级别 　　access function 存取函式 访问函数 　　activate 活化 激活 　　active 作用中的 　　adapter 配接器 适配器 　　addr
并发基础概念
Bug君的博客
05-17 271
一、发生情况 计数情况 1、200个线程累加500次会发生问题，数据累加不正确 2、1个线程累加500次不会问题，数据累加争取 二、基本概念 1、并发 同时拥有两个或者多个线程，如果程序在单核处理器上运行，多个线程将交替地换入或换出内存，这些线程是同时“存在”的。每个线程都处于执行过程的某个状态。如果运行在多核处理器上，此时，程序中的每个线程都将分配到一个处理器核上，因此可以同时运行 2、高并发 High Concurrency是互联网分布式系统架构设计中必须考虑的因素之一，通常设计保证系统能够同时并行处理
Java源码学习之高并发编程基础——AQS源码剖析之线程间通信之条件等待队列
最新发布
qq_39108894的博客
09-03 1275
前言：在Java中，使用synchronized关键字构建的锁，线程间通信可以使用某对象实例的wait/notify机制完成。AQS同样也提供了一套线程间通信的解决方案——条件等待队列。在AQS源码分析的两篇文章AQS源码分析（上）AQS源码分析（下）中，我们知道了，无论是独占锁模式还是共享锁模式，AQS提供的能力是将获取不到锁的线程将它们封装成链表节点的形式组织起来进行同步等待。
高并发编程（一）
honger_hua的博客
09-11 1174
高并发编程（一） 概念： 并发：同时拥有两个或多个线程，如果程序在单核处理器上运行，多个线程将交替地换入或者换出内存，这些线程是同时“存在”的，每个线程都处于执行过程中的某个状态，如果运行在多核处理器上，此时，程序中的每个线程都将分配到一个处理器上，因此可以同时运行。 ...
JAVA高并发编程
灵魂画师牧码
07-05 631
# java高并发编程 synchronized 锁定的不是代码块，方法，而是对象，一定要明确，也就是对象锁 静态的属性和方法要锁定当前类的Class对象，也就是所谓的类锁 public static void mm(){ synchronized(T.class) { count--; } } 同步方法和非同步方法同时存在时，非同步方法可以被多个占有该对象的线程...
高并发编程-1
a1084986263的博客
07-26 185
概念： 1-继承Thread类创建线程类 2-通过Runable接口创建线程类 3- 通过Callable和FutureTask创建线程 a. 创建Callable接口的实现类，并实现call()方法； b. 创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callback对象的ca...
计算机编程常用词汇
__静禅__
11-14 3099
第一部分、计算机算法常用术语中英对照 Data Structures 基本数据结构  Dictionaries 字典  Priority Queues 堆  Graph Data Structures 图  Set Data Structures 集合  Kd-Trees 线段树  Numerical Problems 数值问题  Solving Linear Equations
半同步半异步模式 -------一个架构模式，清晰的结构,高效并发的I/O
把握自己。
10-16 3904
译者: cuichaox@gmail.com 英文原文: http://www.cs.wustl.edu/~schmidt/PDF/HS-HA.pdf http://www.cs.wustl.edu/~Schmidt/PDF/PLoP-95.pdf 摘要 这篇文字介绍了半同步半异步模式，这个模式运用在复杂的并行系统中，把同步和异步I/O模型集成在一起，既保持了编程简单又保证了执
聊聊互联网巨头在新加坡的职位与薪酬
热门推荐
圣殿骑士
08-17 3万+
概述 上周发了一篇AutoUpdater迁移到Github， 主要目的是熟悉当前社区写文章的流程以及GitHub的开源和发布流程，另外也开始回归社区，准备多写一些技术文章，多开源项目，顺带把这几年造的轮子也一一开源，我深信有开源才有进步，一味闭门造车只会逐渐被时代所淘汰。 前几天查看博客与邮箱，发现很多朋友发的邮件或者博客留言，由于最近几年一直忙于工作，所以没有及时一一回复，在此也统一表示抱歉，希望后面有更多的时间来回答各位的问题。 也有朋友想了解新加坡IT现状和薪酬情况，我觉得三言两语可能无法完全讲
Qt4.7官方白皮书
08-31
- **并发编程**：通过QThread类和相关API，开发者可以轻松地创建和管理线程。 #### Desktop Integration - **桌面集成**：为了让应用程序更好地融入操作系统环境，Qt提供了与桌面环境紧密集成的功能，如托盘图标、...
高并发编程（Thread API的详细介绍）
sunny_daily的博客
02-23 288
Thread对象的线程API有sleep、TimeUnit、yield、interrupt等方法，具体方法和使用逻辑可以参考知乎：高并发编程（Thread API的详细介绍） - 知乎。
java高级（并发编程）
小趴菜不能喝的博客
05-26 640
，这个类在java.util.concurrent.locks包下面。
高级技术之 JUC 高并发编程
wa_ka_ka的博客
08-25 850
1，什么是 JUC 1.1 JUC简介 JUC 就是java.util.concurrent 工具包的简称，这一个专门用来处理线程的工具包，JDK1.5开始出现 1.2 进程与线程 **进程（Process）：**是系统进行资源分配和调度的基本单位，比如QQ启动就是一个进程。 **线程（Thread）：**是操作系统能够进行运算调度的最小单位，是程序执行的最小单位，它被包含在进程中，比如QQ中的各个功能，都是不同的线程。 1.3 线程的状态 在Thread类中枚举了线程的6种状态; pu
高并发编程学习(1)——并发基础
WantFlyDaCheng的博客
11-29 234
一、前言当我们使用计算机时，可以同时做许多事情，例如一边打游戏一边听音乐。这是因为操作系统支持并发任务，从而使得这些工作得以同时进行。那么提出一个问题：如果我们要实现一个程序能一边听音乐...
线程池自定义异常处理方法
09-11 656
// 线程工厂，用于为线程池中的每条线程命名 ThreadFactory namedThreadFactory = new ThreadFactoryBuilder() .setNameFormat("judge-pool-%d") .setUncaughtExceptionHandler((thread, throwable)-> logger.error("ThreadPool {} got exception", thread,t.
【java学习】多线程之高并发编程：线程&任务&启动任务
午后阳光
01-24 4245
1，synchronized（同步块）（1）概念用synchronized 关键字来实现同步块，所有加上synchronized 的块语句，在多线程访问的时候，同一时刻只能有一个线程能够访问，另一个线程必须等到当前线程访问完毕才能访问此代码块，解决了多线程的安全问题。即：加锁。（2）缺陷多个线程判断锁，耗费资源，降低代码执行效率。（3）作用①实现操作的原子性什么是原子性？原子操作即：不可分割的单一的...............
【java高并发核心编程】
weixin_44933612的博客
08-03 1153
java高并发核心编程 第一章 多线程原理与实战 1.2　无处不在的进程和线程 什么是进程呢？简单来说，进程是程序的一次启动执行。什么是程序呢？程序是存放在硬盘中的可执行文件，主要包括代码指令和数据。一个进程是一个程序的一次启动和执行，是操作系统将程序装入内存，给程序分配必要的系统资源，并且开始运行程序的指令。 进程与程序是什么关系呢？同一个程序可以多次启动，对应多个进程。比如，多次打开Chrome浏览器程序，在ProcessExplorer中可以看到多个Chrome浏览器进程。 1.2.1　进程的基本
VC++入门：Hello World程序与GDI图形编程基础
4. 应用程序实例化与执行：创建项目后，通过Build菜单下的Executive选项构建hello.exe程序。这将自动生成必要的开始文件，并打开项目工作区，以便进行调试和运行。运行Hello程序时，可以看到图形设备接口在其中的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值