何时使用Akka，何时不使用？

Question

I'm currently in the situation that I'm actually making things more complicated by using Actors then when I don't. I need to execute a lot of Http Requests without blocking the Main thread. Since this is concurrency and I wanted to try something different then locks, I decided to go with Akka. Now I'm in the situation that I'm doubting between two approaches.

Approach one (Create new Actors when it's in need):

public class Main {
    public void start() {
        ActorSystem system = ActorSystem.create();

        // Create 5 Manager Actors (Currently the same Actor for all but this is different in actual practise)
        ActorRef managers = system.actorOf(new BroadcastPool(5).props(Props.create(Actor.class)));
        managers.tell(new Message(), ActorRef.noSender());
    }
}

public class Actor extends UntypedActor {

    @Override
    public void onReceive(Object message) throws Exception {
        if (message instanceof Message) {
            ActorRef ref = getContext().actorOf(new SmallestMailboxPool(10).props(Props.create(Actor.class)));

            // Repeat the below 10 times
            ref.tell(new Message2(), getSelf());
        } else if (message instanceof Message2) {
            // Execute long running Http Request
        }
    }
}

public final class Message {
    public Message() {
    }
}

public final class Message2 {
    public Message2() {
    }
}

Approach two (Create a whole lot of actors before hand and hope it's enough):

public class Main {
    public void start() {
        ActorSystem system = ActorSystem.create();

        ActorRef actors = system.actorOf(new SmallestMailboxPool(100).props(Props.create(Actor.class)));
        ActorRef managers = system.actorOf(new BroadcastPool(5).props(Props.create(() -> new Manager(actors))));

        managers.tell(new Message(), ActorRef.noSender());
    }
}

public class Manager extends UntypedActor {

    private ActorRef actors;

    public Manager(ActorRef actors) {
        this.actors = actors;
    }

    @Override
    public void onReceive(Object message) throws Exception {
        if (message instanceof Message) {
            // Repeat 10 times
            actors.tell(new Message2(), getSelf());
        }
    }
}

public class Actor extends UntypedActor {

    @Override
    public void onReceive(Object message) throws Exception {
        if (message instanceof Message2) {
            // Http request
        }
    }
}

public final class Message {
    public Message() {
    }
}

public final class Message2 {
    public Message2() {
    }
}

So both approaches have up and down sides. One makes sure it can always handle new requests coming in, those never have to wait. But it leaves behind a lot of Actors that are never gonna be used. Two on the hand reuses Actors but with the downside that it might not have enough of them and can't cope some time in the future and has to queue the messages.

What is the best approach of solving this and what is most common way people deal with this?

If you think I could be doing this sort of stuff a lot better (with or without Akka) please tell me! I'm pretty new to Akka and would love to learn more about it.

Answer 1

Based on the given information, it looks like a typical example for task-based concurrency -- not for actor-based concurrency. Imagine you have a method for doing the HTTP request. The method fetches the given URL and returns an object without causing any data races on shared memory:

private static Page loadPage(String url) {
    // ...
}

You can easily fetch the pages concurrently with an Executor . There are different kinds of Executors , eg you can use one with a fixed number of threads.

public static void main(String... args) {
    ExecutorService executor = Executors.newFixedThreadPool(5);
    List<Future<Page>> futures = new ArrayList<>();
    // submit tasks
    for (String url : args) {
        futures.add(executor.submit(() -> loadPage(url)));
    }
    // access result of tasks (or wait until it is available)
    for (Future<Page> future : futures) {
        Page page = future.get();
        // ...
    }
    executor.shutdown();
}

There is no further synchronization required. The Executor framework takes care of that.

Answer 2

我会使用混合方法：预先创建相对较小的actor池，在需要时增加它，但保持池的大小受限（当连接过多时拒绝请求，以避免由于内存不足而导致崩溃）。