Java多线程​（一）基本概念及三种实现方式

Java多线程

• 相关概念

• 线程

线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。

• 进程

进程是程序的基本执行实体

• 多线程

简单理解：应用软件中互相独立，可以同时运行的功能

• 并发和并行

并发：在同一时刻，有多个指令在单个CPU上交替执行

并行：在同一时刻，有多个指令在多个CPU上同时执行

• 小结

1.什么是多线程?

有了多线程，我们就可以让程序同时做多件事情

2.多线程的作用?

提高效率

3.多线程的应用场景?

只要你想让多个事情同时运行就需要用到多线程比如：软件中的耗时操作、所有的聊天软件、所有的服务器

• 多线程的实现方式

在Java中共有三种方式实现多线程，分别是：

①继承Thread类的方式进行实现

②实现Runnable接口的方式进行实现

③利用Callable接口和Future接口方式实现

• 实现方式一：继承Thread类

继承Thread类，并重写run()方法。创建新线程的方法是实例化线程类，开辟新线程的方法是调用该实例的start()方法。

线程实现类：

public class MyThread01 extends Thread{
    @java.lang.Override
    public void run() {
        // 线程要执行的代码
        for (int i = 0; i < 100; i++) {
            System.out.println(getName() + ": hello world.");
        }
    }
}

线程使用：

public class ThreadDemo1 {
    public static void main(String[] args) {
        // 多线程的第一种启动方式
        /*
         * 多线程的第一种启动方式：
         *  1.自己定义一个类继承Thread
         *  2.重写run方法
         *  3.创建子类的对象，并启动线程
         */
        MyThread01 mt01 = new MyThread01();
        MyThread01 mt02 = new MyThread01();
        // 给线程命名
        mt01.setName("线程01");
        mt02.setName("线程02");
        // 开启线程
        mt01.start();
        mt02.start();
    }
}

• 实现方式二：实现Runnable接口

实现Runnable接口，并重写run()方法。创建新线程的方法是实例化该线程类，然后将该实例作为参数传入Thread类创建线程实例类，开辟新线程的方法是调用Thread类实例的start()方法。

线程实现类：

public class MyThread02 implements Runnable{
    @Override
    public void run() {
        // 线程要实现的代码
        for (int i = 0; i < 100; i++) {
            // 获取当前线程的对象
            Thread t = Thread.currentThread();
            // 本线程要执行的任务
            System.out.println(t.getName() + ": hello world.");
        }

    }
}

线程使用：

public class ThreadDemo2 {
    public static void main(String[] args) {
        // 多线程的第二种启动方式
        /*
         *  多线程的第二种启动方式：
         *  1.自己定义一个类实现Runnable接口
         *  2.重写里面的run方法
         *  3.创建自己的类的对象
         *  4.创建一个Thread类的对象，并开启线程
         */
        // 创建对象
        // 表示多线程要执行的任务
        MyThread02 mt01 = new MyThread02();
        // 创建线程对象
        Thread t1 = new Thread(mt01);
        Thread t2 = new Thread(mt01);
        // 给线程命名
        t1.setName("线程1");
        t2.setName("线程2");
        // 开启线程
        t1.start();
        t2.start();

        /*
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {

            }
        });
         */
    }
}

• 实现方式三：实现Callable和Future接口

前面2中方式创建的多线程，run方法的返回值类型是void，也即没有线程运行的返回值，为了解决这个问题可以使用第三种线程实现方法。本方式可以获取到多线程运行的结果，但是实现方式相比前面的2种方式略显复杂。

线程实现类：

import java.util.concurrent.Callable;

public class MyCallable implements Callable<Integer> {
    // Callable接口有一个泛型，表示要返回的类型


    @Override
    public Integer call() throws Exception {
        // 返回1~100相加的和
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum += i;
        }
        return sum;
    }
}

线程使用：

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

public class ThreadDemo3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 多线程的第三种启动方式
        /*
         *  多线程的第三种实现方式：
         *  特点：可以获取到多线程运行的结果
         *  1.创建一个类MyCallable实现Callable接口
         *  2.重写call (是有返回值的，表示多线程运行的结果)
         *  3.创建MyCallable的对象(表示多线程要执行的任务)
         *  4.创建FutureTask的对象(作用管理多线程运行的结果)
         *  5.创建Thread类的对象，并启动(表示线程)
         */

        // 1.创建MyCallable的对象(表示多线程要执行的任务)
        MyCallable mc = new MyCallable();
        // 2.创建FutureTask的对象(作用管理多线程运行的结果)
        // FutureTask的泛型表示要返回的值的类型
        // 将Callable实现类的对象作为参数传给FutureTask
        FutureTask<Integer> ft = new FutureTask<>(mc);
        // 3.创建线程的对象
        Thread t1 = new Thread(ft);
        // 4.启动线程
        t1.start();
        // 5.获取线程运行的结果
        Integer i = ft.get();
        System.out.println(i);
    }
}

• 多线程三种实现方式的对比

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