JavaEE-多线程初阶1

✏️作者：银河罐头
📋系列专栏：JavaEE

🌲“种一棵树最好的时间是十年前，其次是现在”

1.认识线程

1.1概念

进程是操作系统资源分配的基本单位，线程是操作系统调度执行的基本单位

引入进程这个概念，最主要的目的是为了解决"并发编程"这样的问题，这是因为CPU进入了多核心时代，要想进一步的提升程序的执行速度，就需要充分的利用CPU的多核资源。

其实，多进程编程，已经可以解决并发编程的问题了，已经可以利用起来CPU的多核资源了。

但是，进程太重了。(这里的"重"指的是消耗资源多+速度慢)

进程"重"就"重"在了资源分配/回收

创建一个进程，开销比较大；销毁一个进程，开销也比较大；调度一个进程，开销还比较大。

线程也叫做"轻量型进程"。解决并发编程的问题的前提下，让创建，销毁，调度的速度更快一些。

线程为什么更"轻"，因为它省去了申请资源和释放资源的操作。

举例:一个工厂加工产品

工厂效益好了，想要提高生产力，有两个方案

方案一：再租一个场地，再买一套生产线和物流线

方案二：在原场地的基础上，只用买一套生产线，场地和物流线可以复用

分析：方案二与方案一相比更节省成本

方案一相当于多进程，方案二相当于多线程

线程和进程的关系，进程包含线程。

一个进程可以包含1个或多个线程，不能没有。

只有第一个线程启动的时候开销是比较大的，后续线程就省事了。

同一个进程的多个线程之间共用同一份资源(主要指的是内存和文件描述符表)。(这里的内存：你线程1new的个对象，线程2，3，4都可以直接使用)(这里的文件描述符表：线程1里打开的文件，线程2，3，4都可以直接使用)

操作系统里实际调度的时候，是以线程为单位进行调度的。

如果每个进程有多个线程，那么每个线程是独立在CPU上进行调度的，线程是操作系统调度执行的基本单位。

每个线程有自己的执行逻辑(执行流)

一个线程也是通过一个PCB进行描述的，也就是说一个进程可能对应1个PCB，也可能对应多个PCB。

之前学过的，PCB里的状态，上下文，优先级，记账信息都是每个线程有自己的，各自记录各自的。

而同一个进程的PCB之间，pid是一样的，内存指针，文件描述符表也是一样的。

进程专门负责资源分配，线程来接管和调度相关的一切内容。

多线程也会带来一些问题：

• 为了提高速度可以增加线程数量，但不是一直增加线程数量，速度能一直提高的，因为CPU核心数量是有限的。线程数目太多，核心数目有限，不少的开销反而浪费在线程调度上了。

系统创建线程，也是要消耗资源的，(虽然比进程轻量，但也不是0)，如果你创建线程太多，会导致资源耗尽，导致别的进程用不了，这里的资源指的是CPU，内存，带宽等。

• 多线程情况下，还可能带来线程安全问题。

  在多个执行流访问同一个共享资源的时候可能会有线程安全问题。

  线程模型，天然就是资源共享的，多线程争抢同一个资源(同一个变量)非常容易触发。

  进程模型，天然是资源隔离的，不容易触发。在进行进程间通信的时候，多个进程访问同一份资源，可能会有问题。

• 如果一个线程抛异常，如果没有处理好，可能使得整个进程崩了，其他线程也就挂了。

chrome浏览器要使用多进程编程模型(每个标签页都是一个进程)，目的是为了防止一个页面挂了使得其他页面也挂了

多线程的编程模型要比多进程的编程模型更加广泛

1.2多线程程序

在Java中如何是实现多线程编程。

Java执行多线程，最核心的类Thread

Thread t = new MyThread();
t.run();//虽然t是父类引用，此处调用的run仍然是子类的方法。(t本质上还是指向子类的对象)
1
2

使用Thread类不需要import别的包，Thread类在java.lang包下

还有哪些类类似？String，StringBuffer，StringBuilder

而像ArrayList，HashMap，Scanner，Random这些类都在java.util包下

创建线程是希望线程能够成为一个独立的执行流(执行一段代码)

如何指定？

t.start();
//t创建了一个新的线程，由这个新的线程调用run()
//调用操作系统的API，通过操作系统内核创建新线程的PCB，并且把要执行的指令交给这个PCB，然后这个PCB被调度到CPU上执行的时候，就执行到了线程run方法里的代码
1
2
3

public static void main(String[] args) {
        System.out.println("hello world");
    //如果只是直接打印hello world，Java进程主要就是有一个线程(调用main方法的线程)，主线程
    }
1
2
3
4

package Thread;

class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("hello world");
    }
}

