止束的学习笔记

# 第八章 多线程

# 8.1 线程相关概念

# 8.1.1 进程

  1. 进程是指运行中的程序，比如使用QQ，就启动了一个进程，操作系统就会为该进程分配内存空间，当使用迅雷时，又启动了一个进程，操作系统将为迅雷分配新的内存空间。

  2. 进程是程序的一次执行过程，或是正在运行的一个程序，是动态过程：有它自身的产生、存在和消亡的过程

# 8.1.2 线程

  1. 线程是由进程创建的，是进程的一个实体，一个进程可以拥有多个线程

  1. 单线程：同一个时刻，只允许执行一个线程

  2. 多线程：同一个时刻，可以执行多个线程，比如：一个QQ进程，可以同时打开多个聊天窗口；一个迅雷进程，可以同时下载多个文件

  3. 并发：同一个时刻，多个任务交替执行，造成一种 "貌似同时" 的错觉，简单的说，单核 CPU 实现的多任务就是并发

  1. 并行：同一个时刻，多个任务同时执行，多核 CPU 可以实现并行。并发和并行有可能同时进行

# 8.2 创建线程的两种方式

  1. 继承 Thread 类，重写 run 方法

  2. 实现 Runnable 接口，重写 run 方法

# 8.2.1 应用案例-继承 Thread 类

  1. 编写程序，开启一个线程，该线程每隔 1 秒，在控制台输出 "喵喵，我是小猫咪"

  2. 改进：当输出 8 次时，结束该线程

public class Thread01 {
    public static void main(String[] args) {
        //创建 Cat 对象，可以当作线程使用
        Cat cat = new Cat();
        //启动线程
        cat.start();

    }
}
/**
 * 1. 当一个类继承了 Thread 类，该类就可以当做线程使用
 * 2. 我们会重写 run 方法，写上自己的业务代码
 * 3. run Thread 类，实现了 Runnable 接口的 run 方法
 * */
class Cat extends Thread {
    int times = 0;

    @Override
    public void run() { //重写 run 方法，写上自己的业务逻辑
        while (true) {
            //该线程每隔 1 秒，在控制台输出 "喵喵，我是小猫咪"
            System.out.println("喵喵，我是小猫咪" + (++times));
            //让该线程休眠 1 秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            if (times == 8) {
                break;
            }
        }
    }
}
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
32
33
34

# 8.2.1.1 多线程机制

public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        //创建 Cat 对象，可以当作线程使用
        Cat cat = new Cat();
        //启动线程(启动的是子线程)
        cat.start();

        //当 main 线程启动一个子线程 Thread-0, 主线程不会阻塞，会继续执行
        //此时，主线程和子线程交替进行
        System.out.println("主线程继续执行" + Thread.currentThread().getName());
        for (int i = 0;i < 6; i++) {
            System.out.println("主线程 i = " + i);
            //让主线程休眠
            Thread.sleep(1000);
        }
    }
}
/**
 * 1. 当一个类继承了 Thread 类，该类就可以当做线程使用
 * 2. 我们会重写 run 方法，写上自己的业务代码
 * 3. run Thread 类，实现了 Runnable 接口的 run 方法
 * */
class Cat extends Thread {
    int times = 0;

    @Override
    public void run() { //重写 run 方法，写上自己的业务逻辑
        while (true) {
            //该线程每隔 1 秒，在控制台输出 "喵喵，我是小猫咪"
            System.out.println("喵喵，我是小猫咪" + (++times));
            //让该线程休眠 1 秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            if (times == 8) {
                break;
            }
        }
    }
}
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
32
33
34
35
36
37
38
39
40
41
42

# 8.2.1.2 为什么是 .start()

cat.start() 用来启动线程，最终会执行 cat 的 run 方法

因为最终都会调用 cat 的 run 方法，那为什么不直接调用 run 方法？因为 run 方法就是一个普通的方法，没有真正的启动一个线程，直接调用 run 方法会执行完 run 方法后就直接执行下面的代码，会造成堵塞

# 8.2.2 应用案例2-实现 Runnable 接口

  1. Java 是单继承的，在某些情况下一个类可能已经继承了某个父类，这时再用继承 Thread 类的方法来创建线程显然不可能了，这时可以通过实现 Runnable 接口来创建线程

  2. 应用案例

