JAVA多线程之三种线程创建方式

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());
    }
}

三种实现方式的简单对比分析

1 Runnable接口 和 Callable接口实现多线程的方式基本相同，但是Callable接口有返回值并且可以声明抛出异常；

2 JAVA类只支持单继承，当某个类已经继承了其他父类，就可以考虑通过实现Runnable接口 和 Callable接口的方式实现多线程；

3 实现接口的方式：可以用一个类对象去创建多个线程，以确保线程访问同一个变量。适用于多个线程去处理同一个共享资源的情况。(多个小伙伴吃同一份蛋糕、多个服装店卖同一仓库衣服)；

Kee