Die Verwendung und Grundkonzepte von Threads in der Java-Parallelität

Thread-Definition

Ein Thread, manchmal auch Lightweight Process (LWP) genannt, ist die kleinste Einheit des Programmausführungsflusses. Ein Standard-Thread besteht aus Thread-ID, aktuellem Befehlszeiger (PC), Registersatz und Stapel. Ohne einen expliziten Koordinationsmechanismus werden Threads unabhängig voneinander ausgeführt. Jedes Programm hat mindestens einen Thread. Wenn ein Programm nur einen Thread hat, ist es das Programm selbst.

Ein Thread ist eine Einheit in einem Prozess und eine Basiseinheit, die vom System unabhängig geplant und verteilt wird. Der Thread selbst besitzt keine Systemressourcen, sondern nur einige Ressourcen, die für den Betrieb unerlässlich sind, aber er kann mit demselben geteilt werden Andere Threads eines Prozesses teilen sich alle Ressourcen, die dem Prozess gehören (teilen sich den Speicheradressraum des Prozesses), sodass diese Threads auf dieselben Variablen zugreifen und Objekte auf demselben Heap zuweisen können, was eine Methode zur gemeinsamen Nutzung erfordert zwischen Prozessen. Ein Datenaustauschmechanismus mit feinerer Datengranularität. Ohne diesen Synchronisationsmechanismus werden in Multithread-Situationen unvorhersehbare Folgen auftreten.

Ein Thread kann einen anderen Thread erstellen und zerstören, und mehrere Threads im selben Prozess können gleichzeitig ausgeführt werden. Aufgrund der gegenseitigen Beschränkungen zwischen Threads weisen Threads Diskontinuität in ihrem Betrieb auf. Threads haben außerdem drei Grundzustände: bereit, blockiert und ausgeführt. Der Status „Bereit“ bedeutet, dass der Thread alle Bedingungen zum Ausführen erfüllt, logisch ausgeführt werden kann und auf den Prozessor wartet. Der Status „Laufen“ bedeutet, dass der Thread den Prozessor belegt und ausgeführt wird Ereignis (z. B. ein Semaphor) und die Logik ist nicht durchsetzbar.

Ein Thread ist ein einzelner sequenzieller Steuerungsprozess in einem Programm. Eine relativ unabhängige und planbare Ausführungseinheit innerhalb eines Prozesses. Sie ist die Basiseinheit für die unabhängige Planung und Zuweisung der CPU. Sie bezieht sich auf die Planungseinheit eines laufenden Programms. Das gleichzeitige Ausführen mehrerer Threads zur Erledigung verschiedener Aufgaben in einem einzigen Programm wird als Multithreading bezeichnet.

Threads in Java

Der Einstiegspunkt eines Java-Programms ist die Hauptmethode. Sie startet die Ausführung durch den Aufruf der Hauptmethode und führt sie dann gemäß der Codelogik aus Tatsächlich ist das Java-Programm von Natur aus beteiligt. In einem Multithread-Programm ist die Ausführung einer Hauptmethode tatsächlich ein Thread mit dem Namen main, und andere Threads werden separat ausgeführt. Der Referenzcode lautet wie folgt:

Code (Siehe die Kunst der gleichzeitigen Java-Programmierung)

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());
        }
    }
}

Ergebnis zurückgeben

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

Thread-Status

Quellcode-Definition

    /**
     * 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;
    }

Zustandsübergangsdiagramm

Statusbeschreibung

Bereit, läuft und Todesstatus von Java-Multithreading

Der Bereitschaftszustand wird in den Ausführungszustand umgewandelt: wenn dieser Thread Prozessorressourcen erhält
Der Ausführungszustand geht in den Bereitschaftszustand über: wenn dieser Thread aktiv die yield() aufruft; Methode oder verliert Prozessorressourcen während der Ausführung.
Der Ausführungszustand wird in den Todeszustand umgewandelt: wenn der Thread-Ausführungskörper die Ausführung abschließt oder eine Ausnahme auftritt.
Was hier besonders beachtet werden muss, ist: Wenn die yield()-Methode des Threads aufgerufen wird, wechselt der Thread vom laufenden Zustand in den Bereitschaftszustand. Welcher Thread im Bereitschaftszustand als nächstes von der CPU geplant wird, hat jedoch eine gewisse Bedeutung Grad der Zufälligkeit, daher kann es vorkommen, dass die CPU Thread A weiterhin plant, nachdem Thread A die yield()-Methode aufgerufen hat.

Aufgrund tatsächlicher Geschäftsanforderungen ist es häufig erforderlich, die Ausführung eines Threads zu einem bestimmten Zeitpunkt zu beenden und ihn in einen toten Zustand zu versetzen. Derzeit ist die häufigste Methode das Festlegen einer booleschen Variablen. Wenn die Bedingungen erfüllt sind, wird der Thread-Ausführungskörper schnell ausgeführt ( wird die Ausführungsmethode nicht ausführen ). wie man einen Thread sicher beendet. .

Zustandsanalyse – jvisualvm

Code-Referenz (Java Concurrent Programming Art)

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();
        }
    }
}

Dump-Ergebnisse

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)

Das obige ist der detaillierte Inhalt vonDie Verwendung und Grundkonzepte von Threads in der Java-Parallelität. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!