​ 编写程序，该程序可以每隔 1 秒在控制台输出 "小狗汪汪叫"，当输出 10 次后自动退出，这里是静态代理

public class Thread02 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        //这里不能直接调用 .start()
        //需要创建 Thread 对象，把 dog 对象(实现了 Runnable 接口的对象)放入到 Thread
        //这里底层使用了设计模式(代理模式)
        Thread thread = new Thread(dog);
        thread.start();
    }
}

class Dog implements Runnable { //通过实现 Runnable 接口开发线程
    int count = 0;
    @Override
    public void run() {
        while (true) {
            System.out.println("小狗汪汪叫" + (++count) + Thread.currentThread().getName());
            //休眠 1 秒
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            if (count == 10) {
                break;
            }
        }
    }
}
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

# 8.2.3 继承 Thread 和 实现 Runnable 的区别

  1. 从 Java 的设计来看，通过继承 Thread 或者 实现 Runnable 接口来创建线程本质上没有区别，Thread 类本身就实现了 Runnable 接口

  2. 实现 Runnable 接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制

  3. 多线程售票问题

​ 编程模拟三个售票窗口同时售票共100张，分别使用继承 Thread 和实现 Runnable 方式，并分析有什么问题？

（1）使用继承 Thread 方式

public class SellTicket {
    public static void main(String[] args) {
        SellTicket01 sellTicket01 = new SellTicket01();
        SellTicket01 sellTicket02 = new SellTicket01();
        SellTicket01 sellTicket03 = new SellTicket01();
        sellTicket01.start();
        sellTicket02.start();
        sellTicket03.start();
    }
}

//使用 Thread 方式，会出现互斥同步问题
class SellTicket01 extends Thread {
    private static int ticketNum = 100; //让多个线程共享 ticketNum

    @Override
    public void run() {
        while (true) {
            //会出现互斥同步问题是因为下面的 ticketNum 还没来得及减减，其他线程就涌进来了，导致 if 没有控制住，这样就会多读
            if (ticketNum <=0 ) {
                System.out.println("售票结束...");
                break;
            }

            //如果还有票，休眠 50ms
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }

            System.out.println("窗口: " + Thread.currentThread().getName() + " 售出一张票" + " 剩余票数: " + (--ticketNum));
        }
    }
}
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
32
33
34
35

（2）使用实现 Runnable 接口的方式

public class SellTicket {
    public static void main(String[] args) {
        //使用 Runnable 方式
        SellTicket02 sellTicket02 = new SellTicket02();
        new Thread(sellTicket02).start();
        new Thread(sellTicket02).start();
        new Thread(sellTicket02).start();
    }
}

class SellTicket02 implements Runnable {
    private int ticketNum = 100; //让多个线程共享 ticketNum，这里因为只用 new 一个 SellTicket02 对象，所以这个 ticketNum 变量不用加 static
    @Override
    public void run() {
        while (true) {
            //会出现互斥同步问题是因为下面的 ticketNum 还没来得及减，其他线程就涌进来了，导致 if 没有控制住，这样就会多读
            if (ticketNum <= 0) {
                System.out.println("售票结束...");
                break;
            }
            //如果还有票，休眠 50ms
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("窗口: " + Thread.currentThread().getName() + " 售出一张票" + " 剩余票数: " + (--ticketNum));
        }
    }
}
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

# 8.3 线程终止

当线程完成任务后会自动退出，还可以通过使用变量来控制 run 方法退出的方式停止线程，即通知方式

public class ThreadExit_ {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        t.start();
        //如果希望 main 线程去控制 t 线程的终止，必须可以修改 loop
        //让 t 退出 run 方法，从而终止 t线程 通知方式
        //让主线程休眠 10秒，再通知 t 线程退出
        Thread.sleep(10*1000);
        t.setLoop(false);
    }
}

class T extends Thread {
    private int count = 0;
    //设置一个控制变量
    private boolean loop = true;

    @Override
    public void run() {
        while (loop) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("T运行中..." + (++count));
        }
    }
    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}
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
32

