Pause café #159. Cycle de vie d'un thread en Java. Interfaces fonctionnelles et méthodes par défaut dans Java 8

Cycle de vie d'un thread en Java

Source : Medium Cet article traite des différents états du cycle de vie des threads en Java. Le cycle de vie d'un thread en Java consiste principalement en des transitions vers différents états, commençant par la naissance du thread et se terminant par sa fin. Un thread est prêt à s'exécuter lorsqu'il est créé et démarré en appelant la méthode start() sur la classe Thread . Lorsque la méthode sleep() ou wait() de la classe Thread est appelée , le thread devient inutilisable. Pour gérer les threads par programmation, il est important d’identifier l’état du thread. Comprenons comment le cycle de vie d'un thread Java détermine son état. Voici ce que dit la documentation Java à ce sujet : Un thread est un chemin d'exécution d'un programme qui peut entrer dans l'un des cinq états au cours de son cycle de vie :

1. Nouveau
2. Exécutable
3. En cours d'exécution
4. Bloqué
5. Mort

1. Nouveau (état nouveau-né) se produit lorsque vous créez un objet Thread dans la classe Thread. Le flux est créé et est dans un état « nouveau-né ». Autrement dit, lorsqu'un thread est créé, il entre dans un nouvel état, mais la méthode start() n'a pas encore été appelée sur l'instance. 2. Exécutable. Cet état signifie que le thread est prêt à s'exécuter. Lorsque la méthode start() est appelée sur un nouveau thread, elle est prête à démarrer. Dans cet état, le thread attend que le processeur soit disponible (temps CPU). Autrement dit, le thread devient une file d'attente (série) de threads en attente d'exécution. 3. En cours d'exécution (état d'exécution). L'exécution signifie que le processeur a alloué un créneau horaire pour que le thread s'exécute. Il s'agit de l'état dans lequel le thread exécute sa fonction réelle. 4. Bloqué (état bloqué). Un thread est dans un état bloqué lorsqu'il se met en pause, se met en veille ou attend un certain temps pour satisfaire une condition donnée. 5. État mort. Cette condition se produit lorsque la méthode run() termine l’exécution des instructions. Le thread s'arrête automatiquement ou passe à l'état mort. En d’autres termes, lorsqu’un thread quitte la méthode run() , il se termine ou devient mort.

Interfaces fonctionnelles et méthodes par défaut dans Java 8

Source : Medium Dans cet article, vous découvrirez certains des changements introduits dans Java 8, à savoir les interfaces fonctionnelles et les méthodes par défaut.

Que sont les méthodes par défaut ?

Nous savons que les classes abstraites peuvent avoir des méthodes abstraites et non abstraites (méthodes implémentées), mais les interfaces sont 100% abstraites (toutes ces méthodes n'ont qu'une signature et aucune implémentation). Mais que se passe-t-il si nous avons besoin d’une interface au lieu d’une classe et de fonctionnalités communes à toutes les classes implémentées ? Parce qu'alors le code d'implémentation est répété encore et encore dans chaque classe qui implémente l'interface. Pour éviter cela, Java 8 a ajouté le mot-clé par défaut . Si nous avons une méthode implémentée dans une interface, alors le mot-clé par défaut doit être attribué à cette méthode, sinon nous obtiendrons une erreur d'exécution.

Qu'est-ce qu'une interface fonctionnelle ?

Les interfaces fonctionnelles ne sont rien d'autre que des interfaces avec une méthode abstraite et un certain nombre de méthodes standard ou statiques. Un exemple d'interface fonctionnelle est Comparable, qui possède une méthode abstraite, compareTo() . À son tour, Runnable a une méthode run() et ainsi de suite. Nous pouvons également représenter une interface fonctionnelle en utilisant l'annotation @FunctionalInterface. Il garantit qu'une interface n'a qu'une seule méthode abstraite :

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

Types d'interfaces fonctionnelles

Consommateur : prend un argument et ne renvoie rien.

• Les trois variantes de Consumer sont DoubleConsumer, IntConsumer et LongConsumer (selon le type d'arguments qu'elles acceptent).
• Bi-Consumer - prend deux arguments et ne renvoie rien.

Prédicat - prend un argument et renvoie une valeur booléenne.

• Les trois variantes de Predicate sont DoublePredicate, IntPredicate et LongPredicate (selon le type d'arguments qu'elles acceptent).
• Bi-Predicate - prend deux arguments et renvoie une valeur booléenne.

Fonction - prend un argument et renvoie une valeur.

• De nombreuses versions de fonctions sont disponibles sous forme de types d'arguments, int , long et double étant les plus couramment utilisés.
• Bi-Function - prend deux arguments et renvoie une valeur.
• Les opérateurs unaires et binaires implémentent respectivement Function et Bi-Function, mais la condition supplémentaire ici est que l'entrée et la sortie doivent être identiques et du même type.

Fournisseur - N'accepte aucune entrée mais renvoie une seule valeur. Différentes versions de Supplier : BooleanSupplier, IntSupplier, LongSupplier et DoubleSupplier, pour lesquelles les types de retour sont les primitives correspondantes.