创建线程的三种方式

多线程(Thread)

线程概述：

• 程序：程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念；

• 进程：进程是程序执行一次的过程，是一个动态的概念，它负责了这个程序资源的分配；

• 线程：一个进程包含多个线程，最少有一个，是进程中的一个执行路径，线程是CPU调度和执行的单位；

• 多线程：就是一个进程中，多个执行路径同时执行；

创建线程的三种方式：

继承Thread类：

1、自定义线程类继承Thread类；

2、重写run()方法，编写执行内容；

3、创建自定义线程类的对象，调用start()方法启动线程；

package com.xu.threads;

public class TestThread01 extends Thread { // 继承Thread类
    @Override // 重写run()方法
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("我在写代码"+i);
        }
    }

    public static void main(String[] args) {

        TestThread01 testThread01 = new TestThread01(); // 创建线程对象
        testThread01.start();  // 调用start()方法开启线程

        for (int i = 0; i < 20; i++) {
            System.out.println("我在听歌"+i);
        }
    }
}

实现runnable接口：

1、自定义线程类实现Runnable接口；

2、重写run()方法，编写执行内容；

3、创建自定义线程类的对象，把对象丢入Thread()的构造，调用start()方法启动线程；

package com.xu.threads;

public class TestThread02 implements Runnable { // 实现Runnable接口
    @Override // 重写run()方法
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("我在写代码"+i);
        }
    }

    public static void main(String[] args) {

        TestThread02 testThread02 = new TestThread02(); // 创建线程对象
         new Thread(testThread02).start(); // 把对象丢入Thread()构造，调用start()方法;

        for (int i = 0; i < 20; i++) {
            System.out.println("我在听歌"+i);
        }
    }
}

实现Callable接口：

1、自定义线程类实现Callable接口，需要返回值类型；

2、重写call方法，需要抛出异常；

3、创建自定义线程类对象；

4、创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(3);

5、提交执行：Future submit01 = ser.submit(testCallable01);

6、获取结果：Boolean aBoolean01 = submit01.get();

7、关闭服务：ser.shutdownNow();

package com.xu.threads;

import java.util.concurrent.*;

public class TestCallable implements Callable<Boolean> {
    @Override
    public Boolean call() throws Exception {
        for (int i = 0; i < 50; i++) {
            System.out.println(Thread.currentThread().getName()+"在写作业！");
        }
        return true;
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 创建自定义线程类对象
        TestCallable testCallable01 = new TestCallable();
        TestCallable testCallable02 = new TestCallable();
        TestCallable testCallable03 = new TestCallable();

        // 创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(3);
		
        // 提交执行
        Future<Boolean> submit01 = ser.submit(testCallable01);
        Future<Boolean> submit02 = ser.submit(testCallable02);
        Future<Boolean> submit03 = ser.submit(testCallable03);
		
        // 获取结果
        Boolean aBoolean01 = submit01.get();
        Boolean aBoolean02 = submit02.get();
        Boolean aBoolean03 = submit03.get();
		
        //关闭服务
        ser.shutdownNow();
    }
}

相比继承Thread类，实现Runnable接口：避免了单继承的局限性，方便了同一个对象被多个线程使用，使得更加灵活方便！