JAVA多线程之三种线程创建方式-优快云博客

本文详细介绍了在Java中实现多线程的三种主要方法：通过继承Thread类、实现Runnable接口以及实现Callable接口。对比分析了这三种方式的特点，包括线程的创建、启动过程以及它们在处理多线程任务时的优缺点。

1.使用Thread类实现多线程

//创建MyThread类继承Thread类
class MyThread extends Thread{
	//创建子类有参构造方法
    public MyThread(String name){
        super(name);
    }
	//重写Thread类的run()方法
    @Override
    public void run() {
        int i = 0;
        while (i++<5){
            System.out.println(Thread.currentThread().getName()+"的run()方法正在运行");
        }
    }
}
public class Main {
    public static void main(String[] args) {
    	//创建MyThread类的实例对象
        MyThread myThread = new MyThread("thread1");
        //调用start()方法启动线程
        myThread.start();
        //创建另一个
        MyThread myThread2 = new MyThread("thread2");
        //启动
        myThread2.start();
    }
}

2.Rannable 接口实现多线程

//定义一个实现Runnable接口的MyThread类
class MyThread implements Runnable{
//重写Runnable接口的run()方法
    @Override
    public void run() {
        int i = 0;
        while (i++<5){
            System.out.println(Thread.currentThread().getName()+"的run()方法正在运行");
        }
    }
}
public class Main{
    public static void main(String[] args) {
    	//创建Runnable接口实现类的实列对象
        MyThread myThread0 = new MyThread();
        //使用Thread(Runnable target,String name)构造方法创建线程对象
        Thread thread0 = new Thread(myThread0,"thread0");
         //调用start()方法启动线程
        thread0.start();
         //创建另一个
        Thread thread1 = new Thread(myThread0,"thread1");
         //启动
        thread1.start();
    }
}

3.Callable 接口实现多线程

//定义一个实现Callable接口的实现类
class MyThreadCallable implements Callable<Object> {
    //重写Callable接口的call()方法
    @Override
    public Object call() throws Exception {
            int i = 0;
            while (i++<5){
                System.out.println(Thread.currentThread().getName()+"的run()方法正在运行");
            }
            return i;
        }
}
/*
 * 通过实现Callable方式创建自定义线程类
 * */
public class Main{
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建Callable接口的实现类对象
        MyThreadCallable myThread = new MyThreadCallable();
        //使用FutureTask封装Callable接口
        FutureTask<Object> futureTask1 = new FutureTask<>(myThread);
        //使用Thread(Runnable target,String name)构造方法创建线程对象
        Thread thread1 = new Thread(futureTask1,"thread1");
        //调用start()方法启动线程
        thread1.start();
        //同样的方式创建并启动第二个线程
        FutureTask<Object> futureTask2 = new FutureTask<>(myThread);
        Thread thread2 = new Thread(futureTask2,"thread2");
        thread2.start();
        //使用FutureTask对象的方法管理返回值
        System.out.println("thread1的返回值："+futureTask1.get());
        System.out.println("thread2的返回值："+futureTask2.get());
    }
}