Comment utiliser Lock dans le multithreading Java

Jdk1.5 et versions ultérieures, sous le package java.util.concurrent.locks, il existe un ensemble d'interfaces et de classes pour la synchronisation des threads. Lorsqu'il s'agit de synchronisation des threads, tout le monde peut penser au mot-clé synchronisé, #🎜. 🎜##🎜 🎜#Il s'agit d'un mot-clé intégré à Java, utilisé pour gérer la synchronisation des threads, mais ce mot-clé présente de nombreux défauts et n'est pas très pratique et intuitif à utiliser, donc Lock apparaît ci-dessous, nous

#. 🎜 🎜# Comparons et expliquons Lock.

Habituellement, nous rencontrons les problèmes suivants lors de l'utilisation du mot-clé synchronisé :

(1) Incontrôlabilité, impossible de verrouiller et de déverrouiller les verrous à volonté.

(2) L'efficacité est relativement faible. Par exemple, nous lisons actuellement deux fichiers simultanément. La lecture et la lecture n'ont aucune influence l'une sur l'autre. Cependant, si la synchronisation est utilisée pour l'objet lu. réaliser la synchronisation,

Ensuite, tant qu'un thread entre, les autres threads devront attendre.

(3) Il n'y a aucun moyen de savoir si le fil a acquis le verrou.

Lock peut très bien résoudre les problèmes synchronisés ci-dessus, et après jdk1.5, divers verrous sont également fournis, tels que les verrous en lecture-écriture, mais il y a une chose à laquelle vous devez faire attention, utilisez synchronisé# 🎜🎜#

Lorsque cela est critique, il n'est pas nécessaire de déverrouiller manuellement le verrou, mais lorsque vous utilisez Lock, vous devez déverrouiller manuellement le verrou. Découvrons les verrous Lock.

Lock est une interface de couche supérieure. Son prototype est le suivant, fournissant un total de 6 méthodes :

public interface Lock {
　　// 用来获取锁，如果锁已经被其他线程获取，则一直等待，直到获取到锁
   void lock();
　　// 该方法获取锁时，可以响应中断，比如现在有两个线程，一个已经获取到了锁，另一个线程调用这个方法正在等待锁，但是此刻又不想让这个线程一直在这死等，可以通过
　　　　调用线程的Thread.interrupted()方法，来中断线程的等待过程
　　void lockInterruptibly() throws InterruptedException;
　　// tryLock方法会返回bool值，该方法会尝试着获取锁，如果获取到锁，就返回true，如果没有获取到锁，就返回false，但是该方法会立刻返回，而不会一直等待
   boolean tryLock();
　　// 这个方法和上面的tryLock差不多是一样的，只是会尝试指定的时间，如果在指定的时间内拿到了锁，则会返回true，如果在指定的时间内没有拿到锁，则会返回false
   boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
　　// 释放锁
   void unlock();
　　// 实现线程通信，相当于wait和notify，后面会单独讲解
   Condition newCondition();
}

Alors comment utiliser ces méthodes ? Comme nous l'avons mentionné précédemment, l'utilisation de Lock nécessite la libération manuelle du verrou. Cependant, si une exception est levée dans le programme, le verrou ne peut pas être libéré, ce qui peut provoquer un blocage.

Nous utilisons donc Lock , il existe un format fixe, le suivant :

Lock l = ...;
      l.lock();
      try {
      　　// access the resource protected by this lock
      } finally {// 必须使用try，最后在finally里面释放锁
      　　l.unlock();
      }

Regardons un exemple simple, le code est le suivant :

/**
 * 描述：Lock使用
 */
