[进阶]Java：线程概述、线程创建方式

什么是线程？

• 线程(thread)是一个程序内部的一条执行路径。
• 我们之前启动程序执行后，main方法的执行其实就是一条单独的执行路径。
• 程序中如果只有一条执行路径，那么这个程序就是单线程的程序。

多线程是什么？

• 多线程是指从软硬件上实现多条执行流程的技术。
• 在很多地方都离不开多线程的使用，例如某宝，狗东等。

Thread类

• Java是通过java.lang.Thread 类来代表线程的。
• 按照面向对象的思想，Thread类应该提供了实现多线程的方式。

多线程的实现方案一：继承Thread类

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

方式一优缺点：

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

代码演示如下：

public class ThreadDemo01 {
    public static void main(String[] args) {
        //3.new一个新线程对象
        Thread t = new MyThread();
        //4.调用start方法启动线程（执行的还是run方法）
        t.start();
        for (int i = 0;i < 5; i++){
            System.out.println("主线程执行输出：" + i);
        }
    }
}

/**
   1.定义一个线程类继承Thread类
 */
class MyThread extends Thread{
    /**
       2.重写run方法，里面是定义线程以后要干啥
     */
    @Override
    public void run(){
        for (int i = 0; i < 5; i++){
            System.out.println("子线程执行输出：" + i);
        }
    }
}

1.为什么不直接调用run方法，而是调用start启动线程？

• 直接调用run方法会当成普通方法执行，此时相当于还是单线程执行。
• 只有调用start方法才是启动一个新的线程执行。

2.为什么要把主线程任务放在子线程后面？

• 这样主线程一直是先跑完的，相当于是一个单线程的效果了。

多线程的实现方案二：实现Runnable接口

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

 代码演示如下：

public class ThreadDemo02 {
    public static void main(String[] args) {
        //3.创建一个任务对象
        Runnable target = new MyRunnable();
        //4.把任务对象交给Thread处理
        Thread t = new Thread(target);
        //5.启动线程
        t.start();

        for (int i = 0; i < 10;i++){
            System.out.println("主线程执行输出：" + i);
        }
    }
}
/**
   1.定义一个线程任务类 实现Runnable接口
 */
class MyRunnable implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 10; i++){
            System.out.println("子线程执行输出：" + i);
        }
    }
}

方式二的优点：

• 优点：线程任务类只是实现了Runnale接口，可以继续继承和实现。
• 缺点：如果线程有执行结果是不能直接返回的。

实现Runnable接口（匿名内部类形式）

1. 可以创建Runnable的匿名内部类对象。
2. 交给Thread处理。
3. 调用线程对象的start()启动线程。

代码演示如下：

public class ThreadDemo02Other {
    public static void main(String[] args) {
        //3.创建一个任务对象
        Runnable target = new MyRunnable() {
              @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("子线程1执行输出：" + i);
                }
            }
        };
        //4.把任务对象交给Thread处理
        Thread t = new Thread(target);
        //5.启动线程
        t.start();

        for (int i = 0; i < 10; i++) {
            System.out.println("主线程执行输出：" + i);
        }

        new Thread(new Thread() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println("子线程2执行输出：" + i);
                }
            }
        }).start();

        new Thread(() ->{
            for (int i = 0; i < 10; i++) {
                System.out.println("子线程3执行输出：" + i);
            }
        }).start();
    }
}

1.前2种线程创建方式都存在一个问题：

• 他们重写的run方法均不能直接返回结果。
• 不适合需要返回线程执行结果的业务场景。

2.怎么解决这个问题呢？

• JDK 5.0提供了Callable和FutureTask来实现。
• 这种方式的优点是：可以得到线程执行的结果。

多线程的实现方案三：利用Callable、FutureTask接口实现

• 得到任务对象

1. 定义类实现Callable接口，重写call方法，封装要做的事情。
2. 用FutureTask把callable对象封装成线程任务对象。

• 把线程任务对象交给Thread处理。
• 调用Thread的start方法启动线程，执行任务
• 线程执行完毕后、通过FutureTask的get方法去获取任务执行的结果。

代码演示如下：

public class ThreadDemo3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //3.创建Callable任务对象
        Callable<String> call = new MyRunnable(100);
        //4.把Callable任务对象 交给FutureTask 对象
        // FutureTask对象的作用1： 是Runnable的对象（实现了Runnable接口）
        // FutureTask对象的作用2： 可以在线程执行完毕之后通过调用其get方法得到线程执行完成的结果
        FutureTask<String> f1 = new FutureTask<>(call);
        //5.交给线程处理
        Thread t1 = new Thread(f1);
        //6.启动线程
        t1.start();

        Callable<String> call2 = new MyRunnable(200);
        FutureTask<String> f2 = new FutureTask<>(call2);
        Thread t2 = new Thread(f2);
        t2.start();

        try {
            // 如果f1任务没有执行完毕，这里的代码会等待，直到线程1跑完才提取结果。
            String rs1 = f1.get();
            System.out.println("第一个结果："+rs1);
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            // 如果f2任务没有执行完毕，这里的代码会等待，直到线程2跑完才提取结果。
            String rs2 = f2.get();
            System.out.println("第一个结果："+rs2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 1.定义一个任务类 实现Callable接口
     */
    class MyCallable implements Callable<String> {
        private int n;

        public MyCallable(int n) {
            this.n = n;
        }
        /**
         * 2.重写call方法（任务方法）
         */
        @Override
        public String call() throws Exception {
            int sum = 0;
            for (int i = 0; i <= n; i++) {
                sum += i;
            }
            return "子线程执行的结果是：" + sum;
        }
    }
}

FutureTask的API

方法三优缺点：

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

三种方式对比

Thread提供的线程操作相关的方法

代码演示如下：

public class Mythread extends Thread{
    public Mythread(String name){
        super(name); // 为当前线程设置名字
    }
    @Override
    public void run(){
        // 哪个线程执行它，它就会得到哪个线程对象
        Thread t = Thread.currentThread();
        for (int i = 0; i <= 3; i++) {
            System.out.println(t.getName() + "输出：" + i);
        }
    }
}

public class ThreadTest1 {
    public static void main(String[] args) {
        Thread t1 = new Mythread("1号线程");
        t1.start();
        System.out.println(t1.getName());

        Thread t2 = new Mythread("2号线程");
        t2.start();
        System.out.println(t2.getName());

        Thread m = Thread.currentThread();
        m.setName("最牛的线程");
        System.out.println(m.getName());

        for (int i = 0; i <= 5; i++) {
            System.out.println(m.getName() + "线程输出：" + i);
        }
    }
}

public class ThreadTest2 {
    public static void main(String[] args) throws Exception {
        for (int i = 0; i <= 5; i++) {
            System.out.println(i);
            //休眠5秒
            if (i == 3) {
                // 会让当前执行的线程暂停5秒，再继续执行
                // 项目经理让我加上这行代码，如果用户交钱了，我就注释掉！
                Thread.sleep(5000);
            }
        }
        // join方法作用：让当前调用这个方法的线程先执行完
        Thread t1 = new Mythread("1号线程");
        t1.start();
        t1.join();

        Thread t2 = new Mythread("2号线程");
        t2.start();
        t2.join();

        Thread t3 = new Mythread("3号线程");
        t3.start();
        t3.join();
    }
}