À quoi fait référence le multithreading Java ?

Le multithreading Java fait référence à : Le multithreading est un mécanisme qui permet à plusieurs flux d'instructions d'être exécutés simultanément dans un programme. Chaque flux d'instructions est appelé un thread et est indépendant les uns des autres. Toutes les variables en Java sont stockées dans main. mémoire et partagé par tous les threads.

Explication détaillée du multi-threading Java :

1. Comprendre le multi-threading

Le multi-threading est un mécanisme qui permet d'exécuter plusieurs flux d'instructions simultanément dans un programme. Chaque flux d'instructions est appelé un thread et est indépendant les uns des autres. Les threads sont également appelés processus légers. Ils ont un contrôle d'exécution indépendant comme les processus et sont planifiés par le système d'exploitation. La différence est que les threads ne disposent pas d'espace de stockage indépendant, mais partagent un espace de stockage avec d'autres threads du processus auquel ils appartiennent. Cela rend la communication entre les threads beaucoup plus simple que celle des processus.

Spécifique au modèle de mémoire Java, Java étant conçu comme un langage multiplateforme, il est évident qu'il doit y avoir un modèle unifié en termes de gestion de la mémoire. Le système dispose d'une mémoire principale (Main Memory). Toutes les variables en Java sont stockées dans la mémoire principale et sont partagées par tous les threads. Chaque thread possède sa propre mémoire de travail (Working Memory). Ce qui est stocké dans la mémoire de travail est une copie de certaines variables dans la mémoire principale. Toutes les opérations des threads sur les variables sont effectuées dans la mémoire de travail et les threads ne peuvent pas accéder directement les uns aux autres. , le transfert de variables doit être effectué via la mémoire principale.

L'exécution de plusieurs threads est concurrente, c'est-à-dire logiquement "simultanément", qu'elle soit physiquement "simultanément". Si le système ne dispose que d'un seul processeur, la véritable « simultanéité » est alors impossible. La plus grande différence de programmation entre le multithreading et le monothreading traditionnel est que, comme les flux de contrôle de chaque thread sont indépendants les uns des autres, le code entre chaque thread est exécuté dans le désordre, ce qui entraînera des problèmes de planification, de synchronisation et d'autres problèmes. . Réseau de gestion de réseau bitsCN.com

Recommandations d'apprentissage associées : Tutoriel de base Java

Implémentation du multi-threading en Java

Autant imaginer ce qu'il faut faire pour créer un nouveau fil ? Évidemment, il faut préciser le code qui sera exécuté par ce thread, et c'est tout ce qu'il faut faire pour implémenter le multi-threading en Java !

En tant que langage entièrement orienté objet, Java fournit la classe java.lang.Thread pour faciliter la programmation multi-thread. Cette classe fournit un grand nombre de méthodes pour nous faciliter le contrôle de nos propres threads.

Alors, comment pouvons-nous fournir à Java le code que nous voulons que le thread exécute ? Jetons un coup d'œil à la classe Thread. La méthode la plus importante de la classe Thread est run(), qui est appelée par la méthode start() de la classe Thread et fournit le code à exécuter par notre thread. Afin de spécifier notre propre code, remplacez-le !

Méthode 1 : Hériter de la classe Thread et réécrire la méthode run() Nous réécrivons run() dans la sous-classe de la classe Thread créée et ajoutons le code à exécuter par le thread. Voici un exemple :

public class TwoThread extends Thread {
    public void run() {
        for ( int i = 0; i < 10; i++ ) {
            System.out.println("New thread");
        }
    }
    public static void main(String[] args) {
        TwoThread tt = new TwoThread();
        tt.start();
        for ( int i = 0; i < 10; i++ ) {
            System.out.println("Main thread");
        }
    }
}

Cette méthode est simple et claire, et correspond aux habitudes de chacun. Cependant, elle a aussi un gros inconvénient, c'est que si notre classe a hérité d'une classe, elle. ne peut plus hériter du type Thread.

Méthode 2 : Implémenter l'interface Runnable

L'interface Runnable n'a qu'une seule méthode run() Nous déclarons que notre classe implémente l'interface Runnable et fournit cette méthode pour y écrire notre code de thread. . Cette partie de la tâche est terminée. Cependant, l'interface Runnable ne prend pas en charge les threads. Il faut également créer une instance de la classe Thread, ce qui est réalisé via le constructeur public Thread (cible Runnable) de la classe Thread. Voici un exemple :

