当前位置： 首页 > article >正文

Java并发编程框架之第三方库

article 2025/1/18 10:53:03

山有顶峰 海有彼岸
泰戈尔曾说："不要着急，最好的总会在最不经意的时候出现，所以不必慌张地去赶路，按自己的节奏，步履不停地走过每个今天。"即使觉得孤军奋战的夜晚漫长又烦闷，你也必须独自熬过这样的夜晚。只有熬得住无人问津的寂寞，才配拥有诗和远方。
正如杨绛先生说得那样："把圈子变小，把语速放缓，把心放宽，把生活打理简单。用心做好手边的事情，不恋尘世浮华，不被红尘纷扰；看天上的月，吹人间的风。过着平常的日子，该有的，总会有。"
静下心来 沉淀自己

目录

第三方库在并发编程中的应用

Guava中的ListenableFuture

Akka Actor模型

RxJava反应式扩展

其他优秀的并发编程库

1. Quasar：Java协程与通道

2. libco：C++协程库

3. MILL：C语言协程库

4. Rayon：Rust 并发库

第三方库在并发编程中的应用

除了Java标准库提供的丰富并发工具外，还有许多第三方库专注于特定领域的问题解决，并可能带来额外的功能或性能优势。以下是几个值得注意的第三方库及其特点：

Guava中的ListenableFuture

Guava 是 Google 开发的一套 Java 库集合，它扩展了 Java 标准库的功能。其中 ListenableFuture 接口是对 JDK 中 Future 接口的一种增强. 它允许开发者注册回调函数，在结果计算完成时自动触发这些回调。这意味着可以避免阻塞主线程等待任务完成，而是通过非阻塞的方式处理任务的结果。这不仅提高了程序的响应速度，还简化了异步编程模型。

import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.MoreExecutors;
import com.google.common.util.concurrent.Futures;
import java.util.concurrent.Callable;
import java.util.concurrent.Executors;

public class ListenableFutureExample {
    public static void main(String[] args) {
        // 创建一个线程池并装饰为 ListeningExecutorService
        var execService = MoreExecutors.listeningDecorator(Executors.newSingleThreadExecutor());

        // 提交一个异步任务
        ListenableFuture<String> future = execService.submit((Callable<String>) () -> {
            try {
                Thread.sleep(1000); // 模拟耗时操作
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            return "Hello, World!";
        });

        // 添加成功和失败的回调
        Futures.addCallback(future, new FutureCallback<String>() {
            @Override
            public void onSuccess(String result) {
                System.out.println("Task succeeded with result: " + result);
            }

            @Override
            public void onFailure(Throwable t) {
                System.err.println("Task failed with exception: " + t.getMessage());
            }
        }, MoreExecutors.directExecutor());
    }
}

这段代码展示了如何使用 ListenableFuture 来执行一个异步任务，并在其完成后调用相应的回调函数。

Akka Actor模型

Akka 是一个构建在 JVM 上的并发框架，基于 Actor 模型实现了轻量级事件处理机制。Actor 模型是一种并发编程范式，其中 Actors 是基本的计算单元，它们之间通过消息传递来通信，而不是共享内存。每个 Actor 都有自己的状态、行为以及邮箱（MailBox），用于接收来自其他 Actors 的消息。这种设计使得 Actors 可以独立运行并且易于扩展到分布式系统中。

import akka.actor.{Actor, ActorSystem, Props}

class BankActor extends Actor {
  var balance = 0

  def receive = {
    case "ADD" =>
      balance += 1
      println(s"Balance after adding: $balance")
    case "MINUS" =>
      if (balance > 0) balance -= 1
      println(s"Balance after subtracting: $balance")
    case "GET" =>
      sender() ! balance
  }
}

object AkkaExample extends App {
  val system = ActorSystem("bank-system")
  val bankActor = system.actorOf(Props[BankActor], name = "bank-actor")

  // 发送消息给 actor
  bankActor ! "ADD"
  bankActor ! "ADD"
  bankActor ! "MINUS"

  // 请求当前余额
  import scala.concurrent.duration._
  import akka.pattern.ask
  import akka.util.Timeout
  implicit val timeout = Timeout(5 seconds)
  val future = bankActor ? "GET"
  future.mapTo[Int].foreach(balance => println(s"Final balance: $balance"))

