Einführung in die Verwendung einiger grundlegender Methoden des Multithreading in Java (mit Beispielen)

Dieser Artikel bietet Ihnen eine Einführung in die Verwendung einiger grundlegender Methoden im Multithreading in Java (mit Beispielen). Ich hoffe, dass er hilfreich ist Dir zu helfen.

Thread Sleep Sleep()

Thread.sleep(milliseconds); Wir können den Thread durch die Sleep-Methode in den Ruhezustand versetzen. Sie können sehen, dass Sleep eine statische Methode ist

public static native void sleep(long var0) throws InterruptedException;

    try {
        System.out.println(new Date().getSeconds());
        Thread.sleep(5000);
        System.out.println(new Date().getSeconds());
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

setDaemon-Daemon-Thread

Der Nicht-Daemon-Thread stoppt, dann wird der Daemon-Thread automatisch beendet

    public static void main(String[] args) {
        Thread thread1 = new Thread() {
            @Override
            public void run() {
                super.run();
                for(int i = 0; i < 5; i ++) {
                    System.out.println("非守护线程");
                }
            }
        };

        Thread thread2 = new Thread() {
            @Override
            public void run() {
                for(int i = 0; i < 200; i ++) {
                    System.out.println("守护线程");
                }
            }
        };

        thread2.setDaemon(true);
        thread1.start();
        thread2.start();
    }

Es ist offensichtlich, dass Thread2 Die Ausgabe sollte 200 Mal ausgeführt werden, hier werden jedoch nur wenige Zeilen ausgegeben. Denn wenn Thread1 die Ausführung abschließt, stoppt Thread2 automatisch als Daemon-Thread.

Multithread-Jion

Wenn die Jion-Methode ausgeführt wird, stoppen Sie den aktuellen Thread und führen Sie zuerst den Thread aus, der jion() ausgeführt hat. Dies entspricht einer Warteschlangensprung-Ausführung. Wenn beim Ausführen des Thread2-Threads i==20 gilt, springen Sie Thread1 in die Warteschlange und führen Sie zuerst die Methode

    public static void main(String[] args) {
        final Thread thread1 = new Thread() {
            @Override
            public void run() {
            super.run();
            for(int i = 0; i < 500; i ++) {
                System.out.println("thread1---" + i);
            }
            }
        };

        Thread thread2 = new Thread() {
            @Override
            public void run() {
                for(int i = 0; i < 200; i ++) {
                    if (i == 20) {
                        try {
                            //插队执行
                            thread1.join();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println(i);
                }
            }
        };
        thread1.start();
        thread2.start();
    }

join() aus. Sie können auch den Parameter lange Millisekunden-Join (Millisekunden) < übergeben 🎜> um die Ausführung anzuzeigen. Der Join-Thread springt in die Warteschlange und wird ausgeführt für 🎜>setPriority legt die Priorität für den Thread fest

Die Standardpriorität ist 5, mindestens 1, maximal 10

Je größer Je höher die Priorität, desto höher die Priorität

   public static void main(String[] args) {
        final Thread thread1 = new Thread() {
            @Override
            public void run() {
            super.run();
            for(int i = 0; i < 500; i ++) {
                System.out.println("thread1---" + i);
            }
            }
        };

        Thread thread2 = new Thread() {
            @Override
            public void run() {
                for(int i = 0; i < 200; i ++) {
                    if (i == 20) {
                        try {
                            //插队执行１毫秒
                            thread1.join(1);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println(i);
                }
            }
        };
        thread1.start();
        thread2.start();
    }

synchronisiert

Synchronisierter Codeblock

Wenn mehrere Threads gleichzeitig ausgeführt werden und mehrere Codeteile gleichzeitig ausgeführt werden. Ich hoffe, dass die CPU beim Ausführen des Codes nicht den Thread wechselt

Situation ohne Synchronisierung

Sehen wir uns an, was ohne Synchronisierung passieren wird

    public static void main(String[] args) {
        final Thread thread1 = new Thread() {
            @Override
            public void run() {
            super.run();
            for(int i = 0; i < 500; i ++) {
                System.out.println( getName() + "---" + i);
            }
            }
        };

        Thread thread2 = new Thread() {
            @Override
            public void run() {
                for(int i = 0; i < 200; i ++) {
                    if (i % 5 == 0) {
                        Thread.yield();
                    }
                    System.out.println(getName() + "---" + i);
                }
            }
        };
        thread1.start();
        thread2.start();
    }

Wir haben festgestellt, dass einige Ausgaben nicht vollständig gedruckt wurden. Während der Ausführung von Thread Thread1 wurde die CPU von Thread2 vorbelegt. In diesem Fall entspricht es definitiv nicht unserer Geschäftslogik. Daher müssen wir sicherstellen, dass die CPU erst dann von anderen Threads vorbelegt wird, wenn der Thread eine vollständige Methode ausführt

Synchronisiert verwenden

    public static void main(String[] args) {
        final Thread thread1 = new Thread() {
            @Override
            public void run() {
            super.run();
            for(int i = 0; i < 500; i ++) {
                System.out.println( getName() + "---" + i);
            }
            }
        };

        Thread thread2 = new Thread() {
            @Override
            public void run() {
                for(int i = 0; i < 500; i ++) {

                    System.out.println(getName() + "---" + i);
                }
            }
        };
        //设置最大的线程优先级最大为10
        thread1.setPriority(Thread.MIN_PRIORITY);
        //设置最小的线程优先级，最小为１
        thread2.setPriority(Thread.MAX_PRIORITY);
        thread1.start();
        thread2.start();
    }

Nach der Verwendung der synchronisierten Synchronisierung Codeblock, Sie werden feststellen, dass die obige Situation nicht auftritt

Synchronisationsmethode

public class ThreadSynchronied {

    public static void main(String[] args) {
        final Say say = new Say();

         Thread thread1 = new Thread() {
            @Override
            public void run() {
                for (int i = 0 ; i < 10000 ; i ++) {
                    say.say();
                }
            }
        };

        Thread thread2 = new Thread() {
            @Override
            public void run() {
                for (int i = 0 ; i < 10000 ; i ++) {
                    say.say1();
                }
            }
        };
        //设置最大的线程优先级最大为10
        thread1.setPriority(Thread.MIN_PRIORITY);
        //设置最小的线程优先级，最小为１
        thread2.setPriority(Thread.MAX_PRIORITY);
        thread1.start();
        thread2.start();
    }
}

class Say {
    void say() {
        System.out.print("s ");
        System.out.print("a ");
        System.out.print("y ");
        System.out.print("h ");
        System.out.print("e ");
        System.out.print("l ");
        System.out.print("l ");
        System.out.println("o");
    }

    void say1() {
        System.out.print("1 ");
        System.out.print("2 ");
        System.out.print("3 ");
        System.out.print("4 ");
        System.out.print("5 ");
        System.out.print("6 ");
        System.out.print("7 ");
        System.out.println("8");
    }
}

Synchronisationsmethode bezieht sich auf das Sperren der Methode

Das Objekt der statischen Synchronisationsmethode ist von Dieses Klassen-Bytecode-Objekt

Das ist das nicht-statische Sperrobjekt für die Synchronisationsmethode

Mehrere Threads, die dieselbe Ressourcensperre verwenden, können leicht einen Deadlock verursachen

Was ist ein Deadlock?

Deadlock bezieht sich auf ein Blockierungsphänomen, das dadurch verursacht wird, dass zwei oder mehr Prozesse während der Ausführung um Ressourcen konkurrieren oder miteinander kommunizieren. Ohne äußere Kraft können sie nicht voranschreiten. Zu diesem Zeitpunkt befindet sich das System in einem Deadlock-Zustand oder das System hat einen Deadlock. Diese Prozesse, die immer aufeinander warten, werden Deadlock-Prozesse genannt.

Thread-sichere Klasse

Vector

StringBuffer

HashTable

Thread-unsicher

ArrayList

StringBuilder
HashSet

java.util.Collections verfügt über Methoden wie „synchonizedList“, mit denen wir threadunsichere Sammlungen in threadsichere umwandeln können

Das obige ist der detaillierte Inhalt vonEinführung in die Verwendung einiger grundlegender Methoden des Multithreading in Java (mit Beispielen). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!