Exemples d'utilisation de verrous dans la programmation multithread Java

Lock est un outil qui contrôle l’accès de plusieurs threads aux ressources partagées. En règle générale, un verrou fournit un accès exclusif à une ressource partagée. Un seul thread peut acquérir un verrou à la fois, et tout accès à une ressource partagée nécessite d'abord l'acquisition du verrou. Cependant, certains verrous peuvent permettre un accès simultané à des ressources partagées, comme ReadWriteLock (un verrou en lecture-écriture qui maintient une paire de verrous associés, l'un pour les opérations en lecture seule et l'autre pour les opérations d'écriture).

1. Lock fournit des opérations d'acquisition de verrouillage inconditionnelles, interrogeables, chronométrées et interrompues. Toutes les méthodes de verrouillage et de déverrouillage sont explicites.

public interface Lock{
  void lock(); //加锁
  //优先考虑响应中断，而不是响应锁定的普通获取或重入获取
  void lockInterruptibly() throws InterruptedException;
  boolean tryLock(); //可定时和可轮询的锁获取模式
  boolean tryLock(long timeout,TimeUnit unit) throws InterruptedException;
  void unlock(); //解锁
  Condition newCondition();
}

2. ReentrantLock implémente l'interface de verrouillage Par rapport à synchronisé, ReentrantLock offre plus de flexibilité pour gérer les verrous indisponibles.
3. La forme canonique d'utilisation de l'interface de verrouillage nécessite de libérer le verrou lock.unlock() dans le bloc final. Si le code gardant le verrou lève une exception en dehors du bloc try, elle ne sera jamais libérée.

Ce qui suit simule l'utilisation du verrou : supposons qu'il existe deux threads (un thread A, un thread B) pour appeler la méthode print (String name), un thread A est responsable de l'impression de la chaîne 'zhangsan' et un thread B. est responsable de l'impression de la chaîne de caractères 'lisi'.
1. Lorsque la méthode print(String name) n'est pas verrouillée, il arrivera que le thread A n'ait pas terminé l'exécution et que le thread B ait commencé l'exécution. Le nom imprimé aura alors les problèmes suivants.

2. Lorsqu'un verrou est ajouté à la méthode print(String name), le thread B exécutera la méthode print(String name) uniquement après que A ait terminé l'exécution pour obtenir un effet d'exclusion mutuelle ou de synchronisation.

package com.ljq.test.thread;
  
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
  
/**
 * 用Lock替代synchronized
 *
 * @author Administrator
 *
 */
public class LockTest {
  
  public static void main(String[] args) {
    new LockTest().init();
  }
  
  private void init() {
    final Outputer outputer = new Outputer();
    //A线程
    new Thread(new Runnable() {
      @Override
      public void run() {
        while (true) {
          try {
            Thread.sleep(10);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
          outputer.output("zhangsan");
        }
  
      }
    }).start();
  
    //B线程
    new Thread(new Runnable() {
      @Override
      public void run() {
        while (true) {
          try {
            Thread.sleep(10);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
          outputer.output("lisi");
        }
  
      }
    }).start();
  
  }
  
  static class Outputer {
    Lock lock = new ReentrantLock();
  
    /**
     * 打印字符
     *
     * @param name
     */
    public void output(String name) {
      int len = name.length();
      lock.lock();
      try {
        for (int i = 0; i < len; i++) {
          System.out.print(name.charAt(i));
        }
        System.out.println();
      } finally {
        lock.unlock();
      }
    }
  }
}

Pour plus d'articles liés aux exemples d'utilisation de Lock dans la programmation multi-thread Java, veuillez faire attention au site Web PHP chinois !