Akka基本使用总结

最新推荐文章于 2024-05-21 02:54:21 发布
最新推荐文章于 2024-05-21 02:54:21 发布
阅读量2.6k 收藏 11
点赞数
文章标签： spark flink tcp/ip
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dream_xin2013/article/details/133321028
版权

1、什么是akka

akka是一个构建高并发、分布式、可容错、事件驱动的开发库，它可以使构建高并发分布式应用更加容易。

akka的特性：

  1. 易于构建并行和分布式应用： akka的核心组件是actor，actor被设计成独立的，每个actor之间互相不影响，没有了线程间资源共享的问题。
  2. 可靠性： akka中的actor之间有层级关系，actor有专门的进程监护。
  3. 高性能： actor占用内存非常小，1GB内存中可以保存上百万的actor，相对于传统的线程模型有很高的性能提升，java21已经推出了虚拟线程也可以支持海量任务处理了。

2、什么是actor

actor可以理解为做事情的，当系统收到一个需要处理的任务时，就会交给actor进行处理，actor具有层级关系，是一个树形结构，父节点负责子actor的创建、销毁和状态管理，在akka中，所有actor的根是ActorSystem，在系统中，ActorSystem需要被设计成单例模式。

3、使用案例

在使用时，要注意akka的版本，高版本中的一些api与低版本的api并不通用（大版本号好像是2.6），这里需要注意。目前很多软件都是使用低版本的api，这里就总结一些低版本api的使用：

需求如下：计算两个数的加减乘除，master端提供两个数和运算符，将任务提交到worker端进行计算，worker端按照要求将计算结果返回给master端。

  1. 引入依赖：
<!-- 基础actor依赖 -->
<dependency>
    <groupId>com.typesafe.akka</groupId>
    <artifactId>akka-actor_2.11</artifactId>
    <version>2.3.15</version>
</dependency>
<!-- 集群依赖 -->
<dependency>
    <groupId>com.typesafe.akka</groupId>
    <artifactId>akka-cluster_2.11</artifactId>
    <version>2.3.15</version>
</dependency>
<!-- 远程调用依赖 -->
<dependency>
    <groupId>com.typesafe.akka</groupId>
    <artifactId>akka-remote_2.11</artifactId>
    <version>2.3.15</version>
</dependency>
  1. 构建一个公用类：存储两个数、运算符、运算结果，类结构如下：
import java.io.Serializable;

public class MathCalculate implements Serializable {

    /**
     * 数字1
     */
    private int num1;
    /**
     * 数字2
     */
    private int num2;
    /**
     * 计算结果
     */
    private int result;
    /**
     * 操作类型
     */
    private OperateEnum type;
    /**
     * 计算结果对应的运算符
     */
    private String op;

    public MathCalculate() {
    }

    public MathCalculate(int result, OperateEnum type) {
        this.result = result;
        this.type = type;
    }

    public MathCalculate(int num1, int num2, OperateEnum type) {
        this.num1 = num1;
        this.num2 = num2;
        this.type = type;
    }

    public MathCalculate(int num1, int num2, int result, OperateEnum type) {
        this.num1 = num1;
        this.num2 = num2;
        this.result = result;
        this.type = type;
    }

    public int getNum1() {
        return num1;
    }

    public void setNum1(int num1) {
        this.num1 = num1;
    }

    public int getNum2() {
        return num2;
    }

    public void setNum2(int num2) {
        this.num2 = num2;
    }

    public int getResult() {
        return result;
    }

    public void setResult(int result) {
        this.result = result;
    }

    public OperateEnum getType() {
        return type;
    }

    public void setType(OperateEnum type) {
        this.type = type;
    }

    public String getOp() {
        return op;
    }

    public void setOp(String op) {
        this.op = op;
    }

    public static enum OperateEnum {
        ADD("+"),
        SUBTRACT("-"),
        MULTIPLY("*"),
        DIVIDE("/"),
        RESULT("="),
        ;

        private String val;

        OperateEnum(String val) {
            this.val = val;
        }

        public String getVal() {
            return val;
        }
    }
}
  1. master端：master端创建一个akka环境，指定服务地址和端口号，并继承Actor用于处理结果信息：

master端的actor内容：

import akka.actor.UntypedActor;
import com.alibaba.fastjson.JSONObject;

