L'utilisation et les concepts de base des threads dans la concurrence Java

Définition du thread

Un thread, parfois appelé processus léger (LWP), est la plus petite unité du flux d'exécution d'un programme. Un thread standard se compose d'un ID de thread, d'un pointeur d'instruction actuel (PC), d'un ensemble de registres et d'une pile. Sans mécanisme de coordination explicite, les threads s'exécuteront indépendamment les uns des autres. Chaque programme possède au moins un thread. Si un programme n'a qu'un seul thread, c'est le programme lui-même.

Un thread est une entité dans un processus et est une unité de base qui est planifiée et distribuée indépendamment par le système. Le thread lui-même ne possède pas de ressources système, seulement certaines ressources essentielles au fonctionnement, mais il peut le faire. être partagé avec le même Les autres threads d'un processus partagent toutes les ressources appartenant au processus (partagent l'espace d'adressage mémoire du processus), de sorte que ces threads peuvent accéder aux mêmes variables et allouer des objets sur le même tas, ce qui nécessite une méthode de partage entre les processus. Un mécanisme de partage de données avec une granularité plus fine des données. Sans ce mécanisme de synchronisation, des conséquences imprévisibles se produiront dans les situations multithread.

Un thread peut créer et détruire un autre thread, et plusieurs threads du même processus peuvent s'exécuter simultanément. En raison des contraintes mutuelles entre les threads, les threads présentent une discontinuité dans leur fonctionnement. Les threads ont également trois états de base : prêt, bloqué et en cours d'exécution. L'état prêt signifie que le thread a toutes les conditions pour s'exécuter, peut s'exécuter logiquement et attend le processeur ; l'état en cours d'exécution signifie que le thread occupe le processeur et est en cours d'exécution ; événement (comme un sémaphore), et la logique n'est pas exécutoire.

Un thread est un processus de contrôle séquentiel unique dans un programme. Unité d'exécution relativement indépendante et planifiable au sein d'un processus. Il s'agit de l'unité de base permettant au système de planifier et d'allouer indépendamment le processeur. Elle fait référence à l'unité de planification du programme en cours d'exécution. L’exécution de plusieurs threads en même temps pour effectuer différentes tâches dans un seul programme est appelée multithreading.

Threads en Java

Le point d'entrée d'un programme Java est la méthode principale. Il démarre l'exécution en appelant la méthode principale, puis s'exécute selon la logique du code. les threads sont impliqués. En fait, le programme Java est intrinsèquement Dans un programme multi-thread, l'exécution d'une méthode principale est en fait un thread nommé main et les autres threads sont exécutés séparément. Le code de référence est le suivant :

