Explication détaillée de la synchronisation des threads Java et des méthodes de synchronisation

Cet article présente principalement les threads Java à travers des exemples : méthode de synchronisation-synchronisation des threads. Les amis dans le besoin peuvent s'y référer

La synchronisation des threads consiste à assurer un accès multithread sécuritéaux ressources concurrentes. un moyen.

La synchronisation des threads est la difficulté de la programmation multithread Java. Les développeurs ne comprennent souvent pas ce que sont les ressources concurrentes, quand la synchronisation doit être prise en compte, comment synchroniser, etc. , ces problèmes Il n'y a pas de réponse claire, mais certaines questions principales doivent être prises en compte. Des ressources concurrentes sont-elles modifiées en même temps ?

Pour la synchronisation, les deux opérations suivantes doivent être effectuées dans le code Java spécifique :

Marquer la ressource en concurrence pour l'accès comme privée ;
Pour synchroniser le code qui modifie les

variables

, utilisez le mot-clé synchronisé pour synchroniser les méthodes ou les codes.
Bien sûr, ce n'est pas le seul moyen de contrôler la sécurité de la concurrence.

Les instructions d'utilisation du mot-clé synchronisé

synchronized ne peuvent marquer que les méthodes non abstraites et ne peuvent pas identifier les variables membres.

Afin de démontrer l'utilisation de la méthode de synchronisation, un compte de carte de crédit a été construit avec une limite de crédit initiale de 1 million, puis plusieurs opérations telles que le découvert et le dépôt ont été simulées. Évidemment, le compte bancaire User

object

est une ressource concurrente, et la méthode de compte oper(int x) est utilisée pour plusieurs opérations simultanées. Bien entendu, la synchronisation doit être ajoutée à cette méthode, ainsi que le solde du compte. doit être défini comme variable privée L'accès direct est interdit.

/** 
* Java线程：线程的同步 
* 
* @author leizhimin 2009-11-4 11:23:32 
*/ 
public class Test { 
  public static void main(String[] args) { 
    User u = new User("张三", 100); 
    MyThread t1 = new MyThread("线程A", u, 20); 
    MyThread t2 = new MyThread("线程B", u, -60); 
    MyThread t3 = new MyThread("线程C", u, -80); 
    MyThread t4 = new MyThread("线程D", u, -30); 
    MyThread t5 = new MyThread("线程E", u, 32); 
    MyThread t6 = new MyThread("线程F", u, 21); 
    t1.start(); 
    t2.start(); 
    t3.start(); 
    t4.start(); 
    t5.start(); 
    t6.start(); 
  } 
} 
class MyThread extends Thread { 
  private User u; 
  private int y = 0; 
   MyThread(String name, User u, int y) { 
    super(name); 
    this.u = u; 
    this.y = y; 
  } 
  public void run() { 
    u.oper(y); 
  } 
} 
class User { 
  private String code; 
  private int cash; 
  User(String code, int cash) { 
    this.code = code; 
    this.cash = cash; 
  } 
  public String getCode() { 
    return code; 
  } 
  public void setCode(String code) { 
    this.code = code; 
  } 
  /** 
   * 业务方法 
   * @param x 添加x万元 
   */ 
  public synchronized void oper(int x) { 
    try { 
      Thread.sleep(10L); 
      this.cash += x; 
      System.out.println(Thread.currentThread().getName() + "运行结束，增加“" + x + "”，当前用户账户余额为：" + cash); 
      Thread.sleep(10L); 
    } catch (InterruptedException e) { 
      e.printStackTrace(); 
    } 
  } 
  @Override 
  public String toString() { 
    return "User{" + 
        "code='" + code + '\'' + 
        ", cash=" + cash + 
        '}'; 
  } 
}

Résultat de sortie :

线程A运行结束，增加“20”，当前用户账户余额为：120 
线程F运行结束，增加“21”，当前用户账户余额为：141 
线程E运行结束，增加“32”，当前用户账户余额为：173 
线程C运行结束，增加“-80”，当前用户账户余额为：93 
线程B运行结束，增加“-60”，当前用户账户余额为：33 
线程D运行结束，增加“-30”，当前用户账户余额为：3

Matériel pédagogique négatif, situation désynchronisée, c'est-à-dire supprimer la modification synchronisée de l'opérateur ( int x), puis exécutez le programme, le résultat est le suivant :

De toute évidence, le résultat ci-dessus est faux. La raison de l'erreur est que plusieurs threads accèdent simultanément au. La ressource concurrente u et les

线程A运行结束，增加“20”，当前用户账户余额为：61 
线程D运行结束，增加“-30”，当前用户账户余额为：63 
线程B运行结束，增加“-60”，当前用户账户余额为：3 
线程F运行结束，增加“21”，当前用户账户余额为：61 
线程E运行结束，增加“32”，当前用户账户余额为：93 
线程C运行结束，增加“-80”，当前用户账户余额为：61

attributs

modifiés de u ont été modifiés.
Vous pouvez voir l'importance de la synchronisation.

Remarque :

Comme le montre l'article précédent, lorsque le fil

quitte la méthode de synchronisation

, le Le verrou de l'objet auquel appartient la méthode sera libéré. ​​Mais il convient également de noter que des méthodes spécifiques peuvent également être utilisées pour planifier des threads dans les méthodes de synchronisation. Ces méthodes proviennent de la classe java.lang.Object.

En combinant les méthodes ci-dessus, il est très important de traiter les problèmes de synchronisation multi-thread et d'exclusion mutuelle. Le célèbre exemple producteur-consommateur est un exemple classique qui doit être appris pour le multi-threading dans tout. langue.

void notify()  
     唤醒在此对象监视器上等待的单个线程。  
void notifyAll()  
     唤醒在此对象监视器上等待的所有线程。  
void wait()  
     导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法。  
void wait(long timeout)  
     导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量。  
void wait(long timeout, int nanos)  
     导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量

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!