Es gibt mehrere Möglichkeiten, Threads in Java zu erstellen

So erstellen Sie Threads

1 Erben Sie die Thread-Klasse, um Multithreading zu implementieren

2. Die Override Runnable()-Schnittstelle implementiert Multithreading und überschreibt dann auch run(). Diese Methode wird empfohlen

3. Verwenden Sie Callable und Future, um Threads zu erstellen

Empfohlene verwandte Video-Tutorials: Java-Lernvideo

Die Beispiele sind wie folgt :

1. Erben Sie die Thread-Klasse, um Multithreading zu implementieren

/*
 * 继承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. Überschreiben Sie die Runnable()-Schnittstelle, um Multithreading zu implementieren, und überschreiben Sie dann auch run()

Um die Schnittstellenimplementierungsklasse Runnable() zu definieren, überschreiben Sie die Run()-Methode.

Erstellen Sie eine Instanz der Runnable-Implementierungsklasse und verwenden Sie diese Instanz als Ziel von Thread, um ein Thread-Objekt zu erstellen. Dieses Thread-Objekt ist das eigentliche Thread-Objekt

Starten Sie den Thread, indem Sie die start()-Methode des Thread-Objekts aufrufen

/*创建线程方式二
 * 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();
　　}
}

3. Verwenden Sie Callable und Future, um einen Thread zu erstellen

Im Gegensatz zur Runnable-Schnittstelle stellt die Callable-Schnittstelle eine call()-Methode als Thread-Ausführungskörper bereit. Die call()-Methode ist leistungsfähiger als die run()-Methode.

Die call()-Methode kann einen Rückgabewert haben

Die call()-Methode kann deklarieren, dass sie eine Ausnahme auslöst

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

Empfehlungen für Tutorials zu verwandten Artikeln: Einführung zur Java-Programmierung

Das obige ist der detaillierte Inhalt vonEs gibt mehrere Möglichkeiten, Threads in Java zu erstellen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!