Programmation multithread
Plusieurs threads peuvent être simultanés et chaque thread exécute différentes tâches en parallèle.
Le multithreading est une forme spéciale de multitâche, mais le multithreading utilise moins de surcharge de ressources.
Un autre terme lié aux threads est défini ici-processus: Un processus inclut l'espace mémoire alloué par le système d'exploitation et contient un ou plusieurs threads. Un thread ne peut pas exister indépendamment, il doit faire partie du processus. Un processus a été exécuté jusqu'à ce que tous les threads non démons aient fini de s'exécuter avant de pouvoir se terminer.
Le multi-threading peut satisfaire les programmeurs pour écrire des programmes efficaces pour utiliser pleinement le CPU.
La relation entre les processus et les threads est: un processus peut contenir un ou plusieurs threads, mais il y aura au moins un thread.
Créer un nouveau fil
Le langage Java a un support multithreading intégré. Lorsque le programme Java démarre, il démarre en fait un processus JVM, puis la JVM démarre le thread principal pour exécuter la méthode main (). Dans la méthode main (), vous pouvez démarrer d'autres threads.
Java propose trois méthodes pour créer des threads:
- En implémentant l'interface Runnable;
- En héritant de la classe Thread elle-même;
- Créez des discussions via Callable et Future.
Créer un thread en implémentant l'interface Runnable
La façon la plus simple de créer un thread est de créer une classe qui implémente l'interface Runnable.
Pour implémenter Runnable, une classe n'a besoin d'exécuter qu'une seule méthode appelée run (), déclarée comme suit:
public void run ()
Vous pouvez remplacer cette méthode, l'important est de comprendre que run () peut appeler d'autres méthodes, utiliser d'autres classes et déclarer Variables, tout comme le thread principal.
Après avoir créé une classe qui implémente l'interface Runnable, vous pouvez instancier un objet thread dans la classe.
Thread définit plusieurs méthodes de construction, voici ce que nous utilisons souvent:
Thread (Runnable threadOb, String threadName);
Ici, threadOb est une instance d'une classe qui implémente l'interface Runnable, et threadName spécifie le nom du nouveau thread.
Une fois le nouveau thread créé, il ne s'exécutera que si vous appelez sa méthode start ().
void start ();
Voici un exemple de création d'un thread et de démarrage de son exécution:
class RunnableDemo implements Runnable {
private Thread t;
private String threadName;
RunnableDemo( String name) {
threadName = name;
System.out.println("Creating " + threadName );
}
public void run() {
System.out.println("Running " + threadName );
try {
for(int i = 4; i > 0; i--) {
System.out.println("Thread: " + threadName + ", " + i);
// 让线程睡眠一会
Thread.sleep(50);
}
}catch (InterruptedException e) {
System.out.println("Thread " + threadName + " interrupted.");
}
System.out.println("Thread " + threadName + " exiting.");
}
public void start () {
System.out.println("Starting " + threadName );
if (t == null) {
t = new Thread (this, threadName);
t.start ();
}
}
}
public class TestThread {
public static void main(String args[]) {
RunnableDemo R1 = new RunnableDemo( "Thread-1");
R1.start();
RunnableDemo R2 = new RunnableDemo( "Thread-2");
R2.start();
}
}
编译以上程序运行结果如下：
Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.
Créer un fil en héritant du fil
La deuxième façon de créer un thread est de créer une nouvelle classe qui hérite de la classe Thread, puis de créer une instance de cette classe.
Les classes héritées doivent remplacer la méthode run (), qui est le point d'entrée pour les nouveaux threads. Il doit également appeler la méthode start () pour s'exécuter.
Bien que cette méthode soit répertoriée comme une implémentation multithread, il s'agit essentiellement d'une instance de l'interface Runnable.
class ThreadDemo extends Thread {
private Thread t;
private String threadName;
ThreadDemo( String name) {
threadName = name;
System.out.println("Creating " + threadName );
}
public void run() {
System.out.println("Running " + threadName );
try {
for(int i = 4; i > 0; i--) {
System.out.println("Thread: " + threadName + ", " + i);
// 让线程睡眠一会
Thread.sleep(50);
}
}catch (InterruptedException e) {
System.out.println("Thread " + threadName + " interrupted.");
}
System.out.println("Thread " + threadName + " exiting.");
}
public void start () {
System.out.println("Starting " + threadName );
if (t == null) {
t = new Thread (this, threadName);
t.start ();
}
}
}
public class TestThread {
public static void main(String args[]) {
ThreadDemo T1 = new ThreadDemo( "Thread-1");
T1.start();
ThreadDemo T2 = new ThreadDemo( "Thread-2");
T2.start();
}
}
编译以上程序运行结果如下：
Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.
Méthode du fil
Le tableau suivant répertorie certaines méthodes importantes de la classe Thread:
testez si le thread est actif. La méthode ci-dessus est appelée par l'objet Thread. La méthode suivante est une méthode statique de la classe Thread.
Le programme ThreadClassDemo suivant illustre certaines méthodes de la classe Thread:
DisplayMessage.java 文件代码：
// 文件名 : DisplayMessage.java
// 通过实现 Runnable 接口创建线程
public class DisplayMessage implements Runnable {
private String message;
public DisplayMessage(String message) {
this.message = message;
}
public void run() {
while(true) {
System.out.println(message);
}
}
}
GuessANumber.java 文件代码：
// 文件名 : GuessANumber.java
// 通过继承 Thread 类创建线程
public class GuessANumber extends Thread {
private int number;
public GuessANumber(int number) {
this.number = number;
}
public void run() {
int counter = 0;
int guess = 0;
do {
guess = (int) (Math.random() * 100 + 1);
System.out.println(this.getName() + " guesses " + guess);
counter++;
} while(guess != number);
System.out.println("** Correct!" + this.getName() + "in" + counter + "guesses.**");
}
}
ThreadClassDemo.java 文件代码：
// 文件名 : ThreadClassDemo.java
public class ThreadClassDemo {
public static void main(String [] args) {
Runnable hello = new DisplayMessage("Hello");
Thread thread1 = new Thread(hello);
thread1.setDaemon(true);
thread1.setName("hello");
System.out.println("Starting hello thread...");
thread1.start();
Runnable bye = new DisplayMessage("Goodbye");
Thread thread2 = new Thread(bye);
thread2.setPriority(Thread.MIN_PRIORITY);
thread2.setDaemon(true);
System.out.println("Starting goodbye thread...");
thread2.start();
System.out.println("Starting thread3...");
Thread thread3 = new GuessANumber(27);
thread3.start();
try {
thread3.join();
}catch(InterruptedException e) {
System.out.println("Thread interrupted.");
}
System.out.println("Starting thread4...");
Thread thread4 = new GuessANumber(75);
thread4.start();
System.out.println("main() is ending...");
}
}
运行结果如下，每一次运行的结果都不一样。
Starting hello thread...
Starting goodbye thread...
Hello
Hello
Hello
Hello
Hello
Hello
Goodbye
Goodbye
Goodbye
Goodbye
Goodbye
.......
Créez des discussions avec Callable et Future
-
Créez une classe d'implémentation de l'interface Callable et implémentez la méthode call (). La méthode call () agira comme le corps d'exécution du thread et aura une valeur de retour.
-
Créez une instance de la classe d'implémentation Callable et utilisez la classe FutureTask pour encapsuler l'objet Callable. L'objet FutureTask encapsule la valeur de retour de la méthode call () de l'objet Callable.
-
Utilisez l'objet FutureTask comme cible de l'objet Thread pour créer et démarrer un nouveau thread.
-
Appelez la méthode get () de l'objet FutureTask pour obtenir la valeur de retour après l'exécution du thread enfant.
Des exemples
public class CallableThreadTest implements Callable<Integer> {
public static void main(String[] args)
{
CallableThreadTest ctt = new CallableThreadTest();
FutureTask<Integer> ft = new FutureTask<>(ctt);
for(int i = 0;i < 100;i++)
{
System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);
if(i==20)
{
new Thread(ft,"有返回值的线程").start();
}
}
try
{
System.out.println("子线程的返回值："+ft.get());
} catch (InterruptedException e)
{
e.printStackTrace();
} catch (ExecutionException e)
{
e.printStackTrace();
}
}
@Override
public Integer call() throws Exception
{
int i = 0;
for(;i<100;i++)
{
System.out.println(Thread.currentThread().getName()+" "+i);
}
return i;
}
}
Contraste
- Lorsque plusieurs threads sont créés en implémentant les interfaces Runnable et Callable, la classe de thread implémente uniquement l'interface Runnable ou Callable, et peut également hériter d'autres classes.
- Lors de la création de plusieurs threads en héritant de la classe Thread, il est simple d'écrire. Si vous devez accéder au thread actuel, vous n'avez pas besoin d'utiliser la méthode Thread.currentThread (), vous pouvez l'utiliser directement pour obtenir le thread actuel.
La clé d'une utilisation efficace du multithreading est de comprendre que les programmes sont exécutés simultanément plutôt qu'en série. Par exemple, il existe deux sous-systèmes dans le programme qui doivent être exécutés simultanément, puis une programmation multithread est requise.
Grâce à l'utilisation du multithreading, vous pouvez écrire des programmes très efficaces. Cependant, veuillez noter que si vous créez trop de threads, l'efficacité de l'exécution du programme est en fait réduite, pas améliorée.
N'oubliez pas que la surcharge de changement de contexte est également très importante. Si vous créez trop de threads, le CPU passera plus de temps à changer de contexte qu'à exécuter le programme!
