Explication détaillée de la méthode d'implémentation de la synchronisation des threads Java (avec code)

Cet article vous apporte une explication détaillée de la méthode d'implémentation de la synchronisation des threads Java (avec du code). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Pourquoi la synchronisation des threads

Lorsque nous avons plusieurs threads fonctionnant sur la même ressource, comme des fichiers, nous ne pouvons pas permettre à plusieurs threads de fonctionner en même temps. ce fichier. Parce que lorsque des fichiers sont partagés, plusieurs opérations entreront en conflit. Je pense que les personnes qui ont utilisé Git pour le développement d'équipes auront une profonde expérience en matière de comparaison de prix.

À ce stade, le mécanisme de synchronisation des threads doit être introduit.

La soi-disant synchronisation fait référence à l'exécution un par un, c'est-à-dire à la mise en file d'attente de plusieurs threads pour l'exécution, de sorte qu'il y ait une relation premier arrivé, premier servi entre les threads. De cette façon, il n’y aura ni combats ni conflits.

Description du problème

Un programme avec deux threads Le premier thread calcule les nombres pairs et les nombres entre 2 et 1000, et le deuxième thread calcule 1000. Les nombres pairs et les nombres. entre ~2000.

Mise en œuvre initiale

Tout d'abord, concevons la méthode de mise en œuvre en fonction du sujet.

1. Définissez deux fils de discussion. Ici, vous devez définir votre propre classe de thread, puis définir le début et la fin du calcul des nombres pairs
2 Implémenter le calcul des nombres pairs et le nombre de nombres pairs dans la plage donnée
3. 🎜>

Vous pouvez voir La mise en œuvre est simple. La mise en œuvre préliminaire est la suivante :

1. Définissez votre propre classe de thread :

public class MyTread extends Thread {
    private int begin;          // 范围开始
    private int end;            // 范围结束

    public MyTread(int begin, int end) {
        this.begin = begin;
        this.end = end;
    }
}

2. 🎜>

@Override
public void run() {
    this.getEven(begin, end);
}

// 获取偶数以及个数
private void getEven(int begin, int end) {
    int count = 0;
    System.out.println(begin + "～" + end + "之间的偶数为：");
    if (begin % 2 != 0) {
        begin += 1;
    }

    for (; begin 3. Initialisez le fil de discussion et exécutez <p><strong></strong></p><pre class="brush:php;toolbar:false">public static void main(String[] args) {
    MyTread tread1 = new MyTread(2, 500);
    MyTread tread2 = new MyTread(500, 1000);
    tread1.start();
    tread2.start();
}

Remarque : est là pour afficher l'effet ultérieur, donc réduire la plage de numéros. Regardez les résultats :

Cela ne semble pas être l'effet que nous souhaitons. Nous voulons cet effet :

Nous voulons que les nombres pairs et pairs de chaque partie soient ensemble, mais l'effet après sa mise en œuvre est bien deux des éléments de confusion surgissent.

Amélioration de la procédure

Pour résoudre les problèmes ci-dessus, nous devons utiliser le

dont nous avons parlé au début.

线程同步D'après notre introduction initiale, nous avons constaté qu'une condition pour la synchronisation est d'avoir un

. Alors qu'est-ce que c'est

dans notre code ? Il semble que non. Alors créez-en un d’abord. 共享的资源共享的资源

1. Créer des ressources partagées

Les ressources partagées que nous avons ici peuvent être

, nous allons donc créer une autre classe pour exemple de ressources partagées.

同一个对象

public class Even {}

2. Créez ensuite une méthode de calcul des nombres pairs dans la classe partagée :

Les personnes prudentes constateront que cette méthode est la même que ce que nous avons écrit à l'origine La méthode est un peu différente, elle a un mot-clé supplémentaire :

public class Even {
    /**
     * 获取某个范围内偶数以及个数
     * @param begin 统计开始
     * @param end   统计结束
     */
    public synchronized void getEven(int begin, int end) {
        int count = 0;
        System.out.println(begin + "～" + end + "之间的偶数为：");
        if (begin % 2 != 0) {
            begin += 1;
        }

        for (; begin . Grâce à ce mot-clé, nous pouvons réaliser la synchronisation des threads lors de l'exécution des méthodes. <p><code>synchronized</code></p>3. Enfin, appelons la méthode partagée dans le fil <p><strong></strong></p>À ce moment, exécutons-la à nouveau : <pre class="brush:php;toolbar:false">public class MyTread extends Thread {
    Even even;
    
    @Override
    public void run() {
        even.getEven(begin, end);
    }
}

a obtenu l'effet que nous souhaitions.

Enfin, le code complet est joint :

/**
 * 偶数类
 */
public class Even {
    /**
     * 获取某个范围内偶数以及个数
     * @param begin 统计开始
     * @param end   统计结束
     */
    public synchronized void getEven(int begin, int end) {
        int count = 0;
        System.out.println(begin + "～" + end + "之间的偶数为：");
        if (begin % 2 != 0) {
            begin += 1;
        }

        for (; begin <p class="comments-box-content"></p>

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!