Comment implémenter le multi-threading

● Héritez de la classe Thread pour créer une classe de thread et remplacez la méthode run La méthode run représente les tâches qui. le thread doit se terminer. Appelez Start() de l'objet thread pour démarrer le thread. La classe thread a hérité de la classe Thread, elle ne peut donc pas hériter des autres classes parentes.

class ThreadTest extends Thread {  

    Thread thread;  

    public ThreadTest(Thread thread) {  
      this.thread = thread;  
  }  

   @Override  
   public void run() {  
      synchronized (thread) {  
          System.out.println("getObjectLock");  
         try {  
             Thread.sleep(9000);  
       } catch (InterruptedException ex) {  
          ex.printStackTrace();  
         }  
           System.out.println("ReleaseObjectLock");  
    }  
   }  
 }

Copier après la connexion

● Implémentez l'interface Runnable pour créer une classe de thread, définissez la classe d'implémentation Runnable et remplacez la méthode run

  class RunnableImpl implements Runnable {  
    
     public void run() {  
          try {  
             System.out.println("Begin sleep");  
             Thread.sleep(2000);  
             System.out.println("End sleep");  
          } catch (InterruptedException e) {  
              e.printStackTrace();  
          }  
      }  
   }

Copier après la connexion

● Implémentez l'interface Callable, remplacez l'appel ( ), méthode call() En tant que corps d'exécution du thread, il a une valeur de retour

● Pool de threads, utilisant le pool de threads pour générer des objets de thread java.util.concurrent.ExecutorService, java.util.concurrent .Executors;

Comment l'implémenter dans la sécurité des threads Java

● Synchronisation mutuellement exclusive : il est recommandé d'utiliser le mot-clé synchronisé pour la synchronisation. Il existe la classe ReentrantLock dans le package simultané, qui. a des effets de mise en œuvre similaires. L'original synchronisé est toujours recommandé
. ● Synchronisation non bloquante : nécessite des instructions matérielles. Les instructions couramment utilisées sont : Test-and-Set Fetch-and-Increment Swap Compare-and-Swap (CAS) Load-Linked/Store-Conditional (LL/SC) Applications typiques. : AtomicInteger dans
● Pas de solution de synchronisation : enregistrez les variables dans le thread local afin qu'il n'y ait pas d'erreurs simultanées de plusieurs threads. La principale chose utilisée en Java est la classe ThreadLocal.

Méthode Join()

thread.Join ajoute le thread spécifié au thread actuel et peut fusionner deux threads s'exécutant alternativement en threads d'exécution séquentielle. Par exemple, si la méthode Join() du thread A est appelée dans le thread B, le thread B ne continuera pas à s'exécuter jusqu'à ce que le thread A termine son exécution.

t.join(); // Laissez le thread appelant terminer son exécution avant cela.
t.join(1000); //En attente du thread t, le temps d'attente est de 1000 millisecondes, quel que soit le délai d'attente

public class JoinTest implements Runnable{  

    public static int a = 0;  

    public void run() {  
        for (int k = 0; k < 5; k++) {  
            a = a + 1;  
        }  
    }  

    public static void main(String[] args) throws Exception {  
        Runnable r = new JoinTest();  
        Thread t = new Thread(r);  
        t.start();        
        t.join();//等待t线程完成后输出，可保证a=5；
        System.out.println(a);  
    }         
}

Copier après la connexion

wait()

Il y a trois attentes méthodes d'Object Il existe des méthodes surchargées, dont l'une, wait(), attend indéfiniment (toujours) jusqu'à ce que d'autres threads appellent la méthode notify ou notifyAll pour réveiller le thread actuel, les deux autres méthodes sont wait(long timeout) et wait( ; long timeout, int nanos) Il est autorisé à passer le temps pendant lequel le thread actuel doit attendre avant d'être réveillé. Le délai d'attente est le nombre de millisecondes et nanos est le nombre de nanosecondes.

notify()

La méthode notify réveille uniquement un thread en attente (de l'objet) et provoque le démarrage de l'exécution du thread. Ainsi, si plusieurs threads attendent un objet, cette méthode ne réveillera qu'un seul des threads, et le thread à choisir dépend de l'implémentation de la gestion multi-thread par le système d'exploitation.

notifyAll()

notifyAll réveillera tous les threads en attente, bien que le thread qui le traitera en premier dépende de l'implémentation du système d'exploitation.
Ces méthodes peuvent être utilisées dans le problème "producteur-consommateur". Le consommateur est le thread qui attend l'objet dans la file d'attente, et le producteur est le thread qui libère l'objet dans la file d'attente et informe les autres threads.

Comment implémenter le multi-threading

● Héritez de la classe Thread pour créer une classe de thread et remplacez la méthode run La méthode run représente la tâche que le thread doit accomplir. () de l'objet thread pour démarrer le thread, la classe thread a hérité de la classe Thread, elle ne peut donc pas hériter d'autres classes parent.

class ThreadTest extends Thread {  

    Thread thread;  

    public ThreadTest(Thread thread) {  
      this.thread = thread;  
  }  

   @Override  
   public void run() {  
      synchronized (thread) {  
          System.out.println("getObjectLock");  
         try {  
             Thread.sleep(9000);  
       } catch (InterruptedException ex) {  
          ex.printStackTrace();  
         }  
           System.out.println("ReleaseObjectLock");  
    }  
   }  
 }

Copier après la connexion

● Implémentez l'interface Runnable pour créer une classe de thread, définissez la classe d'implémentation Runnable et remplacez la méthode run

  class RunnableImpl implements Runnable {  
    
      public void run() {  
          try {  
              System.out.println("Begin sleep");  
              Thread.sleep(2000);  
              System.out.println("End sleep");  
          } catch (InterruptedException e) {  
              e.printStackTrace();  
           }  
       }  
   }

Copier après la connexion

● Implémentez l'interface Callable, remplacez l'appel ( ), méthode call() En tant que corps d'exécution du thread, il a une valeur de retour

● Pool de threads, utilisant le pool de threads pour générer des objets de thread java.util.concurrent.ExecutorService, java.util.concurrent .Executors;

Comment l'implémenter dans la sécurité des threads Java

Méthode Join()

t.join(); // Laissez le thread appelant terminer son exécution avant cela.
t.join(1000); //En attente du thread t, le temps d'attente est de 1000 millisecondes, quel que soit le délai d'attente

public class JoinTest implements Runnable{  

    public static int a = 0;  

    public void run() {  
        for (int k = 0; k < 5; k++) {  
            a = a + 1;  
        }  
    }  

    public static void main(String[] args) throws Exception {  
        Runnable r = new JoinTest();  
        Thread t = new Thread(r);  
        t.start();        
        t.join();//等待t线程完成后输出，可保证a=5；
        System.out.println(a);  
    }         
}

Copier après la connexion