public class MasterResultActor extends UntypedActor {

    @Override
    public void preStart() throws Exception {
        System.out.println("MasterResultActor invoker");
    }

    @Override
    public void onReceive(Object message) {
        MathCalculate math = null;
        if(message instanceof String) {
            String json = (String) message;
            math = JSONObject.parseObject(json, MathCalculate.class);
        } else if(message instanceof MathCalculate) {
            math = (MathCalculate) message;
        }

        System.out.println("calculate result: " + math.getNum1() + " " + math.getOp() + " " + math.getNum2() + " = " + math.getResult());
    }
}

master端的主类内容：

import akka.actor.ActorRef;
import akka.actor.ActorSelection;
import akka.actor.ActorSystem;
import akka.actor.Props;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;

import java.util.HashMap;
import java.util.Map;

public class MasterCalculateTest {

    public static void main(String[] args) {
        Map<String, Object> propMap = new HashMap<>();
        propMap.put("akka.actor.provider", "akka.remote.RemoteActorRefProvider");
        propMap.put("akka.remote.netty.tcp.hostname", "127.0.0.1");
        propMap.put("akka.remote.netty.tcp.port", 8989);

        Config config = ConfigFactory.parseMap(propMap);
        ActorSystem system = ActorSystem.create("master-server", config);
        ActorRef masterActor = system.actorOf(Props.create(MasterResultActor.class), "master-actor");

        ActorSelection actorSelection = system.actorSelection("akka.tcp://math-worker@127.0.0.1:8899/user/worker-actor");
        for(int i =0; i < 5; i++) {
            final int num = i;
            new Thread(() -> actorSelection.tell(new MathCalculate(num, num, MathCalculate.OperateEnum.ADD), masterActor)).start();
        }
    }
}
  1. worker端：worker端也需要创建一个akka环境，用于接收master端的任务，并且创建一个actor用于计算任务结果：

worker端的actor内容：

import akka.actor.UntypedActor;
import com.alibaba.fastjson.JSONObject;

public class WorkerCalculateActor extends UntypedActor {

    @Override
    public void onReceive(Object message) {
        // System.out.println("sender info : " + getSender().path().toString());

        MathCalculate math = null;
        if(message instanceof String) {
            String json = (String) message;
            math = JSONObject.parseObject(json, MathCalculate.class);
        } else if(message instanceof MathCalculate) {
            math = (MathCalculate) message;
        }

        if(math != null) {
            int result = 0;
            switch (math.getType()) {
                case ADD:
                    result = math.getNum1() + math.getNum2();
                    break;
                case SUBTRACT:
                    result = math.getNum1() - math.getNum2();
                    break;
                case DIVIDE:
                    result = math.getNum1() / math.getNum2();
                    break;
                case MULTIPLY:
                    result = math.getNum1() * math.getNum2();
                    break;
                case RESULT:
                    result = math.getResult();
                    break;
            }

            if(math.getType() != MathCalculate.OperateEnum.RESULT) {
                MathCalculate rs = new MathCalculate(math.getNum1(), math.getNum2(), result, MathCalculate.OperateEnum.RESULT);
                rs.setOp(math.getType().getVal());
                getSender().tell(rs, this.getSelf());

                System.out.println("worker calculator: " + math.getNum1() + " " + math.getType().getVal() + " " + math.getNum2() + " = " + result);
            }
        }
    }
}

worker端的主类：

import akka.actor.ActorSystem;
import akka.actor.Props;
import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;

import java.util.HashMap;
import java.util.Map;

public class MathWorkerTest {

    public static void main(String[] args) {
        Map<String, Object> propMap = new HashMap<>();
        propMap.put("akka.actor.provider", "akka.remote.RemoteActorRefProvider");
        propMap.put("akka.remote.netty.tcp.hostname", "127.0.0.1");
        propMap.put("akka.remote.netty.tcp.port", 8899);
        Config config = ConfigFactory.parseMap(propMap);

        ActorSystem system = ActorSystem.create("math-worker", config);
        system.actorOf(Props.create(WorkerCalculateActor.class), "worker-actor");
    }
}

上面就是一个akka使用示例，运行示例代码首先启动worker端，等待master端下发任务进行计算，当worker端收到任务并生成计算结果了，在将计算结果返回给master，在这个过程中，都是通过 tell 方法进行交互的。

