Il existe plusieurs façons de créer des threads en Java

Comment créer des threads

Hériter de la classe Thread pour implémenter le multi-threading

2. L'interface Override Runnable() implémente le multithreading, puis remplace également run(). Cette méthode est recommandée

3. Utilisez Callable et Future pour créer des fils de discussion

Tutoriels vidéo associés recommandés : Vidéo d'apprentissage Java

Les exemples sont les suivants :

1. Héritez de la classe Thread pour implémenter le multi-threading

/*
 * 继承Thread类创建线程
 * 1、重写run方法
 * 2、创建thread类的实例，即创建线程对象
 * 3、调用线程对象的start()来启动该线程
 * 注意：Thread类的每个进程之间不能共享该实例变量；具有单继承局限
 * */
public class StartThread extends Thread{
 
 private int i;
 @Override
 //重写run方法
 public void run() {
  // TODO Auto-generated method stub
  for(i=0;i<10;i++) {
   System.out.println(getName()+"  "+i);
   
  }
 }
 public static void main(String[] args) {
  for(int i=0;i<10;i++) {
   System.out.println(Thread.currentThread().getName()+ " ,"+i);
   //创建thread类的实例
   StartThread h1=new StartThread();
   StartThread h2=new StartThread();
   if(i==2) {
    //启动第一个进程
    h1.start();
    //启动第二个进程
    h2.start();
    
   }
   
  }
 }
 
}

2. Remplacez l'interface Runnable() pour implémenter le multi-threading, puis remplacez également run()<. 🎜>

pour définir la classe d'implémentation Runnable ()Interface, remplacez la méthode Run().

Créez une instance de la classe d'implémentation Runnable et utilisez cette instance comme cible de Thread pour créer un objet Thread. Cet objet Thread est le véritable objet thread

Démarrez le thread en appelant la méthode start() de l'objet thread

/*创建线程方式二
 * 1、创建：实现Runnable+重写run
 * 2、启动：创建实现类对象+Thread对象+start
 * 
 * 注意：推荐使用，避免单继承的局限性，优先使用接口
 * 方便共享资源
 * */

public class MyThread2 implements Runnable {//实现Runnable接口
　　public void run(){
　　//重写run方法
　　// TODO Auto-generated method stub
  //当线程类实现Runnable接口时
  //如果想要获取当前线程，只能使用Thread.currentThread方法
  for(;i<100;i++)
  {
   System.out.println(Thread.currentThread().getName()+" "+i);
  }  
  
}

public class Main {
　　public static void main(String[] args){
　　　　//启动线程1
      //不像继承Thread类一样，直接可以实例化对象即可，Runnable接口必须要
     //先创建实例，再将此实例作为Thread的target来创建Thread对象
　　　　//创建并启动线程
　　　　MyThread2 myThread=new MyThread2();

　　　　Thread thread=new Thread(myThread);

　　　　thread().start();

　　　　//或者    new Thread(new MyThread2()).start();
　　}
}

Utilisez Callable et Future pour créer un thread<🎜. >Contrairement à l'interface Runnable, l'interface Callable fournit une méthode call() comme corps d'exécution du thread. La méthode call() est plus puissante que la méthode run().

La méthode call() peut avoir une valeur de retour

La méthode call() peut déclarer qu'elle lève une exception

public class Main {

　　public static void main(String[] args){

　　　MyThread3 th=new MyThread3();

　　　//使用Lambda表达式创建Callable对象

　　   //使用FutureTask类来包装Callable对象
　　　FutureTask<Integer> future=new FutureTask<Integer>(
　　　　(Callable<Integer>)()->{
　　　　　　return 5;
　　　　}
　　  );
     //实质上还是以Callable对象来创建并启动线程
　　　new Thread(task,"有返回值的线程").start();

　　  try{
       //get()方法会阻塞，直到子线程执行结束才返回
　　　　System.out.println("子线程的返回值："+future.get());
 　　 }catch(Exception e){
　　　　ex.printStackTrace();
　　　}
　　}
}

Recommandations du didacticiel de l'article connexe :

Introduction à la programmation Java

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!