Résumé des méthodes de programmation multithread Java (avec exemples)

Cet article vous présente un résumé des méthodes d'implémentation multi-thread Java (avec des exemples). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

1. Quand utiliser la programmation multithread

Une tâche est exécutée séquentiellement dans des circonstances normales, mais s'il existe plusieurs blocs de processus similaires dans la tâche en cours (comme les instructions for, while) , nous pouvons envisager d'extraire ces blocs de code pour les exécuter en parallèle sans bloquer

2 Plusieurs façons d'implémenter le multi-threading

L'une consiste à hériter de la classe Thread et à réécrire la méthode run, et la. autre La première consiste à implémenter l'interface Runnable et à réécrire la méthode d'exécution

Dans de nombreux cas, démarrer plusieurs threads consiste à gérer des processus simultanés. performances temporelles, nous pouvons également implémenter des files d'attente.

3. Exemple

Hérite du fil de discussion

/**
 * 
* @ClassName: ThreadByEx  
* @Description: TODO
* @author Mr.jqCheng
* @date 2018年9月26日  
* */public class ThreadByEx extends Thread{

    @Override    public void run() {        // TODO Auto-generated method stub
        System.out.println("我是继承线程");
    }

}

Implements Runnable

/**
 * 
* @ClassName: ThreadByRunnable  
* @Description: TODO
* @author Mr.jqCheng
* @date 2018年9月26日  
* */public class ThreadByRunnable implements Runnable{    /*public ThreadByRunnable() {
        this.run();
        // TODO Auto-generated constructor stub
    }*/

    public void run() {        // TODO Auto-generated method stub
        System.out.println("我是实现进程");
    }

}

Test :

/**
 * 
* @ClassName: Test  
* @Description: TODO
* @author Mr.jqCheng
* @date 2018年9月26日  
* */public class Test {    public static void main(String[] args) {        // 继承Thread启动的方法
        ThreadByEx t1 = new ThreadByEx();
        t1.start();// 启动线程        // 实现Runnable启动线程的方法
        ThreadByRunnable r = new ThreadByRunnable();
        Thread t2 = new Thread(r);
        t2.start();// 启动线程        //new ThreadByRunnable();    }

}

Exécution des résultats :

Je suis un thread d'héritage
Je suis un processus d'implémentation

ok, l'implémentation multi-thread simple est terminée Lorsque start() est appelé, le processus est entré dans l'exécutable. state , en attente de l'exécution du système.

Plusieurs méthodes courantes de traitement des threads :

void interrompu() : Envoie une demande d'interruption au thread, l'état d'interruption du thread sera défini sur true, si le thread actuel est bloqué par un appel sleep , une exception interrompue sera levée.

static boolean interrompu() : Teste si le thread actuel (le thread exécutant actuellement la commande) est interrompu. Notez qu'il s'agit d'une méthode statique. L'appel de cette méthode aura un effet secondaire, c'est-à-dire qu'elle réinitialisera l'état d'interruption du thread actuel sur false.

boolean isInterrupted() : Détermine si le thread a été interrompu. L'appel de cette méthode n'aura pas d'effets secondaires, c'est-à-dire qu'il ne modifiera pas l'état d'interruption actuel du thread.

static Thread currentThread() : renvoie l'objet Thread représentant le thread d'exécution actuel.

Le processus démon

est utilisé pour servir tous les threads sous tous les autres processus actuels qui ne sont pas des processus de service

Implémentez simplement deamon.setDaemon(true), avant que le thread ne soit démarré Activer

Exemple

package com.orange.util;
/**
 * 
 * @ClassName: Test
 * @Description: TODO
 * @author Mr.jqCheng
 * @date 2018年9月26日
 *
 */
public class Test {
    public static void main(String[] args) {
        Thread deamon2 = new Thread(new DaemonRunner2(), "otherRunner");
        deamon2.start();// 启动线程
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Thread deamon = new Thread(new DaemonRunner(), "DaemonRunner");
        // 设置为守护线程
        deamon.setDaemon(true);
        deamon.start();// 启动线程
    }
    static class DaemonRunner implements Runnable {
        public void run() {
            // TODO Auto-generated method stub
            try {
                Thread.sleep(300);
                Thread t = Thread.currentThread();
                System.out.println(t);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                System.out.println("进入守护线程，说明现在还有其他线程在执行");
            }
        }
    }
    static class DaemonRunner2 implements Runnable {
        public void run() {
            // TODO Auto-generated method stub
            try {
                Thread.sleep(1500);
                System.out.println("我是其他线程");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

Résultat de l'exécution :

Thread[DaemonRunner,5,main]
entre dans le thread démon, indiquant qu'il y a d'autres threads en cours d'exécution
Je suis un autre thread

Tout d'abord, démarrez d'autres threads, ce qui prend 1 500 ms. En même temps, après que le thread principal ait pris 1 000 ms, il commence à entrer dans le thread démon. toujours en cours d'exécution. En ce qui concerne le thread démon, cela prend 300 ms, d'autres threads sont toujours en cours d'exécution, continuez vers le bas, le thread démon est exécuté

Mais si je change les 300 ms du thread démon en 500 ms, que se passera-t-il ?

Il y a eu deux situations. Après tout, à la valeur critique

1 Je suis un autre fil

2. entre dans le thread démon, indiquant qu'il y a d'autres threads en cours d'exécution
Je suis un autre thread

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!