There are several ways to create threads in java

How to create threads

1. Inherit the Thread class to implement multi-threading

2. Override Runnable () interface implements multi-threading, and then also overrides run(). This method is recommended

3. Use Callable and Future to create threads

Related video tutorials are recommended:java learning video

The examples are as follows:

1. Inherit the Thread class to implement 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. Overwrite the Runnable() interface to implement multi-threading, and then also override run()

Define Runnable ()Interface implementation class, override the Run() method.

Create an instance of the Runnable implementation class, and use this instance as the target of Thread to create a Thread object. This Thread object is the real thread object

Start the thread by calling the start() method of the thread object

/*创建线程方式二
 * 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. Use Callable and Future to create a thread

Unlike the Runnable interface, the Callable interface provides a call() method as the thread execution body. The call() method is more powerful than the run() method.

The call() method can have a return value

The call() method can declare that it throws an 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();
　　　}
　　}
}

Related article tutorial recommendations:Introduction to java programming

The above is the detailed content of There are several ways to create threads in java. For more information, please follow other related articles on the PHP Chinese website!