Quelles sont les opérations couramment utilisées des threads Java ?

Opérations courantes des threads

Définissez le nom du fil : setName()

Obtenez le nom du fil : getName()

Identifiant unique du fil : getId()

// 自定义线程名称
String threadName = "threadName";
// 构造方法方式
Thread thread = new Thread(() -> {
    System.out.println("线程名=" + Thread.currentThread().getName());
},threadName);
// set方法方式
// thread.setName(threadName);
System.out.println("线程唯一Id=" + thread.getId());

Démarrage du fil : start()

Déterminez si le fil est Alive: isAlive()

// 线程启动
thread.start();
System.out.println("是否为存活线程=" + thread.isAlive());

Méthode du thread : run() /call()

Méthode qui sera appelée après le démarrage du fil. Ce que le thread veut faire est écrit dans la méthode run/call. Il n'est pas nécessaire de l'appeler directement. Une fois le thread démarré, il appellera run() /call(). Si le programme appelle directement run/call sans démarrer le thread, alors il n'appartient pas à la programmation multi-thread, mais il appartient au thread actuel pour appeler directement les méthodes ordinaires.

Obtenir l'objet thread actuel : currentThread()

Pour utiliser la méthode non statique du thread actuel, vous devez d'abord obtenir l'objet thread

// 获取当前线程对象
Thread currentThread = Thread.currentThread();
// 对当前线程做一些操作
System.out.println(currentThread.getName());
try {
    // sleep 静态方法则不需要
    Thread.sleep(1000);
} catch (InterruptedException e) {
    e.printStackTrace();
}

Pour les opérations de contrôle de l'état du thread (cycle de vie), veuillez vous référer au précédent article.

Thread démon (thread d'arrière-plan)

Le gardien des threads ordinaires (threads utilisateur). La tâche du thread démon est de fournir des services pour d'autres threads. S'il n'y a aucun thread utilisateur dans le processus, alors le thread démon n'a aucune signification et la JVM se terminera également. Les threads démons typiques incluent le thread de récupération de place de la JVM, et le démarrage du système d'exploitation démarrera également les threads démon de divers modules.

Définissez le thread comme thread démon : setDaeman()

Remarque : Cette méthode doit être appelée avant la méthode start()

public static void main(String[] args) {
    Thread thread = new Thread(() -> {
        System.out.println("线程名="+Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 这一句不会打印出来，因为main线程（目前唯一的普通线程）等待1秒后已经结束了
        System.out.println("守护线程的状态=" + Thread.currentThread().getState());
    });
    // 守护线程
    thread.setDaemon(true);
    // 线程启动
    thread.start();
    System.out.println("是否为守护线程=" + thread.isDaemon());
}

Sérialisation du thread

Le thread exécutant la méthode join() entre dans le réveil en attente state (WAITING), jusqu'à ce que le thread qui a appelé cette méthode se termine, puis passe de l'état de réveil en attente à l'état exécutable (RUNNABLE). La méthode join() est une méthode de la classe Thread. La méthode sous-jacente consiste à utiliser la méthode wait() pour réaliser l'attente du thread. Lorsque le thread isAlive() est faux, la sérialisation du thread est réalisée : un thread en appelle un autre. objet thread. join() pour implémenter l’exécution de la sérialisation des threads. Par exemple : un bon plat

public class DemoCooking {
    
    public static void main(String[] args) {
        Thread mainThread = Thread.currentThread();
        // 1.买菜
        Thread buyThread = new Thread(new CookingThread(mainThread,"买菜"),"buyThread");
        // 2.洗菜
        Thread washThread = new Thread(new CookingThread(buyThread,"洗菜"),"washThread");
        // 3.切菜
        Thread cutThread = new Thread(new CookingThread(washThread,"切菜"),"cutThread");
        // 4.炒菜
        Thread scrambleThread = new Thread(new CookingThread(cutThread,"炒菜"),"scrambleThread");

        // 不受线程启动顺序的影响
        scrambleThread.start();
        washThread.start();
        cutThread.start();
        buyThread.start();
        
        // main线程先执行完才可以开始：买菜
        System.out.println("开始准备……");
    }

    public static class CookingThread implements Runnable{
        private final Thread thread;
        private final String job;

        public CookingThread(Thread thread, String job){
            this.thread = thread;
            this.job = job;
        }
        @Override
        public void run() {
            String name = Thread.currentThread().getName()+"：";
            try {
                thread.join();

                System.out.println(name + job + "开始");
                Thread.sleep(1000);
                System.out.println(name + job + "结束");
                Thread.sleep(1000); // 偷懒下
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

Résultat de l'exécution : principal > buyThread > washThread > cutThread > scrambleThread >

washThread : Début du lavage

washThread : Fin du lavage

cutThread : Début du hachage

cutThread : Fin du hachage

scrambleThread : Début du sauté

scrambleThread : Fin du sauté

Priorité du fil

Définir la priorité du thread actuel, plus la priorité du thread est élevée, plus le thread peut être exécuté plusieurs fois. La priorité d'un thread Java est représentée par un nombre entier. La plage de priorité est de 1 à 10 et la valeur par défaut est de 5.

Méthode setPriority(int) : définit la priorité du thread.

Méthode getPriority : obtenez la priorité du fil de discussion.

public static void main(String[] args) {

    Thread thread = new Thread(() -> {
        System.out.println("线程1");
    });
    thread.setPriority(10);
    Thread thread1 = new Thread(() -> {
        System.out.println("线程2");
    });
    thread1.setPriority(1);
    thread.start();
    thread1.start();

    System.out.println("线程默认的优先级为=" + Thread.currentThread().getPriority());

}

Interruption du thread

Utilisez la méthode interruption() pour définir l'indicateur d'interruption du thread = true, de sorte qu'un signal d'interruption soit émis lorsque le thread est "bloqué". Si le thread est bloqué, en attente de réveil ou en attente d'expiration (Object.wait, Thread.join et Thread.sleep), il recevra une exception d'interruption (InterruptedException) et mettra fin à l'état plus tôt. En revanche, si le thread est dans l'état "RUNNABLE", l'indicateur d'interruption n'aura aucun effet.

Cas 1 : L'interruption du thread est valide

public static void main(String[] args) {
    Thread thread = new Thread(() -> {
        System.out.println("线程1");
        try {
            // 闹钟1分钟后响
            Thread.sleep(60000);
            System.out.println("闹钟响了");
        } catch (InterruptedException e) {
            // 提前退出超时等待状态
            System.out.println("发生异常，提前醒了，闹钟没响手动关了");
        }

        System.out.println("继续执行该线程的后续程序……");

    });
    thread.setPriority(1);
    thread.start();
    thread.interrupt();
    System.out.println("main线程将thread 终端状态设置为 "+thread.isInterrupted());
}

Résultat de l'exécution :

Le thread principal définit l'état du terminal du thread sur true

Thread 1

Une exception s'est produite et s'est réveillée tôt. L'alarme n'a pas retenti et a été désactivée manuellement.

Continuer à exécuter le suivi du programme du thread...

Cas 2 : L'interruption du thread n'est pas valide

public static void main(String[] args) {
    Thread thread1 = new Thread(() -> {
        System.out.println("线程" + Thread.currentThread().getName());
        while (true) {
            System.out.print(Thread.currentThread().getState() + "\t");
        }
    });
    thread1.start();
    thread1.interrupt();
}

Résultat de l'exécution : Le thread continue d'imprimer son statut comme RUNNABLE.

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!