# 8.4 线程常用方法

  1. setName //设置线程名称，使之与参数 name 相同

  2. getName //返回该线程的名称

  3. start //使该线程开始执行，Java虚拟机底层调用该线程的 start0 方法

  4. run //调用线程对象 run 方法

  5. setPriority //更改线程的优先级

  6. getPriority //获取线程的优先级

  7. sleep //在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)

  8. interrupt //中断线程

注意事项和细节：

（1）start 底层会创建新的线程，如果是调用 run，因为 run 就是一个简单的方法调用，不会启动新线程

（2）线程优先级的范围

（3）interrupt 中断线程，但并没有真正的结束线程，所以一般用于中断正在休眠的线程，即唤醒该线程

  1. yield：线程的礼让，让出 CPU，让其它线程执行，但礼让的时间不确定，所以也不一定礼让成功

  2. join：线程的插队，插队的线程一旦插队成功，则肯定先执行完插入的线程的所有的任务

应用案例1：创建一个子线程，每隔 1s 输出 hello，输出 20 次，主线程每隔 1s 输出 hi，输出 20 次。要求：两个线程同时执行，当主线程输出 5次 后，就让子线程运行完毕主线程再继续

public class ThreadMethod02 {
    public static void main(String[] args) throws InterruptedException {
        T2 t2 = new T2();
        t2.start();

        for (int i = 1; i <= 20; i++) {
            Thread.sleep(50);
            System.out.println("主线程 " + i);
            if (i == 5) {
                System.out.println("主线程让子线程先执行");
                t2.join(); //让 t2 线程先执行完毕
                System.out.println("子线程执行完毕，主线程继续执行");
            }
        }
    }
}

class T2 extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 20; i++) {
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("子线程----" + i);
        }
    }
}
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

应用案例2：主线程每隔 1s 输出一个 hi，一共 10次，当输出到第五个 hi 时，启动一个子线程（要求实现 Runnable），每隔 1s 输出 hello，等该线程输出 10次 hello 后退出，主线程继续输出 hi，直到主线程退出

public class ThreadMethodExercise {
    public static void main(String[] args) throws InterruptedException {
        Thread t3 = new Thread(new T3());
        for (int i = 1; i <= 10; i++) {
            System.out.println("hi " + i);
            if (i == 5) { //说明主线程输出了 5次 hi
                t3.start(); //启动子线程，输出 hello
                t3.join(); //立即将 t3 子线程插入到主线程，让 t3 先执行
            }
        }
    }
}

class T3 implements Runnable {
    private int count = 0;

    @Override
    public void run() {
        while (true) {
            System.out.println("hello " + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            if (count == 10) {
                break;
            }
        }
    }
}
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

# 8.5 用户线程和守护线程

  1. 用户线程也叫工作线程，当线程的任务执行完成结束或以通知方式结束

  2. 守护线程一般是为用户线程服务的，当所有的用户线程结束，守护线程自动结束

  3. 常见的守护线程：垃圾回收机制

  4. 应用案例：测试如何将一个线程设置成守护线程

public class ThreadMethod03 {
    public static void main(String[] args) throws InterruptedException {
        MyDaemonThread myDaemonThread = new MyDaemonThread();
        //如果我们希望当 main 线程结束后，子线程自动结束，只需将子线程设为守护线程即可
        myDaemonThread.setDaemon(true);
        myDaemonThread.start();
        for (int i = 0; i < 20; i++) {
            Thread.sleep(1000);
            System.out.println("main 线程");
        }
    }
}

class MyDaemonThread extends Thread {
    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("子线程");
        }
    }
}
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

# 8.6 线程的生命周期

JDK 中用 Thread.State 枚举表示了线程的几种状态：

  • NEW：尚未启动的线程处于此状态
  • RUNNABLE：在 Java 虚拟机中执行的线程处于此状态
  • BLOCKED：被阻塞等待监视器锁定的线程处于此状态
  • WAITING：正在等待另一个线程执行特定动作的线程处于此状态
  • TIMED_WAITING：正在等待另一个线程执行动作达到指定等待时间的线程处于此状态
  • TERMINATED：已退出的线程处于此状态

具体见：一篇文章掌握Java线程的生命周期 (opens new window)

