Pourquoi la synchronisation est nécessaire

Java permet le contr?le de concurrence multithread lorsque plusieurs threads exploitent des variables de ressources partagées. (tels que l'ajout, la suppression, la modification et l'interrogation de données) entra?neront des données inexactes et des conflits les uns avec les autres. Par conséquent, un verrou de synchronisation est ajouté pour éviter d'être appelé par d'autres threads avant que le thread ne termine l'opération, garantissant ainsi que le thread. Unicité et précision des variables.

1. Exemple

Par exemple, si un compte bancaire est géré par deux threads en même temps, l'un prend 100 yuans et l'autre dépose 100 yuans. Supposons que le compte ait à l'origine 0 bloc. Si le thread de retrait et le thread de dép?t se produisent en même temps, que se passera-t-il ? Le retrait a échoué et le solde du compte est de 100. Le retrait a réussi et le solde du compte est de 0. Mais quel équilibre correspond à quoi ? C'est difficile à dire clairement, donc le problème de la synchronisation multithread se pose.

2. Situation sans synchronisation

Par exemple, si un compte bancaire est géré par deux threads en même temps, l'un prend 100 yuans et l'autre dépose 100 yuans . Supposons que le compte ait à l'origine 0 bloc. Si le thread de retrait et le thread de dép?t se produisent en même temps, que se passera-t-il ? Si le retrait d’argent échoue, le solde du compte est de 100. Si le retrait d’argent réussit, le solde du compte est de 0. Mais quel équilibre correspond à quoi ? C'est difficile à dire clairement, donc le problème de la synchronisation multi-thread se pose.

public class Bank {
   private int count =0;//賬戶余額
   
   //存錢
   public  void addMoney(int money){
       count +=money;
       System.out.println(System.currentTimeMillis()+"存進："+money);
   }
    
    //取錢
    public  void subMoney(int money){
        if(count-money < 0){
            System.out.println("余額不足");
            return;
        }
        count -=money;
        System.out.println(+System.currentTimeMillis()+"取出："+money);
    }
    
    //查詢
    public void lookMoney(){
        System.out.println("賬戶余額："+count);
    }
}

package threadTest;
public class SyncThreadTest {
public static void main(String args[]){
final Bank bank=new Bank();
Thread tadd=new Thread(new Runnable() {
    
    @Override
    public void run() {
        // TODO Auto-generated method stub
        while(true){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            bank.addMoney(100);
            bank.lookMoney();
            System.out.println("\n");
            
        }
    }
});
Thread tsub = new Thread(new Runnable() {
    
    @Override
    public void run() {
        // TODO Auto-generated method stub
        while(true){
            bank.subMoney(100);
            bank.lookMoney();
            System.out.println("\n");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }    
        }
    }
});
tsub.start();
tadd.start();
}
}

Résultats d'exécution?:

1502542307917取出：100
賬號余額：100
1502542308917存進:100
1502542308917取出：100
賬號余額：0
賬號余額：0
1502542309917存進:100
賬號余額：0
1502542309917取出：100
賬號余額：0

Un problème de sécurité non lié aux threads se produit à ce moment-là, car deux threads accèdent à une méthode non synchronisée en même temps si ces deux threads exploitent des instances dans l'objet métier. en même temps, des problèmes de sécurité non liés aux threads peuvent survenir.

Solution?: ajoutez simplement le mot-clé synchronisé devant public void run().

3. Méthode de synchronisation

Méthode de modification de mot-clé synchronisé

Il existe une méthode de modification de mot-clé synchronisée. étant donné que chaque objet en Java possède un verrou intégré, lorsqu'une méthode est modifiée avec ce mot-clé, le verrou intégré protégera l'intégralité de la méthode. Avant d'appeler cette méthode, vous devez obtenir le verrou intégré, sinon il sera bloqué.

Code tel que :

public synchronized void save(){}

Remarque : le mot-clé synchronisé peut également modifier les méthodes statiques. à ce stade, si la méthode statique est appelée, la classe entière sera verrouillée.

public class Bank {
private int count =0;//賬戶余額
//存錢
public  synchronized void addMoney(int money){
count +=money;
System.out.println(System.currentTimeMillis()+"存進："+money);
}
//取錢
public  synchronized void subMoney(int money){
if(count-money < 0){
    System.out.println("余額不足");
    return;
}
count -=money;
System.out.println(+System.currentTimeMillis()+"取出："+money);
}
//查詢
public void lookMoney(){
System.out.println("賬戶余額："+count);
}
}