  // 关闭系统
  system.terminate()
}

此示例说明了如何创建一个简单的银行账户模拟器，利用 Akka 的 Actor 系统来进行存款、取款及查询余额的操作。

RxJava反应式扩展

RxJava 是 ReactiveX 规范的一个 Java 实现，旨在提供一致的编程接口帮助开发者更方便地处理异步数据流。它结合了观察者模式、迭代器模式与函数式编程的优点，使编写异步代码变得更加直观和简洁。RxJava 支持多种操作符，如 map、filter、flatMap 等，可以轻松地对事件序列进行转换、过滤和组合。

import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.disposables.Disposable;

public class RxJavaExample {
    public static void main(String[] args) {
        // 创建一个 Observable 并订阅 Observer
        Disposable disposable = Observable.just("Hello", "Reactive", "World")
                                          .subscribe(System.out::println);

        // 清理资源
        disposable.dispose();
    }
}

在这个例子中，我们创建了一个 Observable 对象，它可以发出一系列字符串事件，并通过 subscribe 方法将这些事件传递给 Observer 进行处理。

综上所述，上述提到的第三方库各自针对不同的应用场景提供了强大的功能支持。无论是需要更好的异步任务管理（如 Guava 的 ListenableFuture）、高效的并发处理（如 Akka 的 Actor 模型），还是流畅的数据流操作（如 RxJava），都可以找到合适的解决方案。选择合适的库可以帮助开发人员更加高效地解决问题，并且通常伴随着更好的性能表现。

其他优秀的并发编程库

除了上述提到的第三方库，如Guava中的ListenableFuture、Akka Actor模型以及RxJava反应式扩展之外，还有许多其他优秀的并发编程库值得开发者关注。这些库不仅提供了丰富的功能，而且往往在特定领域内拥有卓越的表现。以下是几个额外的例子：

1. Quasar：Java协程与通道

Quasar 是一个专门为 Java 开发者设计的高性能、轻量级线程处理库。它融合了 Go 语言的 Channel 模型与 Erlang 语言的 Actor 模式的优点，致力于简化并发编程的复杂性。通过 Quasar，开发者可以在 Java 中享受到类似 Go 的 goroutine 和 channel 的便利，从而更轻松地构建高并发应用程序。

  • 特性:
    • 支持非阻塞 I/O 操作。
    • 提供了类似于 Go 的 select 语句来处理多个通道上的事件。
    • 可以创建大量轻量级线程（fibers），比操作系统级别的线程更加节省资源。
import co.paralleluniverse.fibers.Fiber;
import co.paralleluniverse.strands.channels.Channel;

public class QuasarExample {
    public static void main(String[] args) throws InterruptedException {
        Channel<String> channel = new Channel<>();
        
        // 创建并启动一个 fiber 来发送消息
        Fiber<Void> sender = new Fiber<>(() -> {
            channel.send("Hello from fiber!");
        });
        sender.start();
        
        // 接收来自 fiber 的消息
        String message = channel.receive();
        System.out.println(message);
    }
}
2. libco：C++协程库

libco 是由腾讯开源的一款轻量级协程库，适用于 C++ 程序员。它为开发者提供了一种优雅的方式来处理大规模并发场景，无需传统线程上下文切换所带来的高昂开销。该库的核心技术在于其底层实现——coctx_swap.S 文件中编写的协程切换函数，利用硬件级别的支持实现了几乎零成本的上下文切换。

  • 应用场景:
    • 构建高性能服务器，如 HTTP、TCP 服务。
    • 实时系统，如游戏服务器。
    • I/O 密集型应用，如数据库连接池。
#include "libco.h"

void coroutine_func(void *arg) {
    printf("Coroutine started\n");
    co_yield(co_self()); // 让出执行权给调度器
    printf("Coroutine resumed\n");
}

int main() {
    co_context_t *main_co = co_self();
    co_context_t *co = co_create(0, coroutine_func, NULL);
    co_resume(co); // 启动协程
    co_resume(co); // 再次恢复协程
    return 0;
}
3. MILL：C语言协程库

MILL 是专为 C 语言设计的一种并发控制库，借鉴了 Go 语言的并发机制，使得开发者能够在 C 环境中轻松实现并发操作。MILL 引入了两个关键概念——协程（coroutine）和通道（channel），允许程序员更简单地创建、管理和同步多线程应用，极大地提高了程序效率与响应速度。

