Multithreading en Java: Comment démarrer avec les threads

Qu'est-ce qu'un fil?

Un fil est un processus léger. Tout processus peut avoir plusieurs threads en cours d'exécution.

Par exemple, dans un navigateur Web, nous pouvons avoir un thread qui chargera l'interface utilisateur et un autre thread qui récupérera réellement toutes les données qui doivent être affichées dans cette interface.

Qu'est-ce que MultiThreading?

Le multithreading nous permet d'exécuter plusieurs threads simultanément.

Par exemple dans un navigateur web, nous pouvons avoir un thread qui gère l'interface utilisateur, et en parallèle nous pouvons avoir un autre thread qui récupère les données à afficher.

Ainsi, le multithreading améliore la réactivité d'un système.

Qu'est-ce que la concurrence?

La concurrence dans le contexte des threads nous permet d'exécuter plusieurs threads en même temps.

Mais les threads fonctionnent-ils vraiment en même temps?

Systèmes monocœur

Le planificateur de threads fourni par la JVM décide quel thread s'exécute à un moment donné. Le planificateur donne une petite tranche de temps à chaque thread.

Donc, à tout moment, nous n'avons qu'un seul thread qui tourne réellement dans le processeur. Mais à cause du découpage du temps, nous avons le sentiment que plusieurs threads fonctionnent en même temps.

Systèmes multicœur

Même dans plusieurs systèmes principaux, le planificateur de threads est impliqué. Mais comme nous avons plusieurs cœurs, nous pouvons en fait exécuter plusieurs threads exactement en même temps.

Par exemple, si nous avons un système dual core, alors nous pouvons avoir 2 threads en cours d'exécution exactement en même temps. Le premier thread s'exécutera dans le premier noyau et le deuxième thread s'exécutera dans le deuxième noyau.

Pourquoi le multithreading est-il nécessaire?

Le multithreading nous permet d'améliorer la réactivité d'un système.

Par exemple, dans un navigateur Web, si tout s'exécutait dans un seul thread, le système ne répondrait absolument pas chaque fois que des données étaient extraites pour être affichées. Par exemple, si cela prend 10 secondes pour récupérer les données, alors dans ces 10 secondes, nous ne pourrons rien faire d'autre dans le navigateur Web, comme ouvrir de nouveaux onglets ou même fermer le navigateur Web.

L'exécution simultanée de différentes parties d'un programme dans différents threads permet d'améliorer la réactivité d'un système.

Comment écrire des programmes multithread en Java

Nous pouvons créer des threads en Java en utilisant ce qui suit

  • Extension de la classe de thread
  • Implémentation de l'interface exécutable
  • Implémentation de l'interface appelable
  • En utilisant le framework exécuteur avec des tâches exécutables et appelables

Nous examinerons les callables et le framework exécuteur dans un blog séparé. Dans cet article, je me concentrerai principalement sur l'extension de la classe de thread et l'implémentation de l'interface exécutable.

Extension de la classe de thread

Afin de créer un morceau de code qui peut être exécuté dans un thread, nous créons une classe puis étendons la classe de thread . La tâche effectuée par ce morceau de code doit être placée dans la fonction run () .

Dans le code ci-dessous, vous pouvez voir que worker est une classe qui étend la classe de thread et que la tâche d'impression des nombres 0 à 5 est effectuée dans la fonction run () .

class Worker extends Thread { @Override public void run() { for (int i = 0; i <= 5; i++) { System.out.println(Thread.currentThread().getName() + ": " + i); } } } 

Dans le code ci-dessus, Thread.currentThread (). GetName () est utilisé pour obtenir le nom du thread actuel qui exécute le code.

Pour créer un thread , il suffit de créer une instance de la classe worker. Et puis nous pouvons démarrer le thread en utilisant la fonction start () .

public class ThreadClassDemo { public static void main(String[] args) { Thread t1 = new Worker(); Thread t2 = new Worker(); Thread t3 = new Worker(); t1.start(); t2.start(); t3.start(); } } 

