Quelle est la différence entre l'interruption et le blocage du thread Java ? Comparaison de l'interruption et du blocage du thread Java

Ce que cet article vous apporte, c'est quelle est la différence entre l'interruption et le blocage du thread Java ? La comparaison entre l'interruption du thread Java et le blocage a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer, j'espère que cela vous sera utile.

De nombreux développeurs Java (moi y compris), en particulier les novices qui viennent d'entrer dans l'industrie du logiciel, pensent que définir une interruption de thread en Java signifie que le thread s'est arrêté et ne s'exécutera pas vers l'avant,

Thread.currentThread().interrupt()

En fait, ce n'est pas le cas. L'interruption du thread est juste un état vrai signifie qu'il a été interrompu, false signifie qu'il n'a pas été interrompu

.

//Obtenir l'état d'interruption du fil, si Renvoie vrai en cas d'interruption, sinon renvoie faux
Thread.currentThread().isInterrupted()
La définition de l'interruption du fil n'affecte pas la poursuite de l'exécution du fil, mais une fois que le thread a défini l'interruption, les méthodes wait, jion et sleep sont appelées dans le thread. Une méthode qui lève immédiatement une InterruptedException et l'indicateur d'interruption est effacé et réinitialisé à false.

la classe Thread2 implémente Runnable{

    @Override
    public void run() {
        try {
            System.out.println();
            System.out.println(hread.currentThread().isInterrupted());//输出false
            Thread.currentThread().interrupt();//当前线程中断
            System.out.println("Thread.currentThread().isInterrupted());//输出true
            Thread.sleep(3000);//中断后执行sleep会抛出异常
        } catch (InterruptedException e) {
            e.printStackTrace();
            System.out.println("Thread.currentThread().isInterrupted());//输出false
        }
       
    }
}

Comment faire en sorte que le thread s'arrête vraiment et ne s'exécute pas en avant :
Pour vraiment arrêter (bloquer) le thread, Java fournit un classe d'outils de concurrence de niveau : LockSupport, il existe deux méthodes couramment utilisées dans cette classe, 1

park(Object blocker) signifie bloquer le thread spécifié, le paramètre blocker current thread object 2 unpark(Thread thread) réveille le spécifié thread, paramètre thread Spécifier l'objet thread
Exemple :

 public void test_LockSupport(){
      Thread thread=new Thread(new Thread_park());
      thread.start();//阻塞当前线程
      Thread thread2=new Thread(new Thread_unpark(thread));
      thread2.start();//唤醒被阻塞的线程
  }

  class Thread_park implements  Runnable{
    @Override
    public void run() {
        System.out.println("Thread_park开始");
        LockSupport.park(this);//阻塞当前线程
        System.out.println("Thread_park结束");
     }
  }

 class Thread_unpark implements  Runnable{
    private Thread thread;

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

    @Override
    public void run() {
        System.out.println("Thread_unpark开始");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        LockSupport.unpark(thread);//唤醒被阻塞的线程
        System.out.println("Thread_unpark结束");
    }
}

Recommandations associées :

Explication détaillée de l'utilisation du blocage de thread de la classe LockSupport dans la programmation multithread Java

Exemple de code pour le blocage et le réveil multi-thread en Java

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!