Résultat d'exécution?:

余額不足
賬號余額：0
1502543814934存進:100
賬號余額：100
1502543815934存進:100
賬號余額：200
1502543815934取出：100
賬號余額：100

La synchronisation des threads est obtenue de cette manière

Le bloc de code synchronisé

est modifié avec le synchronisé bloc d'instructions de mots-clés.

Le bloc d'instructions modifié par ce mot-clé sera automatiquement ajouté avec un verrou intégré pour réaliser la synchronisation.

Code tel que?:

synchronized(object){ 
}

Remarque?: la synchronisation est un fonctionnement de la méthode de co?t, le contenu synchronisé doit donc être minimisé.

Habituellement, il n'est pas nécessaire de synchroniser l'ensemble de la méthode, utilisez simplement des blocs de code synchronisés pour synchroniser le code clé.

public class Bank {
private int count =0;//賬戶余額
//存錢
public  void addMoney(int money){
synchronized (this) {
    count +=money;
}
System.out.println(System.currentTimeMillis()+"存進："+money);
}
//取錢
public   void subMoney(int money){
synchronized (this) {
    if(count-money < 0){
        System.out.println("余額不足");
        return;
    }
    count -=money;
}
System.out.println(+System.currentTimeMillis()+"取出："+money);
}
//查詢
public void lookMoney(){
System.out.println("賬戶余額："+count);
}
}

Les résultats d'exécution sont les suivants?:

余額不足
賬戶余額：0
余額不足
賬戶余額：100
1502544966411存進：100
賬戶余額：100
1502544967411存進：100
賬戶余額：100
1502544967411取出：100
賬戶余額：100
1502544968422取出：100

Cela permet également la synchronisation des threads, et l'efficacité opérationnelle est supérieure à celle de la synchronisation des méthodes. La synchronisation est une opération co?teuse, la synchronisation doit donc être minimisée. . contenu. Habituellement, il n'est pas nécessaire de synchroniser l'intégralité de la méthode, utilisez simplement des blocs de code synchronisés pour synchroniser le code clé.

Utiliser des variables de domaine spéciales (volatiles) pour réaliser la synchronisation des threads

un mot-clé.volatile fournit un mécanisme sans verrouillage pour l'accès aux variables membres

b. Utiliser volatile pour modifier les variables membres équivaut à indiquer à la machine virtuelle que le champ peut être mis à jour par d'autres threads

c Par conséquent, chaque fois que la variable membre est utilisée, elle doit être recalculée à la place ; en utilisant la valeur dans le registre. Value;

d.volatile ne fournit aucune opération atomique et ne peut pas non plus être utilisé pour modifier les variables de type final.

Le code Bank.java est le suivant?:

package com.thread.demo;
/**
* Created by HJS on 2017/8/12.
*/
public class Bank {
private volatile int count =0;//賬戶余額
//存錢
public  void addMoney(int money){
synchronized (this) {
    count +=money;
}
System.out.println(System.currentTimeMillis()+"存進："+money);
}
//取錢
public   void subMoney(int money){
synchronized (this) {
    if(count-money < 0){
        System.out.println("余額不足");
        return;
    }
    count -=money;
}
System.out.println(+System.currentTimeMillis()+"取出："+money);
}
//查詢
public void lookMoney(){
System.out.println("賬戶余額："+count);
}
}

Résultat d'exécution?:

余額不足
賬戶余額：0
余額不足
賬戶余額：100
1502546287474存進：100
賬戶余額：100
1502546288474存進：100
1502546288474取出：100
賬戶余額：100

à ce moment, la commande est à nouveau foirée, indiquant qu'il y a un autre problème de synchronisation, car volatile ne peut pas garantir les opérations atomiques. En raison de cela, volatile ne peut pas remplacer synchronisé. De plus, volatile empêchera le compilateur d'optimiser le code, donc si vous ne pouvez pas l'utiliser, ne l'appliquez pas. Son principe est que chaque fois qu'un thread veut accéder à une variable volatile modifiée, il la lit dans la mémoire au lieu de la lire dans le cache, donc la valeur de la variable accédée par chaque thread est la même. Cela garantit la synchronisation.

Utilisation de verrous de réentrance pour réaliser la synchronisation des threads

