La définition et les méthodes courantes de Thread

Une étude préliminaire sur Thread

Préface

Dans le passé, tout le monde écrivait des programmes monothread, toutes les méthodes appelant dans la fonction principale. Vous pouvez clairement voir que son efficacité. est Il est particulièrement faible, tout comme l'utilisation d'un seul thread pour explorer un site Web en Python, on peut dire que cela peut vous faire vomir du sang car la quantité de données est trop importante. Aujourd'hui, nous allons nous intéresser à l'apprentissage de Java. programmation concurrente et multi-threading

Créer un thread

Il existe de nombreuses façons de créer un thread, comme hériter de la classe Thread, implémenter l'interface Runnable... Examinons en détail la méthode de création

hérite du fil

Pourquoi l'héritage Thread peut-il appeler directement la méthode start() pour démarrer un fil de discussion ? > lui-même est une méthode de Thread, c'est-à-dire qu'il hérite de la méthode start() de Thread, donc les objets de cette classe peuvent appeler start() pour démarrer le fil 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();     //启动线程}
}

Remarque : hérite Méthode de création de classe : un objet ne peut créer qu'un seul thread, et plusieurs threads ne peuvent pas partager un seul objet, un seul thread peut correspondre à un objet, jetons donc un coup d'œil à. la classe qui implémente l'interface Thread pour réaliser plusieurs threads partageant le même objet. Un objet Runnable

implémente l'interface 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();
    }
}

D'après ce qui précède, nous pouvons clairement voir qu'un objet qui implémente la classe d'interface

peut fournir Partagé par plusieurs threads, ce n'est pas comme hériter de la classe Thread et utiliser uniquement la méthode de création simple

Runnable

pour un thread.

est créé directement dans la méthode

. S'il est créé Si l'objet de la classe ordinaire est à l'extérieur, il doit être modifié de manière définitive, afin que plusieurs threads puissent partager un objet à en même temps. Cela revient à implémenter l'interface

. À ce stade, il est nécessaire de contrôler les conditions de synchronisation. Si l'objet est défini dans la méthode run, alors , c'est-à-dire qu'un thread correspond à un objet. , ce qui a le même effet que d'hériter de la classe Thread. Vous pouvez donc choisir librement mainRunnable

//普通的一个类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();
    }}

les méthodes couramment utilisées

• pour faire dormir le fil en cours mils millisecondes, mais ce qu'il faut noter ici, c'est que si le thread ajoute un verrou, la mise en veille du thread ne libérera pas le verrou

  static void sleep(long mils)

• Obtenez le nom du fil de discussion Cette méthode a été utilisée dans le programme ci-dessus

  String getName()

• Définissez le nom. du fil en cours Démarrer un fil pour le nom

  void setName(String name)

• La création d'un fil ne signifie pas le démarrage du fil. . Seule la méthode start() du thread est appelée. C'est le véritable début de l'exécution

  start()

• Renvoyer l'identifiant. du thread

  long getId()

• Le code exécuté par le thread est placé dans la méthode run() Les appels en cours d'exécution. Les méthodes sont ordonnées et exécutées dans l'ordre dans lequel le programme s'exécute

  run()

Utilisez

ci-dessous pour créer une instance en utilisant la méthode ci-dessus

//线程的类，继承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();

    }
}

• Attendez que ce fil se termine avant d'exécuter d'autres fils

  void join()

• Le temps d'attente pour ce thread est de mils millisecondes. Une fois ce temps écoulé, les autres threads s'exécuteront normalement

  void join(long mils)

Utiliser

//线程类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主线程正在运行主线程正在运行主线程正在运行主线程正在运行主线程正在运行主线程正在运行主线程正在运行主线程正在运行主线程正在运行主线程正在运行 */

• pour obtenir le niveau de priorité actuel du fil

  getPriority()

• Modifier la priorité du fil (0- 10). La valeur par défaut est 5. Plus la priorité est élevée, plus les chances d'obtenir des ressources CPU sont élevées

  setPriority(int num)

Utiliser

.

//线程类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执行的几率就越大 * /

• s'il faut le définir comme thread démon, s'il est défini sur un thread démon, alors Lorsque le thread principal détruit le thread démon, il sera également détruit

  setDaemon(boolean)

• Pour déterminer s'il s'agit d'un thread démon

  isDaemon()

utilisez

//测试类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 {
                Thread.sleep(1000);  //休眠一秒，方便主线程运行结束} catch (InterruptedException e) {
                e.printStackTrace();
            }

        }

    }

}public class Test {public static void main(String[] args) {
        MyThread1 t1 = new MyThread1(); // 创建线程t1.setName("第一个线程"); // 设置线程的名字t1.setDaemon(true);
        t1.start();for (int i = 0; i < 1; i++) {
            System.out.println(i);
        }

    }
}//结果：/* 0123456789Thread-Name:   第一个线程   Thread-id:    9*//* * 从上面的结果可以看出，一旦主线程结束，那么守护线程就会自动的结束 *

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!