Die Definition und allgemeine Methoden von Thread

Eine vorläufige Studie zu Thread

Vorwort

In der Vergangenheit hat jeder Single-Thread-Programme geschrieben, alle Aufrufmethoden in der Hauptfunktion. Sie können die Effizienz deutlich erkennen Es ist besonders niedrig, genau wie die Verwendung eines einzelnen Threads zum Crawlen einer Website in Python. Man kann sagen, dass Sie Blut erbrechen können, weil die Datenmenge zu groß ist. Heute werfen wir einen Blick auf das Lernen von Java gleichzeitige Programmierung und Multithreading

Erstellen Sie einen Thread

Es gibt viele Möglichkeiten, einen Thread zu erstellen, z. B. das Erben der Thread-Klasse, das Implementieren der Runnable-Schnittstelle ... Werfen wir einen detaillierten Blick auf die Erstellungsmethode

erbt Thread

Warum kann das Erben von Thread die Methode start() direkt aufrufen, um einen Thread zu starten? > selbst ist eine Methode von Thread, das heißt, sie hat die start()-Methode von Thread geerbt, sodass Objekte dieser Klasse start() aufrufen können, um den Thread zu starten start()

//继承Threadpublic class MyThread extends Thread {    public void run() {for (int i = 0; i < 10; i++) {
            System.out.println(this.getName()+"正在跑");
        }
    }
}public class Test{public static void main(String[] args)
    {
        Mythread t1=new MyThread();   //创建对象t1.start();     //启动线程}
}

Hinweis: erbtDie Erstellungsmethode einer Klasse kann nur einen Thread für ein Objekt erstellen, und mehrere Threads können nicht ein Objekt gemeinsam nutzen. Nur ein Thread kann einem Objekt entsprechen Ein Blick auf die Klasse, die die Schnittstelle Thread implementiert, um mehrere Threads zu realisieren, die dasselbe Objekt teilen. Ein Objekt Runnable

implementiert die Schnittstelle „Runnable“

//实现Runnable接口public class Demo implements Runnable {  @Overridepublic void run() {for(int i=0;i<10;i++)
        {
            System.out.println(Thread.currentThread().getName()+"正在跑");
        }

    }
}//测试类public class Test{public static void main(String[] args)
    {
        Demo d=new Demo();  //创建对象Thread thread1=new Thread(d); //为对象创建一个线程Thread thread2=new Thread(d);   //创建另外一个线程//同时启动两个线程thread1.start();
        thread2.start();
    }
}

Aus dem Obigen können wir deutlich erkennen, dass ein Objekt, das die Schnittstellenklasse

implementiert, von mehreren Threads gemeinsam genutzt werden kann. Dies ist nicht so, als würde man die Thread-Klasse erben und nur Runnable

verwenden Einfache Erstellungsmethode für einen Thread.

wird direkt in der

-Methode erstellt. Wenn das Objekt der gewöhnlichen Klasse außerhalb liegt, muss es finalisiert werden, damit mehrere Threads eins teilen können Dies entspricht der Implementierung der main-Schnittstelle. Wenn das Objekt in der Ausführungsmethode definiert ist, entspricht dies einem Thread ein Objekt, was den gleichen Effekt hat wie das Erben der Thread-Klasse. Sie können also Runnable

//普通的一个类public class Simple {public void display()
    {for(int i=0;i<10;i++)
        {
            System.out.println(Thread.currentThread().getName()+"正在跑");
        }
    }
}//线程测试类public class Test {public static void main(String[] args) {    //如果在外面必须使用final，当然也可以直写在run方法中,不过写在外面可以实现多个线程共享一个对象//写在run方法中当前对象只能为一个线程使用，和继承Thread类一样的效果final Simple simple=new Simple(); 
        
        //下面创建使用同一个对象创建同两个线程，实现多个线程共享一个对象，和实现Runnable接口一样的效果Thread t1=new Thread(){public void run() {
                simple.display();
            };
        };
        
        Thread t2=new Thread(){public void run() {
                simple.display();
            };
        };        //启动这两个线程t1.start();   
        t2.start();
    }}

häufig verwendete Methoden

• frei wählen, um den laufenden Thread in den Ruhezustand zu versetzen mils Millisekunden, aber was hier beachtet werden muss, ist, dass, wenn der Thread eine Sperre hinzufügt, die Sperre beim Schlafen des Threads nicht aufgehoben wird static void sleep(long mils)

• Ermitteln Sie den Namen des Threads. Diese Methode wurde im obigen Programm verwendet. String getName()

• Legen Sie den Namen fest des laufenden Threads Starten Sie einen Thread für den Namenvoid setName(String name)

• Das Erstellen eines Threads bedeutet nicht das Starten des Threads . Es wird nur die start()-Methode des Threads aufgerufen. Dies ist der eigentliche Start der Ausführung. start()