# 8.7 线程同步机制

  1. 在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何同一时刻最多有一个线程访问，以保证数据的完整性

  2. 也可以这样理解线程同步：即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作

# 8.7.1 同步具体方法-Synchronized

  1. 同步代码块
synchronized(对象) { //得到对象的锁，才能操作同步代码
    //需要被同步的代码
}
1
2
3
  1. synchronized 还可以放在方法声明中，表示整个方法为同步方法
public synchronized void m (String name) {
    //需要被同步的代码
}
1
2
3
public class SellTicket {
    public static void main(String[] args) {
        SellTicket03 sellTicket03 = new SellTicket03();
        new Thread(sellTicket03).start();
        new Thread(sellTicket03).start();
        new Thread(sellTicket03).start();
    }
}


//实现接口方式，使用 synchronized 实现线程同步
class SellTicket03 implements Runnable {
    private int ticketNum = 100; //让多个线程共享 ticketNum
    private boolean loop = true; //控制 run 方法变量
    public synchronized void sell() { //同步方法，在同一时刻，只能有一个线程来执行 sell 方法
        //会出现互斥同步问题是因为下面的 ticketNum 还没来得及减，其他线程就涌进来了，导致 if 没有控制住，这样就会多读,加上 synchronized 关键字后同一时刻只能进来一个线程，这样就可以解决同步互斥问题
        if (ticketNum <= 0) {
            System.out.println("售票结束...");
            loop = false;
            return;
        }
        //如果还有票，休眠 50ms
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("窗口: " + Thread.currentThread().getName() + " 售出一张票" + " 剩余票数: " + (--ticketNum));
    }
    @Override
    public void run() {
        while (loop) {
            sell(); //sell方法是同步方法
        }
    }
}
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
32
33
34
35
36

# 8.7.2 互斥锁

# 8.7.2.1 基本介绍

  1. Java 语言中，引入了对象互斥锁的概念来保证共享数据操作的完整性

  2. 每个对象都对应于一个可称为 "互斥锁" 的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象

  3. 关键字 synchronized 与对象的互斥锁联系，当某个对象用 synchronized 修饰时，表明该对象在任一时刻只能由一个线程访问

  4. 同步的局限性：导致程序的执行效率要降低

  5. 同步方法【非静态的】的锁可以是 this，也可以是其他对象【要求是同一个对象】

  6. 同步方法【静态的】的锁为当前类本身

# 8.7.2.2 注意事项和细节

  1. 同步方法如果没有使用 static 修饰则默认锁对象为 this

  2. 如果方法使用 static 修饰，默认锁对象为 当前类.class

  3. 实现的落地步骤：

    需要先分析上锁的代码

    选择同步代码块或同步方法

    要求多个线程的锁对象为同一个即可

# 8.7.3 线程死锁

# 8.7.3.1 基本介绍

多个线程都占用了对方的锁资源但不肯相让导致了死锁，在编程中要避免死锁的发生

# 8.7.3.2 应用案例

public class DeadLock_ {
    public static void main(String[] args) {
        //模拟死锁现象
        DeadLockDemo A = new DeadLockDemo(true);
        A.setName("A线程");
        DeadLockDemo B = new DeadLockDemo(false);
        B.setName("B线程");
        A.start();
        B.start();
    }
}

//线程
class DeadLockDemo extends Thread {
    static Object o1 = new Object(); //保证多线程共享一个对象这里使用 static,不管有多少个 DeadLockDemo,用的都是同一个 o1 o2
    static Object o2 = new Object();
    boolean flag;

    public DeadLockDemo(boolean flag) {
        this.flag = flag;
    }

    @Override
    public void run() {
        /**
         * 1. 如果 flag 为 True,线程 A 就会先得到/持有 o1 对象锁，然后尝试去获取 o2 对象锁
         * 2. 如果线程 A 得不到 o2 对象锁，就会阻塞/死锁/Blocked
         * 3. 如果 flag 为 False,线程 B 就会先得到/持有 o2 对象锁，然后尝试去获取 o1 对象锁
         * 4. 如果线程 B 得不到 o1 对象锁，就会阻塞/死锁/Blocked
         * */

        if (flag) {
            synchronized (o1) { //对象互斥锁，下面就是同步代码
                System.out.println(Thread.currentThread().getName() + "进入1");
                synchronized (o2) { //这里获得li对象的监视权
                    System.out.println(Thread.currentThread().getName() + "进入2");
                }
            }
        } else {
            synchronized (o2) {
                System.out.println(Thread.currentThread().getName() + "进入3");
                synchronized (o1) { //这里获得 li 对象的监视权
                    System.out.println(Thread.currentThread().getName() + "进入4");
                }
            }
        }
    }
}
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

