Java并发编程 | 第二篇：创建线程的几种方式

梦里梦外; 2022-03-19 15:06 173阅读 0赞

> Java 提供了三种创建线程的方法

• 通过继承 Thread 类本身；  
• 通过实现 Runnable 接口；  
• 通过实现 Callable 接口 和 Future 创建线程。

*  继承Thread类  
    继承Thread类的方式，本质上也是实现了 Runnable 接口的一个实例。  
    • 定义一个继承Thread类的子类，并重写该类的run()方法；  
    • 创建Thread子类的实例，即创建了线程对象；  
    • 调用该线程对象的start()方法启动线程。

//继承Thread类
    public class MyThread extends Thread { 
        //重写Thread类的run方法
        public void run() { 
            System.out.println("线程启动了");
        }
    
        public static void main(String[] args) { 
            //创建线程的实例
            MyThread myThread = new MyThread();
            //启动线程
            myThread.start();
        }
    }
    
    执行结果：
    线程启动了

*  实现Runnable接口  
    通过实现Runnable接口的方式是非常常见的一种  
    • 定义Runnable接口的实现类，并重写该接口的run()方法；  
    • 创建Runnable实现类的实例，并以此实例作为Thread的target对象，即该Thread对象才是真正的线程对象。

//实现Runnable接口
    public class DemoRun implements Runnable { 
    
        //重写run方法
        @Override
        public void run() { 
            System.out.println("我实现了Runnable");
        }
    
        public static void main(String[] args) { 
            //创建实例
            DemoRun demoRun = new DemoRun();
            //通过Thread来启动线程
            new Thread(demoRun).start();
        }
    }
    
    执行结果：
    我实现了Runnable

*  实现Callable接口，利用Future来创建线程（允许有返回值）  
    实现Callable接口的方式与实现Runnable的方式相似，区别就在于Callable可以有返回值。  
    • 创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。  
    • 创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。  
    • 使用FutureTask对象作为Thread对象的target创建并启动新线程。  
    • 调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。

import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    
    //实现Callable接口，并定义返回值类型
    public class DemoCable implements Callable<String> { 
        //重写call方法
        @Override
        public String call() throws Exception { 
            System.out.println("我实现了Callable");
            return "OK";
        }
    
        public static void main(String[] args) throws ExecutionException, InterruptedException { 
            //创建实例
            DemoCable demoCable = new DemoCable();
            //通过FutureTask类来包含Callable实现类
            FutureTask<String> futureTask = new FutureTask<>(demoCable);
            //启动线程
            new Thread(futureTask).start();
            //获取返回值
            System.out.println(futureTask.get());
        }
    }
    
    执行结果：
    我实现了Callable
    OK