Code. (se référer à l'art de la programmation simultanée Java)

package com.sunld;import java.lang.management.ManagementFactory;import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;/**
 * @Title: TestMainThread.java
 * @Package com.sunld
 * <p>Description:</p>
 * @author sunld
 * @version V1.0.0 
 * <p>CreateDate:2017年9月28日 下午3:54:19</p>
*/public class TestMainThread {

    public static void main(String[] args) {        // 获取Java线程管理MXBean
        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();        // 不需要获取同步的monitor和synchronizer信息，仅获取线程和线程堆栈信息
        ThreadInfo[] threadInfos = threadMXBean.dumpAllThreads(false, false);        // 遍历线程信息，仅打印线程ID和线程名称信息
        for (ThreadInfo threadInfo : threadInfos) {
            System.out.println("[" + threadInfo.getThreadId() + "] " + 
                    threadInfo.getThreadName());
        }
    }
}

Résultat de retour

[5] Attach Listener//附加监听
[4] Signal Dispatcher//分发处理发送给JVM信号的线程
[3] Finalizer//调用对象finalize方法的线程
[2] Reference Handler清除Reference的线程
[1] mainmain线程，用户程序入口

État du thread

Définition du code source

    /**
     * A thread state.  A thread can be in one of the following states:
     * <ul>
     * <li>{@link #NEW}<br>
     *     A thread that has not yet started is in this state.
     *     </li>
     * <li>{@link #RUNNABLE}<br>
     *     A thread executing in the Java virtual machine is in this state.
     *     </li>
     * <li>{@link #BLOCKED}<br>
     *     A thread that is blocked waiting for a monitor lock
     *     is in this state.
     *     </li>
     * <li>{@link #WAITING}<br>
     *     A thread that is waiting indefinitely for another thread to
     *     perform a particular action is in this state.
     *     </li>
     * <li>{@link #TIMED_WAITING}<br>
     *     A thread that is waiting for another thread to perform an action
     *     for up to a specified waiting time is in this state.
     *     </li>
     * <li>{@link #TERMINATED}<br>
     *     A thread that has exited is in this state.
     *     </li>
     * </ul>
     *
     * <p>
     * A thread can be in only one state at a given point in time.
     * These states are virtual machine states which do not reflect
     * any operating system thread states.
     *
     * @since   1.5
     * @see #getState
     */
    public enum State {
        /**
         * Thread state for a thread which has not yet started.
         */
        NEW,

        /**
         * Thread state for a runnable thread.  A thread in the runnable
         * state is executing in the Java virtual machine but it may
         * be waiting for other resources from the operating system
         * such as processor.
         */
        RUNNABLE,

        /**
         * Thread state for a thread blocked waiting for a monitor lock.
         * A thread in the blocked state is waiting for a monitor lock
         * to enter a synchronized block/method or
         * reenter a synchronized block/method after calling
         * {@link Object#wait() Object.wait}.
         */
        BLOCKED,

        /**
         * Thread state for a waiting thread.
         * A thread is in the waiting state due to calling one of the
         * following methods:
         * <ul>
         *   <li>{@link Object#wait() Object.wait} with no timeout</li>
         *   <li>{@link #join() Thread.join} with no timeout</li>
         *   <li>{@link LockSupport#park() LockSupport.park}</li>
         * </ul>
         *
         * <p>A thread in the waiting state is waiting for another thread to
         * perform a particular action.
         *
         * For example, a thread that has called <tt>Object.wait()</tt>
         * on an object is waiting for another thread to call
         * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
         * that object. A thread that has called <tt>Thread.join()</tt>
         * is waiting for a specified thread to terminate.
         */
        WAITING,

        /**
         * Thread state for a waiting thread with a specified waiting time.
         * A thread is in the timed waiting state due to calling one of
         * the following methods with a specified positive waiting time:
         * <ul>
         *   <li>{@link #sleep Thread.sleep}</li>
         *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
         *   <li>{@link #join(long) Thread.join} with timeout</li>
         *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
         *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
         * </ul>
         */
        TIMED_WAITING,

        /**
         * Thread state for a terminated thread.
         * The thread has completed execution.
         */
        TERMINATED;
    }

Diagramme de transition d'état

Description de l'état

Prêt, en cours d'exécution et l'état de mort du multithreading Java

L'état prêt est converti en état d'exécution : lorsque ce thread obtient les ressources du processeur
L'état d'exécution passe à l'état prêt : lorsque ce thread appelle activement le rendement() ; méthode ou perd les ressources du processeur pendant l’exécution.
L'état d'exécution est converti en état de mort : lorsque le corps d'exécution du thread termine l'exécution ou qu'une exception se produit.
Ce qui nécessite une attention particulière ici est : lorsque la méthode rendement() du thread est appelée, le thread passe de l'état d'exécution à l'état prêt, mais quel thread à l'état prêt est ensuite planifié par le CPU a un certain degré de caractère aléatoire, il peut donc arriver qu'après que le thread A ait appelé la méthode rendement(), le processeur planifie toujours le thread A.

En raison des besoins réels de l'entreprise, il est souvent nécessaire de terminer l'exécution d'un thread à un moment précis pour le faire entrer dans un état de mort. L'approche la plus courante à l'heure actuelle consiste à définir une variable booléenne. Lorsque les conditions sont remplies, le corps d'exécution du thread sera exécuté rapidement ( n'exécutera pas la méthode d'exécution Dans les articles suivants, nous présenterons comment). pour terminer un thread en toute sécurité. .

Analyse d'état – jvisualvm

Code-Référence (art de programmation simultanée Java)

package com.sunld;

import java.util.concurrent.TimeUnit;/**
 * @Title: TestThreadState.java
 * @Package com.sunld
 * <p>Description:</p>
 * @author sunld
 * @version V1.0.0 
 * <p>CreateDate:2017年9月28日 下午5:14:27</p>
*/public class TestThreadState {
    public static void main(String[] args) {        
    new Thread(new TimeWaiting (), "TimeWaitingThread").start();        
    new Thread(new Waiting(), "WaitingThread").start();        // 使用两个Blocked线程，一个获取锁成功，另一个被阻塞
        new Thread(new Blocked(), "BlockedThread-1").start();        
        new Thread(new Blocked(), "BlockedThread-2").start();
    }    //该线程不断地进行睡眠
    static class TimeWaiting implements Runnable{
        @Override        
        public void run() {
            SleepUtils.second(100);
        }
    }    //该线程在Waiting.class实例上等待
    static class Waiting implements Runnable{

        @Override        
        public void run() {            
        while (true) {
                synchronized (Waiting.class) {                    
                try {
                        Waiting.class.wait();
                    }catch(InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

    }    //该线程在Blocked.class实例上加锁后，不会释放该锁
    static class Blocked implements Runnable {

        @Override        public void run() {
            synchronized (Blocked.class) {                
            while (true) {
                    SleepUtils.second(100);
                }
            }
        }
    }
}class SleepUtils{
    public static final void second(long seconds) {        
    try {
            TimeUnit.SECONDS.sleep(seconds);
        }catch(InterruptedException e) {
            e.printStackTrace();
        }
    }
}

vidage des résultats

2017-09-28 17:26:47Full thread dump Java HotSpot(TM) 64-Bit Server VM (25.112-b15 mixed mode):

//BlockedThread-2线程获取到了Blocked.class的锁"BlockedThread-2" #13 prio=5 os_prio=0 tid=0x000000001f268000 nid=0x3754 waiting on condition [0x000000002009f000]
   java.lang.Thread.State: TIMED_WAITING (sleeping)

//BlockedThread-1线程阻塞在获取Blocked.class示例的锁上"BlockedThread-1" #12 prio=5 os_prio=0 tid=0x000000001f266800 nid=0x89c waiting for monitor entry [0x000000001ff9f000]
   java.lang.Thread.State: BLOCKED (on object monitor)

//WaitingThread线程在Waiting实例上等待"WaitingThread" #11 prio=5 os_prio=0 tid=0x000000001f260800 nid=0x4d08 in Object.wait() [0x000000001fe9f000]
   java.lang.Thread.State: WAITING (on object monitor)

//TimeWaitingThread线程处于超时等待"TimeWaitingThread" #10 prio=5 os_prio=0 tid=0x000000001f25f000 nid=0x42ac waiting on condition [0x000000001fd9e000]
   java.lang.Thread.State: TIMED_WAITING (sleeping)

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!