JAVA面试题——创建线程的三种方式

在JAVA中创建线程一共有三种方式，分别是：

（1）继承Thread类

（2）实现Runnable接口

（3）实现Callable接口

接下来详细讲解每种方式的实现方法

（1）继承Thread类

实现步骤：

1、创建一个类，继承Thread类

2、重写类的run（）方法

3、实例化该类

4、调用实例化对象的start（）方法，启动线程

package com.gsr.my_thread;
 
public class ThreadTest extends Thread{
    @Override
    public void run() {
        for(int i=0;i<20;i++){
            System.out.println("这是线程的方法"+i);
        }
    }
 
    public static void main(String[] args) {
        //main线程
        //创建线程对象
        ThreadTest thread_test = new ThreadTest();
        //调用start方法
        thread_test.start();
        for(int i=0;i<20;i++){
            System.out.println("这是main线程的方法"+i);
        }
        
    }
}

（2）实现Runnable接口

具体实现步骤如下：

1、创建一个类，该类实现Runnable接口

2、重写类的run（）方法

3、实例化该类，并将该实例作为参数，传入Thread中，调用其的start（）方法。

package com.gsr.my_thread;
 
public class TestRunnable implements Runnable{
    @Override
    public void run() {
        for(int i=0;i<20;i++){
            System.out.println("这是线程的方法"+i);
        }
    }
 
    public static void main(String[] args) {
        //创建runnable接口的实现类对象
        TestRunnable testRunnable = new TestRunnable();
        //将改实现类，作为参数传入Thread
        new Thread(testRunnable).start();
        for(int i=0;i<20;i++){
            System.out.println("这是main线程的方法"+i);
        }
    }
}

（3）实现Callable接口

接下来介绍该类方法的具体实现

1、类需要实现Cabble接口

2、重写Cabble接口的call（）方法

3、创建类的实例

4、创建线程池，利用Executors.newFixedThreadPool()

5、将两个实例作为参数，调用线程池的实例化对象的submit（）方法，进行执行。

6、使用结果的get()方法，获得返回值

7、调用线程池实例化对象的shutdownNow方法，关闭线程池。

package com.gsr.my_thread;
 
import java.util.concurrent.*;
 
public class TestCallable implements Callable {
    @Override
    public Boolean call() throws Exception {
        for(int i=0;i<20;i++){
            System.out.println("这是线程"+Thread.currentThread().getName()+"的方法"+i);
        }
        return Boolean.TRUE;
    }
 
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable testCallable = new TestCallable();
        TestCallable testCallable2 = new TestCallable();
        //创建线程池
        ExecutorService executorService = Executors.newFixedThreadPool(2);
        //提交给线程池进行执行
        Future result = executorService.submit(testCallable);
        Future result2 = executorService.submit(testCallable2);
        //得到返回的结果
        Boolean r1 = result.get();
        Boolean r2 = result2.get();
        //关闭线程池
        executorService.shutdownNow();
    }
}

特点：

1、继承Thread类，会存在单继承的局限性

2、实现Runnable接口，更加灵活，能够一个对象被多个线程使用