Actor通信系统

Flink中组件间的通信都是通过Actor通信系统，下面学习下Actor并发编程模型。
Actor并发编程模型在Java的Akka并发框架中得以实现。

Actor：Actor是独立的计算单元，拥有自己的状态和行为。每个actor可以：

• 接收消息。

  • 处理收到的消息。
  • 发送消息给其他actor。
  • 创建新的actor。

• 消息传递：Actor之间通过异步消息传递进行通信。消息传递是非阻塞的，每个actor有自己的消息队列，收到的消息会被排队，逐个处理。

• 无共享状态：每个actor都有自己的独立状态，actor之间不共享状态，从而避免了传统并发编程中的锁机制和竞争条件。

• 自治性：Actor是自主的实体，它们只对接收到的消息做出反应，并根据消息的内容改变自己的状态或行为。

Actor模型的优势

• 高并发性：由于actor之间的通信是异步的，并且actor独立处理自己的消息，系统可以很好地处理大量并发任务。

• 可扩展性：Actor模型可以很容易地扩展到多个节点上运行，适合分布式系统。

• 容错性：通过actor监督策略，可以在actor发生错误时采取相应的恢复措施，提高系统的容错能力。

• 简化并发编程：Actor模型通过消息传递和无共享状态，避免了传统并发编程中的锁和竞争条件，简化了编程和调试。

示例HelloActor，它可以接收并响应消息：
maven依赖：

<dependencies>
    <dependency>
        <groupId>com.typesafe.akka</groupId>
        <artifactId>akka-actor_2.13</artifactId>
        <version>2.6.19</version>
    </dependency>
</dependencies>

HelloActor.java

import akka.actor.AbstractActor;
import akka.actor.ActorRef;
import akka.actor.Props;

public class HelloActor extends AbstractActor {

    static public Props props() {
        return Props.create(HelloActor.class, () -> new HelloActor());
    }

    static public class Greet {
        public final String who;

        public Greet(String who) {
            this.who = who;
        }
    }

    @Override
    public Receive createReceive() {
        return receiveBuilder()
                .match(Greet.class, greet -> {
                    System.out.println("Hello, " + greet.who);
                    // 发送回复消息
                    getSender().tell(new Response("Hello, " + greet.who), getSelf());
                })
                .build();
    }

    static public class Response {
        public final String message;

        public Response(String message) {
            this.message = message;
        }
    }
}

Main.java负责创建Actor系统并向HelloActor发送消息：

import akka.actor.ActorRef;
import akka.actor.ActorSystem;

public class Main {
    public static void main(String[] args) {
        // 创建Actor系统
        final ActorSystem system = ActorSystem.create("hello-akka");

        try {
            // 创建HelloActor
            final ActorRef helloActor = system.actorOf(HelloActor.props(), "helloactor");

            // 向HelloActor发送Greet消息
            helloActor.tell(new HelloActor.Greet("World"), ActorRef.noSender());

            // 等待几秒以便消息处理完成
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 关闭Actor系统
            system.terminate();
        }
    }
}

复杂并发和分布式系统的基石。