public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread t = new MyThread();//不创建线程(说的线程指的是系统内核里的PCB)
        t.start();
        //通过t.start()，主线程调用t.start(),创建一个新线程，通过这个新线程调用t.run()
        //如果run()方法执行完毕，新线程就销毁
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

怎样体现出并发编程？

package Thread;

class MyThread extends Thread{
    @Override
    public void run() {
        while(true) {
            System.out.println("hello thread");
            //为了让这里的打印慢点，方便看，加个sleep，休眠1s
            try{
                Thread.sleep(1000);
            }catch(InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();
        while(true){
            System.out.println("hello main");
            try{
                Thread.sleep(1000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

操作系统调度线程的时候，“抢占式执行”，具体哪个线程先上，哪个线程后上，不确定，取决于操作系统调度器具体实现策略。

虽然有优先级，但是在应用程序(代码)层面上无法修改，从应用程序(代码)的角度，看到的效果就好像是线程之间的调度顺序是"随机"的一样。

内核里并非是随机的，但是干预因素太多了，并且应用程序这一层也无法感知到细节，就只能认为是随机的了。(可以通过一些api进行有限度的干预)

• start和run之间的区别：start是真正创建了一个线程(从系统这里创建的)，线程是独立的执行流。

可以使用jdk自带的工具jconsole查看当前的java进程中的所有线程JDK是Java开发工具包，这里带的工具很多，不只是javac和java

main线程销毁之后，thread-0线程会销毁吗？默认是不会的，守护线程/非守护线程

PCB对应的是线程，一个线程对应一个PCB，一个进程对应多个PCB，如果一个进程里只有一个线程，那就是一个进程对应一个PCB了。

同一个进程里的若干PCB的pid相同，不同进程里的pid不同

PCB只是操作系统书里说的概念，实际上Linux对应结构体名字叫做task_struct

PCB不是简称，它是一个数据结构，体现的是进程/线程是如何实现，如何被描述出来的。

1.3创建线程

• 1.继承Thread，重写run

package Thread;
class MyThread extends Thread{
    @Override
    public void run() {
        while(true) {
            System.out.println("hello thread");
            try{
                Thread.sleep(1000);
            }catch(InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}
public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();
        while(true){
            System.out.println("hello main");
            try{
                Thread.sleep(1000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

• 2.实现Runnable接口

package Thread;
//Runnable作用是描述一个要执行的任务，run方法就是任务的执行细节
class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("hello thread");
    }
}
public class ThreadDemo2 {
    public static void main(String[] args) {
        Runnable runnable = new MyRunnable();
        Thread t = new Thread(runnable);
        t.start();
    }
}
//解耦合，让线程和线程要执行的任务分离开
//好处是如果未来要改代码，不用多线程，使用多进程，或者线程池，协程...代码改动比较小
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

• 3.使用匿名内部类，继承Thread

//使用匿名内部类来创建线程
public class ThreadDemo3 {
    public static void main(String[] args) {
        Thread t = new Thread(){
            //1.创建了一个Thread类的子类，(子类没有名字所以才叫匿名)
            //2.创建了子类的实例并且让t指向该实例
            @Override
            public void run() {
                System.out.println("hello");
            }
        };
        t.start();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• 4.使用匿名内部类，实现Runnable

public class ThreadDemo4 {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello");
            }
        });
        t.start();
    }
}
//这个写法和2本质相同，只不过是把实现Runnable的任务交给匿名内部类的语法
//此处是创建了一个类，实现了Runnable接口，并创建了类的实例，并且传给了Thread的构造方法。
1
2
3
4
5
6
7
8
9
10
11
12
13

• 5.使用Lambda表达式

public class ThreadDemo5 {
    public static void main(String[] args) {
        Thread t = new Thread(()->{
            System.out.println("hello");
        });
        t.start();
    }
}
//把任务用lambda表达式来描述，直接把lambda传给Thread的构造方法
//lambda就是个匿名函数，就用一次
1
2
3
4
5
6
7
8
9
10

2.Thread类及常见方法

2.1Thread 的常见构造方法

package Thread;

public class ThreadDemo6 {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                while(true) {
                    System.out.println("hello");
                }
            }
        },"myThread");
        t.start();
        //对于主线程来说，执行完t.start()之后，main方法结束，主线程执行完了
        //t是代码里的变量名，而myThread是系统里的线程名
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

注意这里线程列表中没有主线程，因为主线程执行完了

2.2 Thread 的几个常见属性

• getName()：构造方法里起的名字

• getState()：线程状态。Java里线程的状态要比操作系统原生的状态更加丰富一些

• getPriority()：这个可以获取，也可以设置(但设置没什么用)

• isDaemon()：是否是守护线程(后台线程)。前台线程会阻止进程结束，后台线程不会阻止进程结束

代码里手动创建的线程默认都是前台的，包括main默认也是前台的，其他JVM自带的线程是后台的

也可以手动的使用setDaemon设置成后台线程

• isAlive()

  

  在真正调用start之前，调用t.isAlive是false，调用t.start之后isAlive就是true。另外如果内核里线程把run执行完了，此时线程销毁PCB随之释放，但是Thread t这个对象还不一定被释放，此时isAlive是false。

  isAlive是在判断当前系统里这个线程是否存在。

public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                    System.out.println("hello");
            }
        },"myThread");
        t.start();//t还在，引用不指向这个对象被GC回收的时候，t就不在了
        while(true){
            try{
                Thread.sleep(1000);
                System.out.println(t.isAlive());
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

如果t.run还没执行，isAlive是false;

如果t.run正在执行，isAlive是true;

如果t.run执行结束，isAlive是false;

2.3中断一个线程

中断的意思不是让线程立即停止，而是通知线程你该停止了。是否真的停止，取决于线程这里的代码写法。

• 1.使用标志位来控制线程是否要停止

private static boolean flag = true;
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while(flag){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        Thread.sleep(3000);
        //在主线程里就可以随时通过flag变量的取值，来操作t线程是否结束
        flag = false;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

• 2.使用Thread自带的标志位来进行判断

这种可以唤醒sleep

public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while(!Thread.currentThread().isInterrupted()){
                //Thread.currentThread()
                //这是Thread类的静态方法，通过这个方法可以获取到当前线程，哪个线程调用的这个方法，就可以获取到这个线程的对象引用，相当于this
                //是在t.run中被调用的，此处获取到的就是t线程
                //isInterrupted()为true表示被终止
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        Thread.sleep(3000);
        t.interrupt();
    }
//如果线程在sleep中休眠，此时调用interrupt就会把t线程唤醒，从sleep提前返回。interrupt会触发sleep里的异常InterruptedException，导致sleep提前返回
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

main调用t.interrupt()，main通知t要被终止

//结果：
hello thread
hello thread
hello thread
//t正常执行
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at Thread.ThreadDemo9.lambda$main$0(ThreadDemo9.java:16)
	at java.lang.Thread.run(Thread.java:748)
//调用interrupt触发了异常
hello thread
hello thread
hello thread
hello thread
hello thread
hello thread
.
.
.
//t还在继续执行
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

interrupt：

把线程内部的标志位(boolean)设置成true,

如果线程在sleep，就会触发异常把sleep唤醒,同时把刚才设置的这个标志位设置成false(清空了标志位)，这就导致当sleep的异常被catch完了之后，循环还要继续执行

//线程t忽略终止请求
public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while(!Thread.currentThread().isInterrupted()){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();
        Thread.sleep(3000);
        t.interrupt();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

//线程t立即响应你的终止请求
public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while(!Thread.currentThread().isInterrupted()){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    break;
                }
            }
        });
        t.start();
        Thread.sleep(3000);
        t.interrupt();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

//稍后进行终止
public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while(!Thread.currentThread().isInterrupted()){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException ex) {
                        ex.printStackTrace();
                    }
                    break;
                }
            }
        });
        t.start();
        Thread.sleep(3000);
        t.interrupt();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

如果不是sleep，像wait,join等类似的造成代码"暂停"的方法都会有清除标志位的设定

2.4等待一个线程-join()

有时，我们需要等待一个线程完成它的工作后，才能进行自己的下一步工作。等待线程，控制两个线程的结束顺序。

public static void main(String[] args) {
        Thread t = new Thread(()->{
            for(int i = 0;i < 3;i++){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        });
        t.start();
        System.out.println("join 之前");
        //此处的 join 就是让当前的 main 线程来等待 t 线程执行结束(等待 t 的 run 执行完)
        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("join 之后");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

执行完t.start()之后main线程和t线程就并发执行。main继续执行遇到join发生阻塞(block),一直阻塞到t线程结束，main线程才从join中恢复回来然后继续向下执行。t线程比main线程先结束

//结果：
join 之前
hello thread
hello thread
hello thread
join 之后
1
2
3
4
5
6

• 如果执行join时，t线程已经结束，会发生什么？

public static void main(String[] args){
        Thread t = new Thread(()->{
            for(int i = 0;i < 3;i++){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        });
        t.start();
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("join 之前");
        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("join 之后");
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

//结果：
hello thread
hello thread
hello thread
join 之前
join 之后
1
2
3
4
5
6

如果 join 时 t 线程已经结束，join就不会阻塞，就会立即返回。