4、相关api介绍

4.1 actor的获取

在使用akka框架时，最重要的就是actor的创建和调用，下面总结一下都可以通过哪些api可以获取到actor：

1、通过 ActorSystem 的 actorOf() 方法获取到actor，这个api是将一个actor实例化并将它注入到系统中，这样他就可以被本地或远程调用了：

ActorSystem system = ActorSystem.create("master-server", config);
ActorRef masterActor = system.actorOf(Props.create(MasterResultActor.class), "master-actor");

2、通过 ActorSystem 的 actorSelection() 方法获取actor，这种方法可以获取到一个已经注入到系统中的actor或一个远程的actor，通过该actor就可以发送任务：

ActorSystem system = ActorSystem.create("master-server", config);
ActorSelection actorSelection = system.actorSelection("akka.tcp://math-worker@127.0.0.1:8899/user/worker-actor");

3、在actor实例内部，可以通过 this.getContext() 获取到应用的上下文，通过上下文环境像 ActorSystem 一样也可以创建actor：

ActorRef actor1 = this.getContext().actorOf(Props.create(MasterResultActor.class), "actor-name1");
ActorSelection actor2 = this.getContext().actorSelection("akka.tcp://math-worker@127.0.0.1:8899/user/worker-actor");

4、在actor实现类内部，可以获取到自身actor或消息发送者actor：

ActorRef self = this.getSelf();
ActorRef sender = this.getSender();

4.2 tell()方法

在akka中进行服务间通信，需要调用actor的tell方法：

remoteActor.tell("Hello,world!", localActor);

这里的remoteActor就是要调用的远程actor，localActor是本地actor，当远端执行完成后，就可以在里面调用this.getSender()获取到它，将结果通知回来。

4.3 远程url结构

在akka中调用远程actor时，就需要构建远程actor的链接，它的格式大概如下：

"akka.tcp://math-worker@127.0.0.1:8899/user/worker-actor"

akka.tcp ： 这个格式是固定的协议头部。

math-worker ： 这个是不确定的，它其实就是ActorSystem创建时指定的名称，如果名称不同在构建url时也要进行相应的修改。

127.0.0.1:8899 ： 这个是服务的IP和端口号，在构建ActorSystem时指定。

/user/ ： 固定格式。

worker-actor ： 注册ActorRef时指定的actor名称，actor就是根据这个名称查找。

