Was sind die häufig verwendeten Operationen von Java-Threads?

Allgemeine Operationen von Threads

Thread-Namen festlegen: setName()

Thread-Namen abrufen: getName()

Eindeutige Thread-ID: 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());

Thread-Startup: start()

Beurteilen Sie, ob der Thread aktiv ist: isAlive()

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

Thread-Methode: run( ) / call()

Die Methode, die nach dem Start des Threads aufgerufen wird. Was der Thread tun möchte, ist in der run/call-Methode geschrieben. Es ist nicht erforderlich, ihn direkt aufzurufen. Nach dem Start ruft er run()/call() auf. Wenn das Programm run/call direkt aufruft, ohne den Thread zu starten, gehört es nicht zur Multithread-Programmierung, sondern zum direkten Aufruf gewöhnlicher Methoden des aktuellen Threads.

Holen Sie sich das aktuelle Thread-Objekt: currentThread()

Um die nicht statische Methode des aktuellen Threads zu betreiben, müssen Sie zuerst das Thread-Objekt abrufen.

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

Info Informationen zu Vorgängen zur Thread-Statuskontrolle (Lebenszyklus) finden Sie im vorherigen Artikel.

Daemon-Thread (Hintergrund-Thread)

Der Wächter gewöhnlicher Threads (Benutzer-Threads). Die Aufgabe des Daemon-Threads besteht darin, Dienste für andere Threads bereitzustellen. Wenn im Prozess keine Benutzer-Threads vorhanden sind, hat der Daemon-Thread keine Bedeutung und die JVM wird ebenfalls beendet. Typische Daemon-Threads umfassen den Garbage-Collection-Thread der JVM, und beim Start des Betriebssystems werden auch die Daemon-Threads verschiedener Module gestartet.

Legen Sie den Thread als Daemon-Thread fest: setDaeman()

Hinweis: Diese Methode muss vor der start()-Methode

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

Thread aufgerufen werden Serialisierung

Der Thread, der die Methode „join()“ ausführt, wechselt in den Warten auf den Aktivierungszustand (WAITING) , bis der Thread, der die Methode aufruft, endet und wartet dann. Der Weckzustand wechselt in den ausführbaren Zustand (RUNNABLE). Die Methode „join()“ ist eine Methode in der Thread-Klasse. Die unterste Ebene besteht darin, die Methode „wait()“ zu verwenden, um das Warten auf Threads zu realisieren Der Thread: Ein Thread. Rufen Sie join () eines anderen Thread-Objekts auf, um eine serielle Thread-Ausführung zu erreichen.

Zum Beispiel: ein gutes Gericht

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

Ausführungsergebnis: main > buyThread > cutThread > end

#🎜🎜 #

Vorbereitung beginnen... #cutThread：Das Hacken beginnt

cutThread：Das Hacken endet

scrambleThread：Das Rühren beginnt

scrambleThread：Das Rühren endet


Thread-Priorität
#Legen Sie die Priorität des aktuellen Threads fest. Je höher die Thread-Priorität, desto häufiger kann der Thread ausgeführt werden Der Prioritätsbereich liegt zwischen 1 und 10, der Standardwert ist 5.

setPriority(int)-Methode: Legt die Priorität des Threads fest.

getPriority-Methode: Ruft die Priorität des Threads ab.

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

}

Thread-Interrupt

Verwenden Sie die Methode interrupt(), um das Thread-Interrupt-Flag = true zu setzen, sodass ein Interrupt-Signal ausgelöst wird, wenn der Thread „blockiert“ ist. Wenn der Thread blockiert ist, auf das Aufwecken wartet oder einen Timeout-Wartezustand aufweist (Object.wait, Thread.join und Thread.sleep), erhält er eine Interrupt-Ausnahme (InterruptedException) und beendet den Zustand vorzeitig. Befindet sich der Thread hingegen im Status „RUNNABLE“, hat das Interrupt-Flag keine Wirkung.

Fall 1: Thread-Unterbrechung ist gültig

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

Ausführungsergebnis:

Hauptthread setzt den Thread-Terminalstatus auf wahr#🎜 🎜 #Thread 1

Eine Ausnahme ist aufgetreten, ich bin früh aufgewacht und der Wecker hat nicht geklingelt und ich habe ihn manuell ausgeschaltet

Führen Sie das Folgeprogramm dieses Threads weiter aus ... Thread-Unterbrechung ist ungültig

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

Ausführungsergebnis: Der Thread gibt weiterhin seinen Status als RUNNABLE aus.

Das obige ist der detaillierte Inhalt vonWas sind die häufig verwendeten Operationen von Java-Threads?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!