Dans le code ci-dessus, nous créons 3 threads (t1, t2 et t3) à partir de la classe worker. Ensuite, nous démarrons les threads en utilisant la fonction start () .

Voici le code final pour créer un thread en étendant une classe de thread:

class Worker extends Thread { @Override public void run() { for (int i = 0; i <= 5; i++) { System.out.println(Thread.currentThread().getName() + ": " + i); } } } public class ThreadClassDemo { public static void main(String[] args) { Thread t1 = new Worker(); Thread t2 = new Worker(); Thread t3 = new Worker(); t1.start(); t2.start(); t3.start(); } } 

Voici la sortie que nous obtenons en exécutant le code ci-dessus:

Sortie de classe de thread

Vous pouvez voir que tous les 3 fils ont imprimé les nombres de 0 à 5.

Vous pouvez également clairement voir à partir de la sortie que les 3 threads ne s'exécutent pas dans une séquence particulière

Implementing the Runnable Interface

In order to create a piece of code which can be run in a thread, we create a class and then implement the runnable interface. The task being done by this piece of code needs to be put in the run() function.

In the below code you can see that RunnableWorker is a class which implements runnable interface, and the task of printing numbers 0 to 4 is being done inside the run() function.

class RunnableWorker implements Runnable{ @Override public void run() { for (int i = 0; i <= 4; i++) { System.out.println(Thread.currentThread().getName() + ": " + i); } } } 

In order to create a thread, first we need to create an Instance of RunnableWorker which implements the runnable interface.

Then we can create a new thread by creating an instance of the thread class and passing the instance of RunnableWorker as the argument. This is shown in the code below:

public class RunnableInterfaceDemo { public static void main(String[] args) { Runnable r = new RunnableWorker(); Thread t1 = new Thread(r); Thread t2 = new Thread(r); Thread t3 = new Thread(r); t1.start(); t2.start(); t3.start(); } } 

The above code creates a runnable instance r. Then it create 3 threads (t1, t2 and t3) and passes r as the argument to the 3 threads. Then the start() function is used to start all 3 threads.

Here is the complete code for creating a thread by implementing the runnable interface:

class RunnableWorker implements Runnable{ @Override public void run() { for (int i = 0; i <= 4; i++) { System.out.println(Thread.currentThread().getName() + ": " + i); } } } public class RunnableInterfaceDemo { public static void main(String[] args) { Runnable r = new RunnableWorker(); Thread t1 = new Thread(r); Thread t2 = new Thread(r); Thread t3 = new Thread(r); t1.start(); t2.start(); t3.start(); } } 

On running the above code, we will get the following output. The sequence of the output will change every time the code is run.

Sortie d'interface exécutable

Implementing the runnable interface is a better option than extending the thread class since we can extend only one class, but we can implement multiple interfaces in Java.

Runnable Interface in Java 8

In Java 8, the runnable interface becomes a FunctionalInterface since it has only one function, run().

The below code shows how we can create a runnable instance in Java 8.

public class RunnableFunctionalInterfaceDemo { public static void main(String[] args) { Runnable r = () -> { for (int i = 0; i <= 4; i++) { System.out.println(Thread.currentThread().getName() + ": " + i); } }; Thread t1 = new Thread(r); Thread t2 = new Thread(r); Thread t3 = new Thread(r); t1.start(); t2.start(); t3.start(); } } 

Here, instead of creating a class and then implementing the runnable interface, we can directly use a lambda expression to create a runnable instance as shown below:

Runnable r = () -> { for (int i = 0; i <= 4; i++) { System.out.println(Thread.currentThread().getName() + ": " + i); } }; 

Code

The code in this article is available in the following GitHub repo: //github.com/aditya-sridhar/basic-threads-demo

Congrats ?

You now know how to create threads by extending the thread class and by implementing the runnable interface.

I will discuss the thread life cycle and challenges while using threads in my next blog post.

My Website: //adityasridhar.com/

N'hésitez pas à me contacter sur LinkedIn ou à me suivre sur Twitter