Pausa para café #159. Ciclo de vida de um thread em Java. Interfaces funcionais e métodos padrão em Java 8

Ciclo de vida de um thread em Java

Fonte: Médio Este artigo discute os diferentes estados do ciclo de vida de threads em Java. O ciclo de vida de um thread em Java consiste principalmente em transições para vários estados, começando com o nascimento do thread e terminando com o término do thread. Um thread está pronto para ser executado quando é criado e iniciado chamando o método start() na classe Thread . Quando o método sleep() ou wait() da classe Thread é chamado , o thread se torna inutilizável. Para gerenciar threads programaticamente, é importante identificar o estado do thread. Vamos entender como o ciclo de vida de um thread Java determina seu estado. Aqui está o que a documentação Java diz sobre isso: Um thread é um caminho de execução de programa que pode entrar em um dos cinco estados durante seu ciclo de vida:

1. Novo
2. Executável
3. Correndo
4. Bloqueado
5. Morto

1. Novo (estado recém-nascido) ocorre quando você cria um objeto Thread na classe Thread. O fluxo é criado e está em estado “recém-nascido”. Ou seja, quando uma thread é criada, ela entra em um novo estado, mas o método start() ainda não foi chamado na instância. 2. Executável. Este estado significa que o thread está pronto para ser executado. Quando o método start() é chamado em um novo thread, ele fica pronto para iniciar. Neste estado, o thread espera até que o processador fique disponível (tempo de CPU). Ou seja, a thread se torna uma fila (série) de threads aguardando para serem executadas. 3. Em execução (estado de execução). Executar significa que o processador alocou um intervalo de tempo para a execução do thread. Este é o estado no qual o thread executa sua função real. 4. Bloqueado (estado bloqueado). Um thread está em um estado bloqueado quando pausa, dorme ou espera algum tempo para satisfazer uma determinada condição. 5. Estado morto. Esta condição ocorre quando o método run() termina de executar as instruções. O thread para automaticamente ou entra no estado morto. Em outras palavras, quando um thread sai do método run() , ele termina ou morre.

Interfaces funcionais e métodos padrão em Java 8

Fonte: Médio Neste artigo, você aprenderá sobre algumas das mudanças introduzidas no Java 8, nomeadamente interfaces funcionais e métodos padrão.

O que são métodos padrão?

Sabemos que classes abstratas podem ter métodos abstratos e não abstratos (métodos que são implementados), mas as interfaces são 100% abstratas (todos esses métodos possuem apenas assinatura e nenhuma implementação). Mas e se precisarmos de uma interface em vez de uma classe e de uma funcionalidade comum entre todas as classes implementadas? Porque então o código de implementação é repetido continuamente em cada classe que implementa a interface. Para evitar isso, o Java 8 adicionou a palavra-chave padrão . Se tivermos um método implementado em uma interface, a palavra-chave padrão deverá ser atribuída a esse método, caso contrário, obteremos um erro de tempo de execução.

O que é uma interface funcional?

Interfaces funcionais nada mais são do que interfaces com um método abstrato e qualquer número de métodos padrão ou estáticos. Um exemplo de interface funcional é Comparable, que possui um método abstrato, compareTo() . Por sua vez, Runnable possui um método run() e assim por diante. Também podemos representar uma interface funcional usando a anotação @FunctionalInterface. Ele garante que uma interface tenha apenas um método abstrato:

@FunctionalInterface
public interface MyfunctionalInterface{
   public void myabstractmethod();
   public static void method1(){
       //Имплементация
    }
   public default void method2(){
       //Имплементация
    }
}

Tipos de interfaces funcionais

Consumidor – recebe um argumento e não retorna nada.

• As três variantes de Consumer são DoubleConsumer, IntConsumer e LongConsumer (dependendo do tipo de argumentos que aceitam).
• Bi-Consumidor – recebe dois argumentos e não retorna nada.

Predicado - recebe um argumento e retorna um valor booleano.

• As três variantes de Predicate são DoublePredicate, IntPredicate e LongPredicate (dependendo do tipo de argumentos que aceitam).
• Bi-Predicado - recebe dois argumentos e retorna um valor booleano.

Função - recebe um argumento e retorna um valor.

• Muitas versões de funções estão disponíveis como tipos de argumentos, sendo int , long e double os mais comumente usados.
• Bifuncional - recebe dois argumentos e retorna um valor.
• Os operadores Unário e Binário implementam Função e Bi-Função respectivamente, mas a condição adicional aqui é que a entrada e a saída devem ser idênticas e do mesmo tipo.

Fornecedor - Não aceita nenhuma entrada, mas retorna um único valor. Várias versões de Supplier: BooleanSupplier, IntSupplier, LongSupplier e DoubleSupplier, para as quais os tipos de retorno são as primitivas correspondentes.