腊笔不小新xingo
关注
  • 0
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【akka】初识Akka 简单介绍
九师兄
11-05 886
Akka是一个用来开发支持并发、容错、扩展性的应用程序框架，基于actor模式的实现。在actor模型的上下文中，所有的活动实体都被认为是互不依赖的actor，actor之间的互相通信是通过彼此之间发送异步消息来实现的。每个actor都有一个邮箱（Mailbox）来存储接收到的消息，因此每个actor都维护着自己独立的状态。
【项目实战】分布式计算和通信框架（AKKA）入门介绍
本本本添哥
03-20 4414
Actor模型是一种并发编程模型，它将计算机系统中的并发实体抽象为Actor，每个Actor都是一个独立的计算单元，它们之间通过消息传递进行通信。Actor之间的通信是异步的，无需共享内存，因此可以避免共享内存带来的并发问题。Actor模型可以轻松地编写出高并发、分布式、可容错的应用程序，因此被广泛应用于分布式系统和并发编程领域。
akka介绍
热门推荐
码农的世界你不懂
02-20 5万+
akka简介    一开始想接触到akka，是在看一些并发相关资料的时候，查了下akka的官方介绍，介绍如下：Akka是一个开发库和运行环境，可以用于构建高并发、分布式、可容错、事件驱动的基于JVM的应用，使构建高并发的分布式应用更加容易。 听到高并发和分布式这两个关键字就已经足够让人想去探索究竟是什么样的框架，当深入查看各种资料后，发现当前大数据领域火热的spark、flink底层的分布式计...
分布式应用框架Akka快速入门
xidajiancun
12-11 1302
转载请注明出处：http://blog.csdn.net/jmppok/article/details/17264495 本文结合网上一些资料，对他们进行整理，摘选和翻译而成，对Akka进行简要的说明。引用资料在最后列出。 1.什么是Akka Akka 是一个用 Scala 编写的库，用于简化编写容错的、高可伸缩性的 Java 和 Scala 的 Actor 模型应用。 官方网站 （htt...
Akka集群原理与代码实例讲解
最新发布
AI大模型应用之禅
05-21 309
1. 背景介绍 1.1 分布式系统的挑战 随着互联网的快速发展，应用系统越来越复杂，对系统的性能、可靠性、可扩展性等方面的要求也越来越高。传统的单体架构已经无法满足这些需求，分布式系统成为了必然的选择。然而，构建分布式系统并非易事，它面临着诸多挑战，例如：
Akka入门
bao2901203013的专栏
04-06 1579
Akka是一个异步非阻塞高并发处理框架，它是一系列框架，包括akka-actor, akka-remote, akka-cluster, akka-stream等，分别具有高并发处理模型——actor模型，远程通信，集群管理，流处理等功能。
Flink通讯模型—Akka与Actor模型
weixin_51981189的博客
03-14 1444
也就是说，它可以被分配，分布，调度到不同的CPU，不同的节点，乃至不同的时间片上运行，而不影响最终的结果。尽管单个的actor是自然有序的，但一个包含若干个actor的系统却是高度并发的并且极具扩展性的。actor线程顺序处理收到的消息。3）call stack的问题 当我们编程模型异步化之后，还有一个比较大的问题是调用栈转移的问题，如下图中主线程提交了一个异步任务到队列中，Worker thread 从队列提取任务执行，调用栈就变成了workthread发起的，当任务出现异常时，处理和排查就变得困难。
Akka教程——1、Akka简介
wu_xiaozhi_xiao的博客
06-15 1290
否则，哪怕 Go语言运行时使用多个线程，goroutine 依然会在同一个物理处理器上并发运行，达不到并行的效果。下图展示了在一个逻辑处理器上并发运行 goroutine 和在两个逻辑处理器上并行运行两个并发的 goroutine 之间的区别。调度器包含一些聪明的算法，这些算法会随着 Go语言的发布被更新和改进，所以不推荐盲目修改语言运行时对逻辑处理器的默认设置。在很多情况下，并发的效果比并行好，因为操作系统和硬件的总资源一般很少，但能支持系统同时做很多事情。
Akka（一）：Akka的基本使用
Yuan_CSDF的博客
07-24 8097
1.akka是什么? akka是一种基于Scala的网络编程库，实现了RPC框架。spark在1.6之前使用的是akka进行通信，1.6及以后是基于netty。现阶段的Flink是基于Akka+Netty。如果需要了解Spark或者Flink的网络通信，就必须得从akka开始。 2.Akka中的方法 主类是在akka.actor.Actor，Endpoint 有三个重要的声明周期方法： prestart()：对象实例初始化之后自动执行 receive()： 核心业务...
Akka简介
heihei_100的博客
03-19 6816
虽然Akka基于Scala而非Java语言编写而成，但由于Scala最终还是被编译为Java字节码并运行在JVM之上，所以我们可以认为Akka属于Java领域。Akka官方对Akka的介绍如下。● 是对并发、并行程序的简单的高级别的抽象。 ● 是异步、非阻塞、高性能的事件驱动编程模型。 ● 是非常轻量的事件驱动处理机制（1GB内存可容纳约270万个Actor）。 我们知道，一个实际的Actor系统是由许多个Actor实例组成的一个复杂的树状结构，父Actor负责子Actor的生命周期并对它们实施必要的
Akka 学习（九）Akka Cluster
长安不及十里的博客
12-12 3792
CAP理论是由Eric Brewer提出的，指的是一个分布式系统中的一致性（Consistency）、可用性（Availability）和分区容错性（Partition tolerance）之间的一个权衡。在分布式系统中，这三个概念是相互矛盾的，因此，系统必须在这三个概念之间进行权衡，以确定在特定情况下采取哪种策略。例如，在一个分布式系统中，如果要同时保证一致性和可用性，就必须牺牲分区容错性。
codes-scratch-akka:akka学习理解，使用了maven、sbt两种构建方式，同时使用量java和scala两种语言实现。akka入门，清晰理解akka流程
05-01
总结，这个项目提供了一个 Akka 入门的实践平台，涵盖了从基础的 Actor 模型到构建工具的使用，再到 Java 和 Scala 语言的结合实践。通过这个项目，开发者不仅可以学习 Akka 的核心概念，还能了解到如何在实际项目中...
akka-typed
03-30
**Akka Typed 基本概念** 1. **Actor**: 在 Akka 中，Actor 是并发的基本单元，它们通过消息传递进行通信。每个 Actor 都有自己的邮箱，用于接收和处理消息。Akka Typed 强制所有消息都具有特定的类型，从而确保了...
gossip-girl:实时同步服务器，使用 Akka & Redis
06-30
这个模板包含基本的配置和依赖，使得开发者能够轻松地开始构建自己的Akka应用。通过这个种子项目，我们可以看到Akka如何帮助构建一个可以处理大量并发事件的系统。 接下来，我们转向Redis。Redis是一个高性能的键值...
akka-java-sample:Akka Java快速入门示例
05-18
在Java中使用Akka，我们需要创建`ActorSystem`，它是整个Akka应用的入口点，然后创建和配置Actors。Akka的Java API设计得尽可能简洁，使得Java开发者能轻松理解和使用。 **快速入门步骤** 1. **创建ActorSystem**:...
akka-clustering-ndc
05-13
Akka是一个用于构建高度并发、分布式和反应式应用程序的开源框架，主要使用Scala和Java编写，但同样支持F#。在Akka中，群集（Cluster）是实现分布式系统的关键组件，它允许节点之间进行通信并共享状态。本篇文章将...
Akka 深度指南：分布式计算的新星
gitblog_00044的博客
04-26 346
Akka 深度指南：分布式计算的新星 项目地址:https://gitcode.com/guobinhit/akka-guide Akka 是一个由 Lightbend 公司维护的开源框架，它提供了一种强大的工具包，用于构建高度并发、分布式的系统。这款基于 Actor 模型和 Scala、Java API 的框架，旨在解决现代云计算环境中的复杂性问题，让用户能够轻松地创建高效、容错的应用程序。 技...
akka集群结构、节点发现机制
qq_45888242的博客
12-30 1189
Akka 在k8s中，通过 Kubernetes API 形成集群的过程
推荐：开启分布式系统新篇章——《Akka实战》开源代码库
gitblog_00069的博客
05-17 379
推荐：开启分布式系统新篇章——《Akka实战》开源代码库 项目地址:https://gitcode.com/RayRoestenburg/akka-in-action 1. 项目介绍 akka-in-action 是一本名为《Akka实战》的书籍的配套源码仓库。这本书深入浅出地介绍了如何利用Akka框架构建强大而可靠的并发与分布式应用。这个开源项目为读者提供了实践案例和示例代码，帮助理论知识落地，...
Flink 中akka的使用
03-31
Apache Flink是一个分布式数据处理引擎，它支持多种数据处理模式和场景。在Flink中使用Akka可以帮助我们更好地管理分布式系统中的状态和通信。 Akka是一个用于构建高度并发、分布式和容错应用程序的工具包。它提供了一个Actor系统，通过Actor进行通信，可以更好地处理并发和容错问题。 在Flink中使用Akka，可以通过以下步骤实现： 1. 引入Akka库 在Flink的pom.xml文件中添加以下Akka相关的依赖： ``` <dependency> <groupId>com.typesafe.akka</groupId> <artifactId>akka-actor_2.11</artifactId> <version>2.4.0</version> </dependency> <dependency> <groupId>com.typesafe.akka</groupId> <artifactId>akka-remote_2.11</artifactId> <version>2.4.0</version> </dependency> ``` 2. 创建ActorSystem 在Flink的程序入口处，创建一个ActorSystem： ``` val actorSystem = ActorSystem("flink-actor-system") ``` 3. 创建Actor 在ActorSystem中创建一个Actor： ``` class MyActor extends Actor { def receive = { case "hello" => println("hello") case _ => println("unknown message") } } val myActor = actorSystem.actorOf(Props[MyActor], "my-actor") ``` 4. 发送消息 在Flink的处理逻辑中，可以通过发送消息的方式与Actor进行通信： ``` myActor ! "hello" ``` 以上就是在Flink中使用Akka的基本流程。需要注意的是，在分布式环境中，需要配置Akka的远程通信参数。具体可以参考Akka官方文档。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值