  • 特点:
    • 使用 Go 风格的 API 进行并发编程。
    • 强调与现有 C 标准库及其他第三方库的良好兼容性。
    • 提供了简单易用的数据交换接口，如 mill_send() 和 mill_recv()。
#include <stdio.h>
#include <mill.h>

void worker(int count, channel c) {
    for (int i = 0; i < count; ++i) {
        mill_send(c, &i); // 向通道发送数据
        printf("Worker: Sent %d\n", i);
    }
    int end_signal = -1;
    mill_send(c, &end_signal); // 发送结束信号
}

int main() {
    int num_tasks = 5;
    channel c = mill_channel_create(sizeof(int)); // 创建一个整型数据的通道
    
    coroutine t1 = mill_coroutine_create(worker, num_tasks, c);
    coroutine t2 = mill_coroutine_create(worker, num_tasks, c);
    
    int value;
    while ((value = *(int*)mill_recv(c)) != -1) {
        printf("Main: Received %d\n", value);
    }
    
    mill_coroutine_destroy(t1);
    mill_coroutine_destroy(t2);
    mill_channel_destroy(c);
    return 0;
}
4. Rayon：Rust 并发库

对于 Rust 开发者来说，Rayon 是一个非常流行的并发库。它基于工作窃取调度算法，能够自动将任务分解成多个子任务，并分配给不同的 CPU 核心进行并行处理。Rayon 提供了简单的 API 来表达数据并行性和任务并行性，同时保证了内存安全，这得益于 Rust 的所有权系统、借用规则等特性。

  • 优势:
    • 易于使用的并行迭代器。
    • 支持并行 map/reduce 操作。
    • 自动负载均衡，减少空闲时间。
use rayon::prelude::*;

fn main() {
    let data = vec![1, 2, 3, 4, 5];
    let sum: i32 = data.par_iter().sum(); // 并行计算总和
    println!("Sum is {}", sum);
}

综上所述，以上列举的第三方库各自针对不同的编程语言和应用场景提供了强大的并发编程能力。无论是需要高效的协程管理（如 libco 或 MILL）、简洁的通道通信（如 Quasar），还是自动化的数据并行处理（如 Rayon），都可以找到合适的解决方案。选择适当的工具可以帮助开发人员更有效地解决问题，并且通常伴随着更好的性能表现。此外，随着技术的发展，新的并发编程库也在不断涌现，持续探索最新的工具和技术总是有益的.


http://www.kler.cn/a/442357.html

相关文章：

  • 网络IO与IO多路复用
  • Spring Boot Actuator 详细介绍
  • 以太网实战AD采集上传上位机——FPGA学习笔记27
  • 【物联网】ARM核介绍
  • vue3+vite+ts+router4+Pinia+Axios+sass 从0到1搭建
  • nginx 实现 正向代理、反向代理 、SSL（证书配置）、负载均衡 、虚拟域名 ，使用其他中间件监控
  • eclipse 如何设置项目、不同类型文件的 utf8 编码
  • 如何与GPT更高效的问答
  • xxl-job 整合 Seatunnel 实现定时任务
  • Bootstrap Blazor中使用PuppeteerSharp对HTML截图
  • 【嵌入式——QT】QT多线程编程
  • Halcon中dots_image(Operator)算子原理及应用详解
  • JumpServer开源堡垒机搭建及使用
  • 基于yolov10的遥感影像目标检测系统，支持图像检测，视频检测和实时摄像检测功能（pytorch框架，python源码）
  • 计算机网络技术基础：3.计算机网络的拓扑结构
  • 从零开始学TiDB（5）Raft与Multi Raft
  • 【Java】使用RSA进行数字签名详解（复制即用，内有详细注释）
  • 用 Python 从零开始创建神经网络（十七）：回归（Regression）
  • 小程序转uniapp之setData
  • RabbitMQ镜像队列机制
  • 【WRF教程第3.4期】预处理系统 WPS 详解：以4.5版本为例
  • python IO编程：序列化
  • android 计算CRC
  • Windows开机黑屏|Windows开机黑屏只有鼠标|Windows开机不运行explorer
  • vue3实现商城系统详情页（前端实现）
  • 面试真题 | 虎牙 C++[20241218]