adeynack/more-executors

Specialised executors for the JVM (mainly Java and Kotlin, but also Scala)

more-executors's Issues

Use ErrorProne

http://errorprone.info/docs/installation

SequencedExecutor

Use cases

• Limit the number of parallel tasks of a similar nature that are executed at the same time to 1.
• Ensure mutually exclusive "lock" over a mutable resource without blocking
  • Done by configuring this Executor with only 1 parallel task.
  • Example: Protect a mutable state inside of a service

Why not ...

... use Executors.newSingleThreadExecutor();

Because it creates a new thread. This proposition is an Executor that limits without creating any new thread. The thread pool already exist and we want to use it. In the end, the tasks are dispatched to an existing Executor (which does not have to be a pool, but is the typical use).

Specifications

• Based on an existing executor (composite)

StateGuard - mutateAndProvide

To be done AFTER

• #1 SequencedExecutor
• #3 StateGuard.mutate

Next feature

mutateAndProvide

User submits a lambda receiving the actual state and returning both the value to return as a result of the operation and the new value of the state.

return stateGuard.mutateAndProvide(actual -> {
  log.info("Adding user " + user.getName());
  
  List<User> updatedUserList = new ArrayList<User>(actual.getUserList());
  updatedUserList.add(user);
  UserServiceState newState = new UserServiceState(updatedUserList);

  List<String> userNames = new ArrayList(actual.getUserList().stream().map(u -> u.getName());

  return new MutateAndProvideDecision(newState, userNames);
});

StateGuard

Idea

Ensures that state mutation is thread safe by holding the state value itself internally and making it available only when a task is dispatched to it.

This works better if the state is an immutable class using immutable collections, for total encapsulation.

To be done AFTER

• #1 SequencedExecutor

Main features

Those are main ideas and not final interfaces.

mutate

User submits a lambda receiving the actual state and returning the new value of the state. The method itself returns a CompletionStage<Void> to allow to caller to react upon the completion of the submitted task.

public CompletionStage<Void> addUser(User user) {
    return stateGuard.mutate(actual -> {
        log.info("Adding user " + user.getName());
        List<User> updatedUserList = new ArrayList<User>(actual.getUserList());
        updatedUserList.add(user);
        UserServiceState newState = new UserServiceState(updatedUserList);
        return newState;
    });    
}

provide

User submits a lambda receiving the actual state and returning a value to pass down to the caller of the method.

public CompletionStage<List<String>> getUserNames() {
    return stateGuard.provide((actual) -> {
       new ArrayList(actual.getUserList().stream().map(u -> u.getName())
    });    
}

mutateAndProvide

User submits a lambda receiving the actual state and returning both the value to return as a result of the operation and the new value of the state.

return stateGuard.mutateAndProvide(actual -> {
  log.info("Adding user " + user.getName());
  
  List<User> updatedUserList = new ArrayList<User>(actual.getUserList());
  updatedUserList.add(user);
  UserServiceState newState = new UserServiceState(updatedUserList);

  List<String> userNames = new ArrayList(actual.getUserList().stream().map(u -> u.getName());

  return new MutateAndProvideDecision(newState, userNames);
});

Publish to local Maven

LimitedExecutor

Use cases

• Limit the number of parallel tasks of a similar nature that are executed at the same time.
  • Example: Ensure that not more than 3 calls to an external service are made at the same time.

Why not ...

... use Executors.newFixedThreadPool

Because it creates new threads. This proposition is an Executor that limits without creating any new thread. The thread pool already exist and we want to use it. In the end, the tasks are dispatched to an existing Executor (which does not have to be a pool, but is the typical use).

Specifications

• Based on an existing executor (composite)
• Receive the number of parallel task to be executed at construction time.

Configure Travis CI

Link

https://travis-ci.org/Adeynack/more-executors/settings

Tasks

• Create /.travis.yaml file (check instructions)

Provide overloads without `baseExecutor`

It should be possible to create the current executor without providing a baseExecutor. That should be using the default executor used for the CompletableFuture.

Dummy (lacking a better one) implementation of such a base executor (in Kotlin):

val baseExecutor = Executor { CompletableFuture.runAsync(it) }

StateGuard - provide

To be done AFTER

• #1 SequencedExecutor
• #3 StateGuard.mutate

Next feature

provide

User submits a lambda receiving the actual state and returning a value to pass down to the caller of the method.

public CompletionStage<List<String>> getUserNames() {
    return stateGuard.provide((actual) -> {
       new ArrayList(actual.getUserList().stream().map(u -> u.getName())
    });    
}