ea async

EA assíncrono

EA Async implementa métodos Async-Await na JVM. Ele permite que os programadores escrevam código assíncrono de forma sequencial.

É fortemente inspirado em Async-Await no .NET CLR, consulte Programação Assíncrona com Async e Await para obter mais informações.

Quem deve usá-lo?

EA Async deve ser usado para escrever código assíncrono sem bloqueio que faz uso intenso de CompletableFutures ou CompletionStage. Melhora a escalabilidade liberando threads de trabalho enquanto seu código aguarda outros processos; E melhora a produtividade ao tornar o código assíncrono mais simples e legível.

Desenvolvedor e licença

Este projeto foi desenvolvido pela Electronic Arts e está licenciado sob a licença BSD de 3 cláusulas.

Exemplos

Com EA Assíncrono

 import static com . ea . async . Async . await ;
import static java . util . concurrent . CompletableFuture . completedFuture ;

public class Store
{
    public CompletableFuture < Boolean > buyItem ( String itemTypeId , int cost )
    {
        if (! await ( bank . decrement ( cost ))) {
            return completedFuture ( false );
        }
        await ( inventory . giveItem ( itemTypeId ));
        return completedFuture ( true );
    }
}

Neste exemplo Bank.decrement retorna CompletableFuture<Boolean> e Inventory.giveItem retorna CompletableFuture<String>

EA Async reescreve as chamadas para Async.await tornando seus métodos não bloqueadores.

Os métodos parecem bloqueadores, mas na verdade são transformados em métodos assíncronos que usam CompletableFutures para continuar a execução conforme chegam resultados intermediários.

Sem EA assíncrono

É assim que fica o primeiro exemplo sem EA Async. É um pouco menos legível.

 import static java . util . concurrent . CompletableFuture . completedFuture ;

public class Store
{
    public CompletableFuture < Boolean > buyItem ( String itemTypeId , int cost )
    {
        return bank . decrement ( cost )
            . thenCompose ( result -> {
                if (! result ) {
                    return completedFuture ( false );
                }
                return inventory . giveItem ( itemTypeId ). thenApply ( res -> true );
            });
    }
}

Este é um pequeno exemplo... Um método com mais alguns CompletableFutures pode parecer muito complicado.

EA Async abstrai a complexidade do CompletableFutures.

Com EA Assíncrono (2)

Então você gosta de CompletableFutures? Tente converter este método para usar apenas CompletableFutures sem nunca bloquear (portanto, não há adesão):

 import static com . ea . async . Async . await ;
import static java . util . concurrent . CompletableFuture . completedFuture ;

public class Store
{
    public CompletableFuture < Boolean > buyItem ( String itemTypeId , int cost )
    {
        if (! await ( bank . decrement ( cost ))) {
            return completedFuture ( false );
        }
        try {
            await ( inventory . giveItem ( itemTypeId ));
            return completedFuture ( true );
        } catch ( Exception ex ) {
            await ( bank . refund ( cost ));
            throw new AppException ( ex );
        }
    }
}

Entendi? Envie para nós. Provavelmente parece feio...

Começando

EA Async atualmente oferece suporte a JDK 8-10.

Funciona com Java e Scala e deve funcionar com a maioria das linguagens JVM. O único requisito para usar o EA Async é que ele deve ser usado apenas dentro de métodos que retornem CompletableFuture , CompletionStage ou subclasses de CompletableFuture .

Usando com maven

< dependency >
    < groupId >com.ea.async</ groupId >
    < artifactId >ea-async</ artifactId >
    < version >1.2.3</ version >
</ dependency >

Gradle

 'com.ea.async:ea-async:1.2.3'

Instrumentando seu código

Opção 1 – parâmetro JVM

Inicie seu aplicativo com um parâmetro JVM extra: -javaagent:ea-async-1.2.3.jar

 java -javaagent:ea-async-1.2.3.jar -cp your_claspath YourMainClass args...

É recomendado adicionar isso como opção padrão para inicializadores em projetos IntelliJ que usam ea-async.

Opção 2 – Tempo de execução

Na aula principal ou o mais cedo possível, ligue pelo menos uma vez:

 Async.init();

Desde que sua JVM tenha o recurso ativado, isso iniciará um agente de instrumentação de tempo de execução. Se você esquecer de invocar esta função, a primeira chamada await inicializará o sistema (e imprimirá um aviso).

Esta é uma solução para teste e desenvolvimento, possui o mínimo de configuração. Isso pode interferir na depuração da JVM. Esta alternativa está presente como um substituto.

Opção 3 – Executar ferramenta de instrumentação

O ea-async-1.2.3.jar é um jar executável que pode pré-instrumentar seus arquivos.

Uso:

java -cp YOUR_PROJECT_CLASSPATH -jar ea-async-1.2.3.jar classDirectory

Exemplo:

java -cp guava.jar ; commons-lang.jar  -jar ea-async-1.2.3.jar target/classes

Depois disso, todos os arquivos em destino/classes terão sido instrumentados. Não haverá referências a Async.await e Async.init nessas classes.

Opção 4 - Instrumentação em tempo de construção, com Maven - Preferencial

Use o plug-in ea-async-maven. Ele instrumentará suas classes em tempo de compilação e removerá todas as referências a Async.await e Async.init() .

Com a instrumentação em tempo de construção, os usuários do seu projeto não precisarão ter o EA Async em seu caminho de classe, a menos que também optem por usá-lo. Isso significa que o EA Async não precisa ser uma dependência transitiva .

Esta é a melhor opção para bibliotecas e projetos maven.

< build >
    < plugins >
        < plugin >
            < groupId >com.ea.async</ groupId >
            < artifactId >ea-async-maven-plugin</ artifactId >
            < version >1.2.3</ version >
            < executions >
                < execution >
                    < goals >
                        < goal >instrument</ goal >
                        < goal >instrument-test</ goal >
                    </ goals >
                </ execution >
            </ executions >
        </ plugin >
    </ plugins >
</ build >