• Gibt die Kennung zurück des Threads long getId()

• Der vom Thread ausgeführte Code wird in der run()-Methode platziert. Die Aufrufe im Lauf Die Methoden sind geordnet und werden in der Reihenfolge ausgeführt, in der das Programm ausgeführt wirdrun()

Verwenden Sie

unten, um eine Instanz mit der oben genannten Methode zu erstellen

//线程的类，继承Threadpublic class MyThread1 extends Thread {public void run() { // 重载run方法，并且在其中写线程执行的代码块for (int i = 0; i < 10; i++) {// 获取线程的id和nameSystem.out.println("Thread-Name:   " + this.getName()
                    + "   Thread-id:    " + this.getId());try {this.sleep(1000); // 线程休眠1秒} catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

    }

}//线程测试的类public class Test {public static void main(String[] args) {
        MyThread1 t1 = new MyThread1(); // 创建线程t1.setName("第一个线程"); // 设置线程的名字MyThread1 t2 = new MyThread1();
        t2.setName("第二个线程");

        t1.start(); // 启动线程，开始运行t2.start();

    }
}

• Warten Sie, bis dieser Thread beendet ist, bevor Sie andere Threads ausführen void join()

• Die Wartezeit für diesen Thread beträgt Millionen Millisekunden. Sobald diese Zeit verstrichen ist, werden andere Threads normal ausgeführt void join(long mils)

Verwenden Sie

//线程类public class MyThread1 extends Thread {public void run() { // 重载run方法，并且在其中写线程执行的代码块for (int i = 0; i < 10; i++) {// 获取线程的id和nameSystem.out.println("Thread-Name:   " + this.getName()
                    + "   Thread-id:    " + this.getId());try {this.sleep(1000); // 线程休眠1秒} catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

    }

}//测试类public class Test {public static void main(String[] args) {
        MyThread1 t1 = new MyThread1(); // 创建线程t1.setName("第一个线程"); // 设置线程的名字t1.start(); // 启动线程，开始运行try {
            t1.join();   //阻塞其他线程，只有当这个线程运行完之后才开始运行其他的线程} catch (InterruptedException e) {
            e.printStackTrace();
        }for (int i = 0; i < 10; i++) {
            System.out.println("主线程正在运行");
        }

    }
}//输出结果/*Thread-Name:   第一个线程   Thread-id:    9Thread-Name:   第一个线程   Thread-id:    9Thread-Name:   第一个线程   Thread-id:    9Thread-Name:   第一个线程   Thread-id:    9Thread-Name:   第一个线程   Thread-id:    9Thread-Name:   第一个线程   Thread-id:    9Thread-Name:   第一个线程   Thread-id:    9Thread-Name:   第一个线程   Thread-id:    9Thread-Name:   第一个线程   Thread-id:    9Thread-Name:   第一个线程   Thread-id:    9主线程正在运行主线程正在运行主线程正在运行主线程正在运行主线程正在运行主线程正在运行主线程正在运行主线程正在运行主线程正在运行主线程正在运行 */

• um die aktuelle Thread-Prioritätsstufe zu erhaltengetPriority()

• Ändern Sie die Priorität des Threads (0- 10). Der Standardwert ist 5. Je höher die Priorität, desto höher ist die Chance, CPU-Ressourcen zu erhalten setPriority(int num)

Ob es als Daemon-Thread festgelegt werden soll, wenn es auf einen Daemon-Thread eingestellt ist, dann Wenn der Haupt-Thread den Daemon-Thread zerstört, wird er auch zerstört

//线程类public class MyThread1 extends Thread {public void run() { // 重载run方法，并且在其中写线程执行的代码块for (int i = 0; i < 10; i++) {// 获取线程的id和nameSystem.out.println("Thread-Name:   " + this.getName()
                    + "   Thread-id:    " + this.getId());try {this.sleep(1000); // 线程休眠1秒} catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

    }

}//测试类public class Test {public static void main(String[] args) {
        MyThread1 t1 = new MyThread1(); // 创建线程t1.setName("第一个线程"); // 设置线程的名字MyThread1 t2 = new MyThread1();
        t2.setName("第二个线程");

        t2.setPriority(8);   //设置第二个线程的优先级为8，第一个线程的优先级为5(是默认的)t1.start();
        t2.start();

    }
}/* * 从上面的运行结果可以看出大部分的第二个线程都是在第一个线程之前开始执行的，也就是说优先级越高获得cpu执行的几率就越大 * /

Um festzustellen, ob es sich um einen Daemon-Thread handelt

• setDaemon(boolean) verwenden Sie

• isDaemon()

Das obige ist der detaillierte Inhalt vonDie Definition und allgemeine Methoden von Thread. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!