Introduction détaillée à la synchronisation Java, à l'analyse de code graphique asynchrone, bloquant et non bloquant

Cet article présente principalement des informations pertinentes sur la synchronisation Java, l'analyse asynchrone, bloquante et non bloquante. Les amis qui en ont besoin peuvent se référer à

synchronisation Java, analyse asynchrone, bloquante et non bloquante<.>

Résumé :

Dans des circonstances normales, notre programme s'exécute de manière synchrone et non bloquante. Cependant, nos programmes comporteront toujours des opérations chronophages, comme des calculs complexes (trouver des nombres premiers entre 1 et 1 milliard) et des opérations que le programme lui-même ne peut pas contrôler (opérations d'E/S, requêtes réseau). Les méthodes qui incluent ces opérations fastidieuses peuvent être appelées méthodes de blocage, et les tâches qui incluent ces opérations chronophages peuvent être appelées tâches de blocage. Le blocage et le non-blocage sont définis selon qu'ils prennent ou non du temps.

S'il y a un grand nombre d'opérations de blocage dans le programme, cela affectera les performances du programme. Mais l'existence d'un blocage est un fait objectif, et notre programme ne peut pas le changer. Une requête réseau met 3 secondes à répondre. Nous ne pouvons pas la faire répondre en 1 milliseconde, car le serveur qui accepte la requête peut être complètement hors de notre contrôle. Mais nous pouvons changer la façon dont nous gérons le blocage : gérer les tâches de blocage de manière asynchrone. La principale technologie pour réaliser l’asynchrone est le multi-threading. Illustration :

La synchronisation et l'asynchronisme sont des concepts de timing. La synchronisation signifie exécuter une seule tâche à la fois, tandis que l'asynchrone signifie exécuter plusieurs tâches en même temps.

Exemple de code

Demande de réseau simulée :

package com.zzj.asyn; 
 
public class HttpRequest { 
  private Callable callable; 
   
  public HttpRequest(Callable callable) { 
    this.callable = callable; 
  } 
   
  public void send(){ 
    // 模拟网络请求 
    try { 
      Thread.sleep(1000 * 5); 
    } catch (InterruptedException e) { 
      e.printStackTrace(); 
      Thread.currentThread().interrupt(); 
    } 
    // 回调 
    this.callable.call("Hello world!"); 
  } 
   
  public interface Callable{ 
    void call(String result); 
  } 
}

Gérer les tâches bloquantes de manière synchrone :

package com.zzj.asyn; 
 
import com.zzj.asyn.HttpRequest.Callable; 
 
/** 
 * 以同步的方式处理阻塞任务 
 * @author lenovo 
 * 
 */ 
public class App { 
  public static void main(String[] args) { 
    new HttpRequest(new Callable() { 
      @Override 
      public void call(String result) { 
        System.out.println("Thread：" + Thread.currentThread().getName()); 
        System.out.println("Message from remote server：" + result); 
      } 
    }).send(); 
    System.out.println("Thread " + Thread.currentThread().getName() + " is over!"); 
  } 
}

Résultat :

Thread：main 
Message from remote server：Hello world! 
Thread main is over!

Gérer les tâches bloquantes de manière asynchrone :

package com.zzj.asyn; 
 
import com.zzj.asyn.HttpRequest.Callable; 
 
/** 
 * 以异步的方式处理阻塞任务 
 * @author lenovo 
 * 
 */ 
public class App2 { 
  public static void main(String[] args) { 
    new Thread(new Runnable() { 
      @Override 
      public void run() { 
        new HttpRequest(new Callable() { 
          @Override 
          public void call(String result) { 
            System.out.println("Thread：" + Thread.currentThread().getName()); 
            System.out.println("Message from remote server：" + result); 
          } 
        }).send(); 
      } 
    }).start(); 
    System.out.println("Thread " + Thread.currentThread().getName() + " is over!"); 
  } 
}

Résultat :

Thread main is over! 
Thread：Thread-0 
Message from remote server：Hello world!

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!