public class MyThread implements Runnable {
int count=1, number;
public MyThread(int num) {
number = num;
System.out.println("创建线程 " + number);
}
public void run() {
while(true) {
System.out.println("线程 " + number + ":计数 " + count);
if(++count== 6) return;
}
}
public static void main(String args[]) {
for(int i = 0; i < 5; i++)
new Thread(new MyThread(i+1)).start();
}
}

L'utilisation de l'interface Runnable pour implémenter le multi-threading nous permet de contenir tout le code dans une seule classe, ce qui est bénéfique pour l'encapsulation. Étudions quelques problèmes liés à l'utilisation du multi-threading. .

3. Quatre états de threads

1. Nouvel état : Le thread a été créé mais n'a pas encore été exécuté (start() n'a pas encore été appelé) .

2. État exécutable : le thread peut être exécuté, même s'il n'est pas nécessairement en cours d'exécution. Du temps CPU peut être alloué à ce thread à tout moment, provoquant son exécution.

3. État bloqué : le thread ne se verra pas attribuer de temps CPU et ne pourra pas être exécuté ; il peut être bloqué en E/S ou bloqué dans un verrou de synchronisation.

4. État de mort : dans des circonstances normales, le retour de run() entraînera la mort du thread. L'appel de stop() ou destroy() a le même effet, mais n'est pas recommandé. Le premier générera une exception, et le second forcera la terminaison et ne libérera pas le verrou.

4. Priorité du sujet

    线程的优先级代表该线程的重要程度，当有多个线程同时处于可执行状态并等待获得 CPU 时间时，线程调度系统根据各个线程的优先级来决定给谁分配 CPU 时间，优先级高的线程有更大的机会获得 CPU 时间，优先级低的线程也不是没有机会，只是机会要小一些罢了。

    你可以调用 Thread 类的方法 getPriority（） 和 setPriority（）来存取线程的优先级，线程的优先级界于1（MIN_PRIORITY）和10（MAX_PRIORITY）之间，缺省是5（NORM_PRIORITY）。

五、线程的同步

    由于同一进程的多个线程共享同一片存储空间，在带来方便的同时，也带来了访问冲突这个严重的问题。Java语言提供了专门机制以解决这种冲突，有效避免了同一个数据对象被多个线程同时访问。

    我们只需针对方法提出一套机制，这套机制就是 synchronized 关键字，它包括两种用法：synchronized 方法和 synchronized 块。

    1. synchronized 方法：通过在方法声明中加入synchronized关键字来声明 synchronized 方法。synchronized 方法控制对类成员变量的访问：每个类实例对应一把锁，每个 synchronized 方法都必须获得调用该方法的类实例的锁方能执行，否则所属线程阻塞，方法一旦执行，就独占该锁，直到从该方法返回时才将锁释放，此后被阻塞的线程方能获得该锁，重新进入可执行状态。这种机制确保了同一时刻对于每一个类实例，其所有声明为 synchronized 的成员函数中至多只有一个处于可执行状态（因为至多只有一个能够获得该类实例对应的锁），从而有效避免了类成员变量的访问冲突（只要所有可能访问类成员变量的方法均被声明为 synchronized）。

    在 Java 中，不光是类实例，每一个类也对应一把锁，这样我们也可将类的静态成员函数声明为 synchronized，以控制其对类的静态成员变量的访问。

    synchronized 方法的缺陷：若将一个大的方法声明为synchronized 将会大大影响效率，典型地，若将线程类的方法run（）声明为synchronized ，由于在线程的整个生命期内它一直在运行，因此将导致它对本类任何synchronized方法的调用都永远不会成功。

    2. synchronized 块：通过 synchronized关键字来声明synchronized 块。语法如下：

synchronized(syncObject) {
//允许访问控制的代码
}

    synchronized 块是这样一个代码块，其中的代码必须获得对象 syncObject 的锁方能执行，具体机制同前所述。由于可以针对任意代码块，且可任意指定上锁的对象，故灵活性较高。

相关学习推荐：编程视频

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!