# 8.7.4 释放锁

# 8.7.4.1 哪些操作会释放锁

（1）当前线程的同步方法、同步代码块执行结束

（2）当前线程在同步代码块、同步方法中遇到 break、return

（3）当前线程在同步代码块、同步方法中出现了未处理的 Error 或 Exception，导致异常结束

（4）当前线程在同步代码块、同步方法中执行了线程对象的 wait() 方法，当前线程暂停并释放锁

# 8.7.4.2 哪些操作不会释放锁

（1）线程执行同步代码块或同步方法时，程序调用 Thread.sleep()、Thread.yield() 方法暂停当前线程的执行，不会释放锁

（2）线程执行同步代码块时，其他线程调用了该线程的 suspend() 方法将该线程挂起，该线程不会释放锁。应尽量避免使用 suspend() 和 resume() 来控制线程，方法不再推荐使用

# 8.8 本章作业

# 8.8.1 编程题1

（1）在 main 方法中启动两个线程

（2）第 1 个线程循环随机打印 100 以内的整数

（3）直到第 2 个线程从键盘读取了 "Q" 命令

public class Homework01 {
    public static void main(String[] args) {
        A a = new A();
        B b = new B(a);
        a.start();
        b.start();
    }
}

//创建 A 线程类
class A extends Thread {
    private boolean loop = true;

    @Override
    public void run() {
        //输出 1-100 数字
        while (loop) {
            System.out.println((int)(Math.random() * 100 + 1));
            //休眠
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public void setLoop(boolean loop) { //可以修改 loop 变量
        this.loop = loop;
    }
}

//直到第 2 个线程从键盘读取了 "Q" 命令
class B extends Thread {
    private A a;
    private Scanner scanner = new Scanner(System.in);
    public B(A a) { //构造器中，直接传入A类对象
        this.a = a;
    }

    @Override
    public void run() {
        while(true) {
            //接收到用户的输入
            System.out.println("请输入你的指令(Q)表示退出");
            char key = scanner.next().toUpperCase().charAt(0);
            if (key == 'Q') {
                //以通知的方式结束 a 线程
                a.setLoop(false);
                System.out.println("b线程退出");
                break;
            }
        }
    }
}
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

# 8.8.2 编程题2

（1）有 2 个用户分别从同一个卡上取钱（总额：10000）

（2）每次都取 1000，当余额不足时就不能取款了

（3）不能出现超取现象，即线程同步问题

public class Homework02 {
    public static void main(String[] args) {
        T t = new T();
        Thread thread1 = new Thread(t);
        thread1.setName("t1");
        Thread thread2 = new Thread(t);
        thread2.setName("t2");
        thread1.start();
        thread2.start();
    }
}

//取款的线程
//1. 因为这里涉及到多个线程共享资源，所以我们使用实现 Runnable 方式
class T implements Runnable {
    private int money = 10000;

    @Override
    public void run() {
        while (true) {
            /**
             * 1. 这里使用 synchronized 实现了线程同步
             * 2. 当多个线程执行到这里时，就会去争夺 this 对象锁
             * 3. 哪个线程争夺到 this 对象锁，就执行 synchronized 代码块，执行完后会释放 this 对象锁
             * 4. 争夺不到 this 对象锁，就阻塞，准备继续争夺
             * */
            synchronized (this) {
                //判断余额是否够
                if (money < 1000) {
                    System.out.println("余额不足");
                    break;
                }
                money -= 1000;
                System.out.println(Thread.currentThread().getName() + " 取出了1000 当前余额 = " + money);
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}
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
32
33
34
35
36
37
38
39
40
41
42
43
最近更新: 3/24/2025, 2:07:09 PM
第八章 多线程
开发笔记   |