1.1 线程与进程

起初刚接触线程与进程的时候，一直傻傻分不清，是因为这两个概念一直都是死记硬背的，并没有完全理解，比如：

• 进程：是对运行时程序的封装，是系统进行资源调度和分配的基本单位，实现了操作系统的并发。
• 线程：是进程的子任务，是 CPU 调度和分派的基本单位，实现了进程内部的并发。

显然，这些概念是很抽象的。我们可以打个比方，如图所示：

• 进程：我打开一个浏览器就相当于一个进程。
• 线程：可以比作是浏览器中打开的 n 个页面。
  
  一个进程可以有多个线程就叫做多线程。

搞清楚了两者的区别后，需要知道以下几点：

1. 线程在进程下进行（打开浏览器之后才能有页面）
2. 进程之间不会相互影响，主线程结束会导致整个进程结束（关闭浏览器，所有页面都将会被关闭）
3. 不同的进程数据很难共享（不同的浏览器搜索的内容并不完全相同）
4. 同进程下的不同线程之间数据很容易共享（同一个浏览器中可以看到历史浏览页面）
5. 进程使用内存地址可以限定使用量（每种浏览器都有打开页面数量的上限）

1.2 创建线程的三种方式

01、继承Thread类

创建一个类实现 Thread 类，并重写 run() 方法：

/**
 * 创建线程的三种方式-继承Thread类
 * 
 * @author qiaohaojie
 * @date 2023/6/29  16:25
 */
public class CreateThreadTest {

    public static void main(String[] args) {
        /**
         * 01 继承Thread类
         */
        // 1. 模拟三个线程
        CreateThread01 thread1 = new CreateThread01();
        CreateThread01 thread2 = new CreateThread01();
        CreateThread01 thread3 = new CreateThread01();
        // 2. 手动设置每个线程的名字
        thread1.setName("青花椒一号");
        thread2.setName("青花椒二号");
        thread3.setName("青花椒三号");
        // 3. 开启线程
        thread1.start();
        thread2.start();
        thread3.start();
    }


    static class CreateThread01 extends Thread {
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.println(getName() + ":打了" + i + "个小兵");
            }
        }
    }
}

运行结果：

02、实现Runnable接口

创建一个类实现 Runnable 接口，并重写 run() 方法：

/**
 * 创建线程的三种方式-实现Runnable接口
 *
 * @author qiaohaojie
 * @date 2023/6/29  16:25
 */
public class CreateThreadTest {

    public static void main(String[] args) {/**
         * 02 实现Runnable接口
         */
        // 1. 创建CreateThread02类
        CreateThread02 runnable = new CreateThread02();
        // 2. 模拟三个线程
        Thread thread4 = new Thread(runnable, "青花椒四号");
        Thread thread5 = new Thread(runnable, "青花椒五号");
        Thread thread6 = new Thread(runnable, "青花椒六号");
        // 3. 开启线程
        thread4.start();
        thread5.start();
        thread6.start();
    }
    
    static class CreateThread02 implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    // sleep会发生异常，要显示处理
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "打了:" + i + "个小兵");
            }
        }
    }
}

运行结果：

03、实现Callable接口

创建一个类实现 Callable 接口，重写 call() 方法，这种方式可以通过FutureTask获取任务执行的返回值。

/**
 * 创建线程的三种方式-实现Callable接口
 *
 * @author qiaohaojie
 * @date 2023/6/29  16:25
 */
public class CreateThreadTest {

    public static void main(String[] args) {
        /**
         * 03 实现Callable接口
         */
        // 1. 创建CreateThread03类
        CreateThread03 createThread03 = new CreateThread03();
        // 2. 创建异步任务
        FutureTask<Integer> futureTask = new FutureTask<>(createThread03);
        // 3. 启动线程
        new Thread(futureTask).start();
        // 4. 返回程序执行结果
        try {
            System.out.println("执行结果：" + futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
    
    static class CreateThread03 implements Callable<Integer> {
        @Override
        public Integer call() throws Exception {
            Thread.sleep(2000);
            int sum = 0;
            for (int i = 0; i < 100; i++) {
                sum += i;
            }
            return sum;
        }
    }
}

运行结果：

1.3 Question？

01、为什么要重写 run() 方法？

因为 run() 方法是用来封装被线程执行的代码。

02、run() 方法和 start() 方法有什么区别？

• run() 方法：封装线程执行的代码，直接调用相当于调用普通方法；
• start() 方法：启动线程，然后由 JVM 调用此线程的 run() 方法。

03、通过继承 Thread 类和实现 Runnable 接口的方式创建多线程，哪个好？

实现 Runnable 接口好，原因有两个：

1. 避免了 Java 单继承的局限性；
2. 适合多个相同的程序代码去处理同一资源的情况，把线程、代码和数据有效的分离，更符合面向对象的设计思想。

1.4 三个常见的方法

针对线程控制，还会遇到三个常见的方法：

01、sleep()

使当前正在执行的线程暂停指定的毫秒数，也就是进入休眠的状态。使用时要对异常进行处理：

try {
	// sleep会发生异常要显示处理
    Thread.sleep(20);//暂停20毫秒
} catch (InterruptedException e) {
    e.printStackTrace();
}

02、join()

等待这个线程执行完才会轮到后续线程得到 cpu 的执行权，使用这个也要抛出异常：

/**
 * 02 实现Runnable接口
 */
// 1. 创建CreateThread02类
CreateThread02 runnable = new CreateThread02();
// 2. 模拟三个线程
Thread thread4 = new Thread(runnable, "青花椒四号");
Thread thread5 = new Thread(runnable, "青花椒五号");
Thread thread6 = new Thread(runnable, "青花椒六号");
// 3. 开启线程
thread4.start();
try {
	// 等到thread4执行完才会轮到thread5和thread6
    thread4.join();
} catch (InterruptedException e) {
    e.printStackTrace();
}
thread5.start();
thread6.start();

运行结果：

03、setDaemon()

将此线程标记为守护线程，准确来说，就是服务其他的线程，像 Java 中的垃圾回收线程，就是典型的守护线程：

/**
 * 01 继承Thread类
 */
// 1. 模拟三个线程
CreateThread01 thread1 = new CreateThread01();
CreateThread01 thread2 = new CreateThread01();
CreateThread01 thread3 = new CreateThread01();
// 2. 手动设置每个线程的名字
thread1.setName("青花椒一号");
thread2.setName("青花椒二号");
thread3.setName("青花椒三号");
// 标记守护线程
thread1.setDaemon(true);
thread2.setDaemon(true);
// 3. 开启线程
thread1.start();
thread2.start();
thread3.start();

如果其他线程都执行完毕，main() 方法也执行完毕，JVM 就会退出，也就是停止运行。如果 JVM 都停止运行了，守护线程自然也就停止了。

1.5 线程的生命周期