JavaSE进阶之多线程-线程创建

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

多线程的三种创建方式

多线程在java中占着极其重要的位置，它可以提高程序的并发性和性能。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、多线程是什么？

多线程指的是从软硬件上实现的多条执行流程的技术（多线程由CPU负责调度执行）。例如：消息通信，淘宝、京东系统都离不开多线程。

二、多线程的三种创建方式

1.方式一：继承Thread类

1.1使用步骤

1、定义一个子类如MyThread继承线程类java.lang.Thread，重写run（）方法
2、创建MyThread类的对象
3、调用线程对象的start（）方法启动线程（启动后还是执行run方法的）

注意：启动线程必须是调用start方法，不是调用run方法。
不能把主线程main任务放在自线程之前，这样主线程一直是先跑完的，相当于是一个单线程的效果了。

1.2代码实现

public class MyThread extends Thread{
    //继承Thread类

    @Override
    public void run() {
        //重写run方法
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "线程:" + i);
        }
    }
}

public class MyThreadTest {
    public static void main(String[] args) {
        //创建线程对象
        MyThread myThread = new MyThread();
        //启动线程
        myThread.start();

        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "线程:" + i);
        }
        //打印结果会显示两条线程随机抢占cpu执行
    }
}

1.3优缺点

优点：编程简单
缺点：线程类已经继承Thread，无法继承其他类，不利于功能的扩展

2.方式二：实现Runnable接口

2.1使用步骤

1、定义一个线程任务类MyRunnable实现Runnable接口，重写run（）方法。
2、创建MyRunnable任务对象
3、把MyRunnable任务对象交给Thread处理
4、调用线程对象的start（）方法启动线程

还可以使用匿名内部类创建对象

2.2代码实现

public class MyRunnable implements Runnable{
    //定义一个线程任务类MyRunnable实现Runnable接口
    @Override
    public void run() {
        //重写run方法
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "线程:" + i);
        }
    }
}

public class RunnableTest {
    public static void main(String[] args) {
        //1、创建MyRunnable任务对象
        MyRunnable myRunnable = new MyRunnable();
        //2、把MyRunnable任务对象交给Thread处理
        Thread t= new Thread(myRunnable);
        //3、调用线程对象的start（）方法启动线程
        t.start();
    }
}

2.3方式的优缺点

优点：任务类只是实现接口，可以继续继承其他类、实现其他接口，拓展性强
缺点：需要多一个Runable对象；如果线程有执行结果是不能直接返回的。

3.方式三：利用Callable接口、FutureTask类来实现

3.1使用步骤

①、创建任务对象
定义一个类实现Callable接口，重写call方法，封装要做的事情，和要返回的数据。
把Callable类型的对象封装成FutureTask（线程任务对象）。
②、把线程任务对象交给Thread对象。
③、调用Thread对象的start方法启动线程。
、线程执行完毕后、通过FutureTask对象的的get方法去获取线程任务执行的结果

3.2代码实现

public class MyCallable implements Callable<Integer> {
    //定义一个类实现Callable接口，重写call方法，封装要做的事情，和要返回的数据
    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            sum += i;
        }
        return sum;
    }
}

public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyCallable myCallable = new MyCallable();
        //把Callable类型的对象封装成FutureTask（线程任务对象）。
        FutureTask<Integer> futureTask = new FutureTask<Integer>(myCallable);
        //把线程任务对象交给Thread对象
        Thread thread = new Thread(futureTask);
        //调用Thread对象的start方法启动线程。
        thread.start();
        //、线程执行完毕后、通过FutureTask对象的的get方法去获取线程任务执行的结果
        Integer result = futureTask.get();
        System.out.println(result);

    }
}

3.3优缺点

优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强；可以在线程执行完毕后去获取线程执行的结果。
缺点：编码相对复杂一点。

总结

方式	优点	缺点
继承Thread类	编程比较简单，可以直接使用Thread类中的方法	扩展性较差，不能再继承其他的类，不能返回线程执行的结果
实现Runnable接口	扩展性强，实现该接口的同时还可以继承其他的类。	编程相对复杂，不能返回线程执行的结果
实现Callable接口	扩展性强，实现该接口的同时还可以继承其他的类。可以得到线程执行的结果	编程相对复杂