二、线程的创建

一、创建方式

线程的创建有三种方式：

• 继承Thread类
• 实现Runnable接口
• 实现Callable接口

注：线程开启不一定立即执行，由CPU调度决定

1. 继承Thread类

继承Thread类创建线程可分为以下几步：

1. 自定义线程类继承Thread类
2. 重写run() 方法，编写线程执行体
3. 创建线程对象，调用start()方法启动线程

例：
public class TestThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("run方法线程---" + i);
        }
    }

    public static void main(String[] args) {
        TestThread testThread = new TestThread();
        testThread.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("主线程---" + i);
        }
    }
}

2. 实现Runnable接口

实现Runnable接口创建线程可分为以下几步：

1. 定义MyRunnable类实现Runnable接口
2. 实现run() 方法，编写线程执行体
3. 创建线程对象，调用start() 方法启动线程

例：
public class TestThread implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 200; i++) {
            System.out.println("run方法线程---" + i);
        }
    }

    public static void main(String[] args) {
        TestThread testThread = new TestThread();
        // 创建线程对象来开启线程，此处的Thread起一个代理的作用
        new Thread(testThread).start();

        for (int i = 0; i < 200; i++) {
            System.out.println("主方法线程---" + i);
        }
    }
}

3. 两者的区别

3.1 继承Thread类

• 子类继承Thread类具备多线程能力
• 启动线程：子类对象.start()
• 不建议使用：避免OOP单继承局限性

3.2 实现Runnable接口

• 实现接口Runnable具有多线程能力
• 启动线程：传入目标对象 + Thread对象.start()
• 推荐使用：可以避免单继承的局限性，灵活方便。方便同一个对象被多个线程使用

4. 实现Callable接口（了解即可）

4.1 实现步骤

1. 实现 Callable 接口，需要返回值类型
2. 重写 call() 方法，需要抛出异常
3. 创建目标对象
4. 创建执行服务
5. 提交执行
6. 获取结果
7. 关闭服务

例：
public class TestCallable implements Callable {
    private String url;
    private String name;

    public TestCallable(String url, String name) {
        this.url = url;
        this.name = name;
    }

    @Override
    public Boolean call() {
        boolean flag = true;
        while (flag) {
            downloader(url, name);
            flag = false;
        }
        return true;
    }

    public void downloader(String url, String name) {
        try {
            FileUtils.copyURLToFile(new URL(url), new File(name));
        } catch (IOException e) {
            System.out.println("downloader方法发生错误：" + e);
        }
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        TestCallable w1 = new TestCallable("https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-3/RUNNABLE-VS-RUNNING.png", "1.png");
        TestCallable w2 = new TestCallable("https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-3/RUNNABLE-VS-RUNNING.png", "2.png");
        TestCallable w3 = new TestCallable("https://my-blog-to-use.oss-cn-beijing.aliyuncs.com/2019-3/RUNNABLE-VS-RUNNING.png", "3.png");

        // 1. 创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(3);
        // 2. 提交执行
        Future r1 = ser.submit(w1);
        Future r2 = ser.submit(w2);
        Future r3 = ser.submit(w3);
        // 3. 获取结果
        boolean rs1 = r1.get();
        boolean rs2 = r2.get();
        boolean rs3 = r3.get();
        // 4. 关闭服务
        ser.shutdown();
    }
}

4.2 特点

• 可以定义返回值
• 可以抛出异常

二、小结

• Runnable接口提供的run()方法只是一个普通的方法，要想启动线程需要调用Thread类中的start()方法
• 同一线程对象的start()不可多次调用，否则会出现IllegalThreadStateException异常（详见线程的五大状态）
• Callable与Runnable类似，都是函数式接口，只不过Callable提供的方法有返回值，且支持泛型
• Callable接口实现多线程需要配合ExecutorService线程池工具使用

三、扩展

1. Thread类

1.1 构造方法

Thread类构造方法中有以下参数：

• ThreadGroup g：线程组，指定线程在哪个线程组下
• Runnable target：指定要执行的任务
• String name：设定线程的名字
• AccessControlContext acc：初始化私有变量inheritedAccessControlContext
• boolean inheritThreadLocals：可继承的ThreadLocal

实际使用中常用的两个构造方法：Thread(Runnable target)和Thread(Runnable target, String name)

1.2 常用方法

• currentThread()：静态方法，返回对当前正在执行的线程对象的引用
• start()：创建一个线程并开始执行，Java 虚拟机会调用线程内的run()方法
• yield()：礼让方法，详见线程状态
• sleep()：休眠方法，详见线程状态
• join()：强制执行方法，内部调用Object类的wait()方法，详见线程状态

2. FutureTask类

• FutureTask是Future接口的一个实现类。FutureTask是实现的RunnableFuture接口，而RunnableFuture接口同时继承了Future和Runnable接口。
• 高并发环境下，Callable和FutureTask可能会被创建多次。而FutureTask能够确保任务只执行一次。

3. 线程组

• ThreadGroup表示线程组，每个 Thread 必须存在在一个 ThreadGroup 当中，不能独立于 ThreadGroup 之外
• main()方法的线程名和线程组名都是“main”
• 如果在new Thread时没有显式指定线程组名，那么默认将此线程归于新建此线程时所在的线程组当中
• ThreadGroup是一个向下引用的树状结构，防止“上级”线程被“下级”线程引用而无法有效地被 GC 回收