public class LockDemo {
    // new一个锁对象，注意此处必须声明成类对象，保持只有一把锁,ReentrantLock是Lock的唯一实现类
   Lock lock = new ReentrantLock();
   public void readFile(String fileMessage){
      lock.lock();// 上锁
      try{
         System.out.println(Thread.currentThread().getName()+"得到了锁，正在读取文件……");
         for(int i=0; i<fileMessage.length(); i++){
            System.out.print(fileMessage.charAt(i));
         }
         System.out.println();
         System.out.println("文件读取完毕！");
      }finally{
         System.out.println(Thread.currentThread().getName()+"释放了锁！");
         lock.unlock();
      }
   }
   public void demo(final String fileMessage){
      // 创建若干个线程
      ExecutorService service = Executors.newCachedThreadPool();
      // 提交20个任务
      for(int i=0; i<20; i++){
         service.execute(new Runnable() {
            @Override
            public void run() {
               readFile(fileMessage);
               try {
                  Thread.sleep(20);
               } catch (InterruptedException e) {
                  e.printStackTrace();
               }
            }
         });
      }
    // 释放线程池中的线程
      service.shutdown();
   }
}

Comparaison entre Lock et synchronisé

# 🎜🎜#

1. Function

lock et synchronisé sont deux outils utilisés en Java pour résoudre les problèmes de sécurité des threads.

2. Source

synchronisé est un mot clé en Java.

lock est une interface fournie dans le package JUC. Cette interface possède de nombreuses classes d'implémentation, y compris notre ReentrantLock (verrouillage réentrant) le plus couramment utilisé.

3. Force de verrouillage

synchronisé Vous pouvez contrôler la force de verrouillage de deux manières :

Le mot-clé synchronisé est modifié au niveau de la méthode. est décoré sur le bloc de code.

La différence entre les objets de verrouillage :

Si l'objet de verrouillage est un objet statique ou un objet de classe, alors ce verrou est un verrou global.

L'objet verrou est un objet d'instance normal, et la portée du verrou dépend du cycle de vie de l'instance.
La force du verrou est déterminée par les deux méthodes lock() et unlock(). Le code entre les deux méthodes est garanti thread-safe. La portée du verrou dépend du cycle de vie de l'instance de verrou.

4. Flexibilité

Le verrouillage est plus flexible que synchronisé.

lock peut décider indépendamment quand verrouiller et déverrouiller le verrou. Appelez simplement les méthodes lock() et unlock() de lock.

synchronisé Parce qu'il s'agit d'un mot-clé, il ne peut pas implémenter la méthode de verrouillage par compétition non bloquante. Une fois qu'un thread a acquis le verrou, les autres verrous ne peuvent qu'attendre que ce thread soit libéré avant d'avoir une chance de l'acquérir. la serrure.

5. Verrouillage équitable et verrouillage injuste

Verrouillage équitable : plusieurs threads obtiennent le verrou dans l'ordre dans lequel ils demandent le verrouillage, et les threads entreront directement dans la file d'attente pour faire la queue, et vous serez toujours le premier dans la file d'attente pour obtenir le verrou.

Avantages : Tous les threads peuvent obtenir des ressources et ne mourront pas de faim. Inconvénients : faible débit, à l'exception du premier thread de la file d'attente, tous les autres threads seront bloqués et le coût du réveil du processeur par les threads bloqués est élevé.

Verrou injuste : lorsque plusieurs threads acquièrent le verrou, ils essaieront directement de l'acquérir, s'ils ne peuvent pas l'acquérir, ils entreront dans la file d'attente. S'ils peuvent l'acquérir, ils obtiendront le verrou directement.

Avantages : cela peut réduire le coût des threads de réveil du processeur, l'efficacité globale du débit sera plus élevée et le processeur n'a pas besoin de réveiller tous les threads, ce qui réduira le nombre de threads d'éveil.

Inconvénients : Le fil de discussion au milieu de la file d'attente peut ne pas pouvoir obtenir le verrou ou ne pas pouvoir obtenir le verrou pendant une longue période, et finir par mourir de faim.
lock propose deux mécanismes : le verrouillage équitable et le verrouillage injuste (verrouillage injuste par défaut).

synchronisé est un verrouillage injuste.

6. S'il faut libérer le verrou en raison d'une exception

La libération du verrouillage synchronisé est passive, lorsque l'exécution d'un bloc de code synchronisé est synchronisée. se termine ou qu’une exception se produit sera libérée.