Un nouveau package java.util.concurrent a été ajouté dans JavaSE5.0 pour prendre en charge la synchronisation. La classe ReentrantLock est un verrou réentrant et mutuellement exclusif qui implémente l'interface Lock. Il a le même comportement de base et la même sémantique que l'utilisation de méthodes et de blocs synchronisés, et étend ses capacités.

Les méthodes courantes de la classe ReenreantLock sont :

ReentrantLock() : Créer une instance ReentrantLock

lock() : Obtenir le verrou

unlock() : Release Lock

Remarque?: ReentrantLock() a également une méthode de construction qui peut créer un verrou équitable, mais elle n'est pas recommandée car elle peut réduire considérablement l'efficacité de fonctionnement du programme.

Le code Bank.java est modifié comme suit :

public class Bank {
private  int count = 0;// 賬戶余額
//需要聲明這個鎖
private Lock lock = new ReentrantLock();
// 存錢
public void addMoney(int money) {
lock.lock();//上鎖
try{
    count += money;
    System.out.println(System.currentTimeMillis() + "存進：" + money);
}finally{
    lock.unlock();//解鎖
}
}
// 取錢
public void subMoney(int money) {
lock.lock();
try{
    if (count - money < 0) {
        System.out.println("余額不足");
        return;
    }
    count -= money;
    System.out.println(+System.currentTimeMillis() + "取出：" + money);
}finally{
    lock.unlock();
}
}
// 查詢
public void lookMoney() {
System.out.println("賬戶余額：" + count);
}
}

Résultats d'exécution :

余額不足
賬戶余額：0
1502547439892存進：100
賬戶余額：100
1502547440892存進：100
賬戶余額：200
1502547440892取出：100
賬戶余額：100

Remarque : concernant la sélection de l'objet Lock et du mot-clé synchronisé :

a. Il est préférable de n'utiliser aucun d'entre eux et d'utiliser un mécanisme fourni par le package java.util.concurrent pour aider les utilisateurs à gérer tout le code lié au verrouillage.

b.如果synchronized關鍵字能滿足用戶的需求，就用synchronized，因為它能簡化代碼。

c.如果需要更高級的功能，就用ReentrantLock類，此時要注意及時釋放鎖，否則會出現(xiàn)死鎖，通常在finally代碼釋放鎖 。

使用局部變量實現(xiàn)線程同步

代碼如下：

public class Bank {
private static ThreadLocal<Integer> count = new ThreadLocal<Integer>(){
@Override
protected Integer initialValue() {
    // TODO Auto-generated method stub
    return 0;
}
};
// 存錢
public void addMoney(int money) {
count.set(count.get()+money);
System.out.println(System.currentTimeMillis() + "存進：" + money);
}
// 取錢
public void subMoney(int money) {
if (count.get() - money < 0) {
    System.out.println("余額不足");
    return;
}
count.set(count.get()- money);
System.out.println(+System.currentTimeMillis() + "取出：" + money);
}
// 查詢
public void lookMoney() {
System.out.println("賬戶余額：" + count.get());
}
}

運行結果如下：

復制代碼
余額不足
賬戶余額：0
余額不足
1502547748383存進：100
賬戶余額：100
賬戶余額：0
余額不足
賬戶余額：0
1502547749383存進：100
賬戶余額：200

看了運行效果，一開始一頭霧水，怎么只讓存，不讓取??？看看ThreadLocal的原理：

如果使用ThreadLocal管理變量，則每一個使用該變量的線程都獲得該變量的副本，副本之間相互獨立，這樣每一個線程都可以隨意修改自己的變量副本，而不會對其他線程產(chǎn)生影響?，F(xiàn)在明白了吧，原來每個線程運行的都是一個副本，也就是說存錢和取錢是兩個賬戶，知識名字相同而已。所以就會發(fā)生上面的效果。

ThreadLocal 類的常用方法

ThreadLocal() : 創(chuàng)建一個線程本地變量? ? ?

get() : 返回此線程局部變量的當前線程副本中的值? ? ?

initialValue() : 返回此線程局部變量的當前線程的"初始值"? ? ?

set(T value) : 將此線程局部變量的當前線程副本中的值設置為value

注：ThreadLocal與同步機制

a.ThreadLocal與同步機制都是為了解決多線程中相同變量的訪問沖突問題。?

b.前者采用以"空間換時間"的方法，后者采用以"時間換空間"的方式。

php中文網(wǎng)，大量的免費Java入門教程，歡迎在線學習！

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!