Java多线程实现线程的三种方式及其对比

方式1：继承Thread类

步骤

• 定义一个MyThread类，继承Thread类
• 在MyThread类中重写run方法
• 创建MyThread类的对象
• 启动线程

MyThred类

package com.cmy.threaddemo;

/**
 * @author 陈明勇
 */
public class MyThread extends Thread {
    /**
     * 线程开启之后执行的方法
     */
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("线程开启了" + i);
        }
    }
}

测试类

package com.cmy.threaddemo;

/**
 * @author 陈明勇
 */
public class Demo {
    public static void main(String[] args) {
        // 创建一个线程对象
        MyThread t1 = new MyThread();
        // 开启一条线程
        t1.start();
        // 创建一个线程对象
        MyThread t2 = new MyThread();
        // 开启一条线程
        t2.start();
    }
}

思考

• 为什么要重写run()方法

  因为run()方法是用来封装被线程执行的代码

• run()方法和start()方法有什么区别？

  run(): 封装被线程执行的代码，如果直接调用，相当于是执行普通的方法，并没有开启线程

  start(): 启动线程；然后由JVM调用此线程的run()方法

方式2：实现Runnable接口

步骤

• 定义一个MyRunnable类实现Runnable接口
• 在MyRunnable类中重写run()方法
• 创建MyRunnable类的对象
• 创建Thread类的对象，将MyRunnable的对象作为构造方法的参数
• 启动线程

MyRunnable类

package com.cmy.threaddemo2;

/**
 * @author 陈明勇
 */
public class MyRunnable implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("线程启动" + i);
        }
    }
}

测试类

package com.cmy.threaddemo2;

/**
 * @author 陈明勇
 */
public class Demo {
    public static void main(String[] args) {
        // 创建MyRunnable对象
        MyRunnable myRunnable1 = new MyRunnable();
        // 创建线程对象
        Thread t1 = new Thread(myRunnable1);
        // 启动线程
        t1.start();

        // 创建MyRunnable对象
        MyRunnable myRunnable2 = new MyRunnable();
        // 创建线程对象
        Thread t2 = new Thread(myRunnable2);
        // 启动线程
        t2.start();
    }
}

方式3：Callable和Future

步骤

• 定义一个类MyCallable实现Callable接口
• 在MyCallable类中重写call()方法
• 创建MyCallable类的对象
• 创建Future的实现类FutureTask对象，把MyCallable类的对象作为构造方法的参数
• 创建MyThread类的对象，把FutureTask的对象作为构造方法的参数
• 启动线程
• 调用get()方法获取线程开启之后的结果

MyCallable类

package com.cmy.threaddemo3;

import java.util.concurrent.Callable;

/**
 * @author 陈明勇
 */
public class MyCallable implements Callable<String> {

    @Override
    public String call() throws Exception {
        for (int i = 0; i < 100; i++) {
            System.out.println("吃饭" + i);
        }
        // 返回值表示线程运行完毕之后的结果
        return "吃饱了，嗝~";
    }
}

重写call方法，call方法的返回值表示线程运行完毕之后的结果

测试类

package com.cmy.threaddemo3;


import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;

/**
 * @author 陈明勇
 */
public class Demo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 线程开启之后需要执行里面的call方法
        MyCallable myCallable = new MyCallable();
        // 可以获取线程执行完毕之后的结果，也可以作为参数传递给Thread对象
        FutureTask<String> ft = new FutureTask<>(myCallable);
        // 创建线程对象
        Thread thread = new Thread(ft);
        // 开启线程
        thread.start();
        // 获取线程运行之后的结果
        String s = ft.get();
        System.out.println(s);
    }
}

FutureTask类的对象通过 get() 方法可以获取线程运行之后的结果，也就是 call() 方法的返回值。注意， get() 方法不能在线程开启之前调用

三种方式对比