Lorsqu'une exception se produit dans le verrou du verrou, le verrou occupé ne sera pas activement libéré. ​​Il doit être libéré manuellement avec unlock(), nous mettons donc généralement le bloc de code de synchronisation en try-catch et écrivons. enfin, entrez la méthode unlock() pour éviter une impasse.

7. Déterminez si le verrou peut être acquis

synchronisé ne peut pas.

lock fournit une méthode de verrouillage de compétition non bloquante trylock(), et la valeur de retour est de type booléen. Il indique qu'il est utilisé pour tenter d'acquérir le verrou : il renvoie vrai si l'acquisition réussit ; il renvoie faux si l'acquisition échoue. Cette méthode retournera immédiatement quoi qu'il arrive.

8. La méthode de planification

synchronized utilise les méthodes wait, notify et notifyAll de l'objet objet lui-même, tandis que le verrouillage utilise la condition. entre les fils.

9. Peut-on l'interrompre

synchronisé ne peut qu'attendre que le verrou soit libéré et ne peut pas répondre aux interruptions.

Vous pouvez utiliser interrompu() pour interrompre en attendant le verrou.

10. Performance

Si la concurrence n'est pas féroce, la performance est à peu près la même ; lorsque la concurrence est féroce, la performance du verrouillage sera meilleure.

Lock peut également utiliser readwritelock pour séparer la lecture et l'écriture, améliorant ainsi l'efficacité des opérations de lecture multithread.

11. Mise à niveau du verrouillage synchronisé

Le bloc de code synchronisé est implémenté par une paire d'instructions monitorenter/monitorexit. L'implémentation de Monitor repose entièrement sur le verrouillage mutex à l'intérieur du système d'exploitation. Parce qu'elle nécessite de passer du mode utilisateur au mode noyau, l'opération de synchronisation est une opération lourde et indifférenciée.

La JVM propose désormais trois verrous différents : les verrous biaisés, les verrous légers et les verrous lourds.

Verrouillage biaisé :
Lorsqu'aucune concurrence ne se produit, le verrouillage biaisé est utilisé par défaut. Le thread utilisera l'opération CAS pour définir l'ID du thread sur l'en-tête de l'objet afin d'indiquer que l'objet est orienté vers le thread actuel.

Objectif : dans de nombreux scénarios d'application, le cycle de vie de la plupart des objets sera verrouillé par au plus un thread. L'utilisation de verrous biaisés peut réduire les frais généraux en l'absence de concurrence.

Verrou léger : 
La JVM compare l'ID de thread du thread actuel et l'ID de thread dans l'en-tête de l'objet Java pour voir s'ils sont cohérents (par exemple, le thread 2 veut rivaliser pour l'objet de verrouillage), alors. vous devez vérifier si le thread 1 enregistré dans l'en-tête de l'objet Java est vivant (le verrou biaisé ne sera pas activement libéré, il s'agit donc toujours de l'ID de thread stocké du thread 1 s'il ne survit pas, l'objet verrou est toujours biaisé). lock (le threadID dans l'en-tête de l'objet est celui du thread 2) ; s'il survit, alors le verrou biaisé est révoqué et mis à niveau vers un verrou de volume léger.

Lorsque d'autres threads souhaitent accéder à des ressources avec des verrous légers, l'optimisation du verrouillage tournant sera utilisée pour accéder aux ressources.

Objectif : il n'y a pas beaucoup de threads en compétition pour l'objet de verrouillage, et les threads ne maintiennent pas le verrou pendant longtemps. Parce que le blocage du thread nécessite que le processeur passe du mode utilisateur au mode noyau, ce qui coûte cher. Si le verrou est libéré peu de temps après le blocage, le gain dépassera la perte. Il est donc préférable de ne pas bloquer le thread pour le moment. laissez-le tourner en attendant que le verrou soit libéré.

Verrouillage lourd :
Si la rotation échoue, il y a une forte probabilité que l'auto-sélection échoue à nouveau, elle est donc directement mise à niveau vers un verrou lourd pour bloquer les threads et réduire la consommation du processeur.

Lorsque le verrou est mis à niveau vers un verrou lourd, les threads qui n'ont pas saisi le verrou seront bloqués et entreront dans la file d'attente de blocage.

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!