JavaEE-多线程初阶(1)

[1. 线程的概念](#1. 线程的概念)

[1.1 线程是是什么](#1.1 线程是是什么)

[1.2 为什么要有线程](#1.2 为什么要有线程)

[1.3 线程和进程的区别](#1.3 线程和进程的区别)

[1.4 Java的线程和操作系统线程的关系](#1.4 Java的线程和操作系统线程的关系)

[2. 第一个多线程程序](#2. 第一个多线程程序)

[2.1 Hello Thread](#2.1 Hello Thread)

[2.2 使用jconsole观察线程](#2.2 使用jconsole观察线程)

[3. 创建线程](#3. 创建线程)

[3.1 继承Thread类](#3.1 继承Thread类)

[3.2 实现Runnable接口](#3.2 实现Runnable接口)

1. 线程的概念

1.1 线程是是什么

⼀个线程就是⼀个 "执⾏流". 每个线程之间都可以按照顺序执⾏⾃⼰的代码. 多个线程之间 "同时" 执⾏着多份代码.

我们设想如下场景：
⼀家公司要去银⾏办理业务，既要进⾏财务转账，⼜要进⾏福利发放，还得进⾏缴社保。
如果只有张三⼀个会计就会忙不过来，耗费的时间特别⻓。为了让业务更快的办理好，张三⼜找来两
位同事李四、王五⼀起来帮助他，三个⼈分别负责⼀个事情，分别申请⼀个号码进⾏排队，⾃此就有
了三个执⾏流共同完成任务，但本质上他们都是为了办理⼀家公司的业务。
此时，我们就把这种情况称为多线程，将⼀个⼤任务分解成不同⼩任务，交给不同执⾏流就分别排队
执⾏。其中李四、王五都是张三叫来的，所以张三⼀般被称为主线程（Main Thread）。

1.2 为什么要有线程

⾸先, "并发编程" 成为 "刚需".

• 单核 CPU 的发展遇到了瓶颈. 要想提⾼算⼒, 就需要多核 CPU. ⽽并发编程能更充分利⽤多核 CPU
资源.
• 有些任务场景需要 "等待 IO", 为了让等待 IO 的时间能够去做⼀些其他的⼯作, 也需要⽤到并发编程.
其次, 虽然多进程也能实现并发编程, 但是线程⽐进程更轻量.
• 创建线程⽐创建进程更快.
• 销毁线程⽐销毁进程更快.
• 调度线程⽐调度进程更快.
最后, 线程虽然⽐进程轻量, 但是⼈们还不满⾜, 于是⼜有了 "线程池"(ThreadPool) 和 "协程"
(Coroutine)
关于线程池我们后⾯再介绍. 关于协程的话题我们此处暂时不做过多讨论.

1.3 线程和进程的区别

• 进程是包含线程的. 每个进程⾄少有⼀个线程存在，即主线程。
• 进程和进程之间不共享内存空间. 同⼀个进程的线程之间共享同⼀个内存空间.
• 进程是系统分配资源的最小单位，线程是系统调度的最小单位。
• ⼀个进程挂了⼀般不会影响到其他进程. 但是⼀个线程挂了, 可能把同进程内的其他线程⼀起带走(整个进程崩溃).

1.4 Java的线程和操作系统线程的关系

线程是操作系统中的概念. 操作系统内核实现了线程这样的机制, 并且对⽤户层提供了⼀些 API 供⽤户使⽤(例如 Linux 的 pthread 库).
Java 标准库中 Thread 类可以视为是对操作系统提供的 API 进⾏了进⼀步的抽象和封装.

2. 第一个多线程程序

2.1 Hello Thread

• 每个线程都是⼀个独⽴的执⾏流
• 多个线程之间是 "并发" 执⾏的.

java 复制代码

class MyThread extends Thread{
    @Override
    public void run() {
        while(true){
            System.out.println("Hello Thread");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

public class Demo1 {
    public static void main(String[] args) throws InterruptedException {
        Thread t=new MyThread();
            t.start();
        while(true){
            System.out.println("Hello Main");
            Thread.sleep(1000);
        }
    }
}

执行现象:

【注意】

使用Thread.sleep方法时会抛出异常：InterruptedException

这个异常在run方法里只能用try catch处理 ，而在main方法里可以使用throws处理：

原因：

父类Thread里的run方法并没有throws InterruptedException，

因此在子类里重写run方法时也不能有throws InterruptedException。

（子类重写的方法除了代码块以外必须保持与父类方法一致）

而main方法并不是对某个方法的重写，因此可以throws InterruptedException 。

2.2 使用jconsole观察线程

使用jconsole工具可以观察正在运行中的java线程，以上面写的死循环多线程代码为例：

具体流程：

1.找到jconsole的位置：

先找到jdk的位置：

进入jdk里的bin目录：

2.运行程序并且使用jconsole连接程序：

中间可能会弹出不安全的连接，直接继续连接即可。

3. 创建线程

3.1 继承Thread类

上述的"第一个多线程程序"就是继承了Thread类，大致写法如下：

3.2 实现Runnable接口

java 复制代码

class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("这里写线程运行的代码...");
    }
}

public class Demo1 {
    public static void main(String[] args) {
        Runnable runnable= new MyRunnable();
        Thread t=new Thread(runnable);
        t.start();
    }
}

MyRunnable里的写法跟MyThread里差不多：都是重写run方法。

区别在于main方法里的调用：创建 Thread 类实例, 调⽤ Thread 的构造⽅法时将 Runnable 对象作为 target 参数。

可以理解为MyRunnable里写的是线程运行的逻辑，然后再将运行逻辑作为参数传入线程里供线程执行。这样的做法可以达到解耦合的效果。

代码中，希望能做到低耦合、高内聚。

**低耦合：**一个代码被修改了不会影响到其他的代码，即修改代码对整个程序的影响低。

（模块之间，依赖尽量小，影响尽量小）

**高内聚：**一个模块内，把有关联的东西都放在一起。（方便查找）

完

如果哪里有疑问的话欢迎来评论区指出和讨论，如果觉得文章有价值的话就请给我点个关注还有免费的收藏和赞吧，谢谢大家