第14章多线程基础

14.1 线程相关概念

14.1.1 程序（program）

是为完成特定任务，用某种语言编写的一组指令的集合，即编写的代码。
示例代码（以Java为例）：

public class BallMove extends JFrame { 
    MyPanel mp = null;
    public static void main(String[] args) { 
        BallMove ballMove = new BallMove(); 
    }
    public BallMove() {
        mp = new MyPanel();
        this.add(mp);
        this.setSize(400, 300);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setVisible(true);
    }
}

14.1.2 进程

运行中的程序，如启动QQ、迅雷，操作系统会为其分配内存空间。
是程序的一次执行过程，有产生、存在和消亡的动态过程。

14.1.3 线程

由进程创建，是进程的实体，一个进程可拥有多个线程。
举例：后续会将多线程加入“坦克大战”游戏实践。

14.1.4 其他相关概念

单线程：同一时刻仅允许执行一个线程。
多线程：同一时刻可执行多个线程，如QQ同时开多个聊天窗口、迅雷同时下载多个文件。
并发：同一时刻多个任务交替执行，单CPU实现“貌似同时” 。
并行：同一时刻多个任务真正同时执行，多核CPU可实现，Java支持。

14.2 线程基本使用

14.2.1 创建线程的两种方式（Java）

继承Thread类：重写run方法，定义线程执行逻辑。
实现Runnable接口：重写run方法，解决Java单继承局限，更灵活。

14.2.2 应用案例1 - 继承`Thread`类

package com.ming.threaduse;

/**
 * @author 明
 * @version 1.0
 * 演示通过继承Thread 类创建线程
 */
public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        //创建Cat对象，可以当做线程使用
        Cat cat = new Cat();

        //读源码
        /*
            (1)
            public synchronized void start() {
                start0();
            }
            (2)
            //start0() 是本地方法，是JVM调用, 底层是c/c++实现
            //真正实现多线程的效果， 是start0(), 而不是 run
            private native void start0();

         */


        //cat.run();//run方法就是一个普通的方法, 没有真正的启动一个线程，就会把run方法执行完毕，才向下执行
        //说明: 当main线程启动一个子线程 Thread-0, 主线程不会阻塞, 会继续执行
        //这时 主线程和子线程是交替执行..
        cat.start();//启动线程-> 最终会执行cat的run方法

        System.out.println("主线程继续执行" +  Thread.currentThread().getName());
        for (int i = 0; i < 10; i++) {
            System.out.println("主线程 i= " + i);
            //让主线程休眠
            Thread.sleep(1000);
        }
    }
}
//说明
//1.当一个类继承了Thread类，该类就可以当作线程使用
//2. 我们会重写 run方法，写上自己的业务代码
//3. run Thread 类 实现了 Runnable 接口的run方法
/*
    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
 */
class Cat extends Thread{

    int times = 0;
    @Override
    public void run() {//重写run方法，写上自己的业务逻辑


        while (true) {
            System.out.println("喵喵，我是小猫咪"+times++ + Thread.currentThread().getName());

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
               e.printStackTrace();
            }
            if(times==8){
                break;
            }
        }
    }
}

14.2.3 应用案例2 - 实现`Runnable`接口

需求：每隔1秒在控制台输出“hi!”，输出10次后退出。
实现：

package com.ming.threaduse;

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

/**
 * @author 明
 * @version 1.0
 * 通过实现接口Runnable 来开发线程
 */
public class Thread02 {
    public static void main(String[] args) throws InterruptedException {
//        Dog dog = new Dog();
//        //dog.start(); 这里不能调用start
//        //创建了Thread对象，把 dog对象(实现Runnable),放入Thread
//        Thread thread = new Thread(dog);
//        thread.start();
        Tiger tiger = new Tiger();
        ThreadProxy threadProxy = new ThreadProxy(tiger);
        threadProxy.start();
    }
}

class Animal {
}

class Tiger extends Animal implements Runnable {

    @Override
    public void run() {
        System.out.println("老虎嗷嗷叫....");
    }
}

//线程代理类 , 模拟了一个极简的Thread类
class ThreadProxy implements Runnable {//你可以把Proxy类当做 ThreadProxy

   private Runnable target = null;//属性，类型是 Runnable

    @Override
    public void run() {
        if (target != null) {
            target.run();//动态绑定（运行类型Tiger）
        }
    }

    public ThreadProxy(Runnable target) {
        this.target = target;
    }

    public void start() {
        start0();//这个方法时真正实现多线程方法
    }

    public void start0() {
        run();
    }
}

class Dog implements Runnable {
    int count = 0;
    @Override
    public void run() {
        while (true) {
            System.out.println("小狗汪汪叫..hi" + (++count) + Thread.currentThread().getName());

            //休眠1秒
            try {
                Thread.sleep(1000);
            }catch (Exception e){
                e.printStackTrace();
            }
            if(count == 10){
                break;
            }
        }
    }
}

14..2.4线程使用应用案例-多线程执行

package com.ming.threaduse;

/**
 * @author 明
 * @version 1.0
 * main线程启动两个子线程
 */
public class Thread03 {
    public static void main(String[] args) {
        T1 t1 = new T1();
        T2 t2 = new T2();
        Thread thread1 = new Thread(t1);
        Thread thread2 = new Thread(t2);
        thread1.start();
        thread2.start();
    }
}
class T1 implements Runnable{
    int count = 0;
    @Override
    public void run() {
        while (true) {
            System.out.println("hello,world  " + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 10){
                break;
            }
        }
    }
}

class T2 implements Runnable{
    int count = 0;
    @Override
    public void run() {
        while (true) {
            System.out.println("hi  " + (++count));
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (count == 5){
                break;
            }
        }
    }
}

14.3 继承`Thread` vs 实现`Runnable`的区别

设计角度：Thread类本身实现Runnable接口，本质无区别，但实现接口更灵活。
适用场景：实现Runnable适合多线程共享资源，且避免单继承限制，推荐优先使用。
案例：售票系统
模拟三个售票窗口售100张票，对比两种方式，分析线程安全等问题（如资源竞争导致超卖，后续需同步机制解决）。

package com.ming.ticket;

import com.hspedu.ticket.SellTicket;

/**
 * @author 明
 * @version 1.0
 * 使用多线程，模拟三个窗口同时售票100张
 */
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();//启动售票线程

        System.out.println("===使用实现接口方式来售票=====");
        SellTicket02 sellTicket02 = new SellTicket02();

        new Thread(sellTicket02).start();
        new Thread(sellTicket02).start();
        new Thread(sellTicket02).start();
    }
}
//使用Thread方式
class SellTicket01 extends Thread {

    private static int ticketNum = 100;//让多个线程共享ticketNum

    @Override
    public void run() {
        while (true){
            if (ticketNum <= 0){
                System.out.println("售票结束~~");
                break;
            }
            //休息50ms
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                    + " 剩余票数=" + (--ticketNum));//1 - 0 - -1  - -2
        }
    }
}
class SellTicket02 implements  Runnable {
    private int ticketNum = 100;

    @Override
    public void run() {
        while (true) {
            if (ticketNum <= 0) {
                System.out.println("售票结束~~");
                break;
            }
            //休息50ms
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                    + " 剩余票数=" + (--ticketNum));//1 - 0 - -1  - -2
        }
    }
}

14.4 线程终止

14.4.1 基本说明

线程完成任务后自动退出。
也可通过修改变量控制run方法退出（通知方式），不推荐强制终止（如stop方法已弃用）。

14.4.2 应用案例（`ThreadExit.java`）

需求：在main线程中停止子线程，通过标志位控制。
示例逻辑：定义子线程类，用布尔变量标记是否继续执行，main线程触发标记改变终止子线程。

package com.ming.exit_;

/**
 * @author 明
 * @version 1.0
 */
public class ThreadExit_ {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        t.start();

        //如果希望main线程去控制t1 线程的终止, 必须可以修改 loop
        //让t1 退出run方法，从而终止 t1线程 -> 通知方式

        //让主线程休眠 10 秒，再通知 t1线程退出
        System.out.println("main线程休眠10s...");
        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);// 让当前线程休眠50ms
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("T 运行中...." + (++count));
        }

    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}

14.5 线程常用方法

14.5.1 常用方法第一组

setName/getName：设置、获取线程名称。
start：启动线程，JVM调用run方法。
run：线程执行体，直接调用是普通方法调用，非启动新线程。
setPriority/getPriority：设置、获取线程优先级（1 - 10，默认5 ）。
sleep：让当前线程休眠指定毫秒数，阻塞状态。
interrupt：中断线程（需配合处理InterruptedException ）。

14.5.2 注意事项

start才会真正启动新线程，直接调run是普通方法调用。
优先级仅为调度提示，不保证执行顺序。
interrupt用于中断阻塞线程，需合理处理中断逻辑。

14.5.3 应用案例（`ThreadMethod01.java`）

测试上述方法，如创建线程设置名称、优先级，演示sleep、interrupt等用法。

package com.ming.method;

/**
 * @author 明
 * @version 1.0
 */
public class ThreadMethod01 {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        t.setName("小明");
        t.setPriority(Thread.MIN_PRIORITY);
        t.start();

        //主线程打印5个 hi ，然后就中断 子线程的休眠
        for (int i = 0; i < 5; i++) {
            Thread.sleep(1000);
            System.out.println("hi " + i);
        }
        System.out.println(t.getName() + " 线程的优先级 =" + t.getPriority());//1

        t.interrupt();//当执行到这里，就会中断 t线程的休眠.
    }
}


class T extends Thread { //自定义的线程类
    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 100; i++) {
                //Thread.currentThread().getName() 获取当前线程的名称
                System.out.println(Thread.currentThread().getName() + "  吃包子~~~~" + i);
            }
            try {
                System.out.println(Thread.currentThread().getName() + " 休眠中~~~");
                Thread.sleep(20000);//20秒
            } catch (InterruptedException e) {
                //当该线程执行到一个interrupt 方法时，就会catch 一个 异常, 可以加入自己的业务代码
                //InterruptedException 是捕获到一个中断异常.
                System.out.println(Thread.currentThread().getName() + "被 interrupt了");
            }
        }
    }
}

14.5.4 常用方法第二组

yield：线程礼让CPU，让其他线程执行，礼让时间不确定，不一定成功。
join：线程插队，调用join的线程会阻塞，直到被调用线程执行完毕。
- 案例：main线程创建子线程，按规则输出内容，结合join控制执行顺序。

14.5.5 应用案例（`ThreadMethod02.java`）

测试yield和join：

package com.ming.method;

/**
 * @author 明
 * @version 1.0
 */
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(1000);//休眠1秒
            System.out.println("主线程 吃了 " + i +  " 包子");
            if(i == 5){
                System.out.println("主线程(小弟) 让 子线程(老大) 先吃");
                //join, 线程插队
                //t2.join();// 这里相当于让t2 线程先执行完毕
                Thread.yield();//礼让，不一定成功..
                System.out.println("线程(老大) 吃完了 主线程(小弟) 接着吃..");
            }
        }
    }
}

class T2 extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 20; i++) {
            try {
                Thread.sleep(1000);//休眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程(老大) 吃了 " + i +  " 包子");
        }
    }
}

（演示join使子线程优先执行完部分逻辑，体会线程协作。）

14.5.6 课堂练习

package com.ming.method;

/**
 * @author 明
 * @version 1.0
 */
public class ThreadMethod0Exercise {

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

class T3 extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            try {
                Thread.sleep(1000);//休眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("hello " + i);
        }
    }
}

14.5.7 用户线程和守护线程

用户线程：也叫工作线程，任务执行完或通过通知方式结束。
守护线程：为工作线程服务，所有用户线程结束后，守护线程自动结束，典型如垃圾回收机制。
应用案例：ThreadMethod03.java，演示将线程设置为守护线程的操作。

package com.ming.method;

/**
 * @author 明
 * @version 1.0
 */
public class ThreadMethod03 {
    public static void main(String[] args) throws InterruptedException {
        MyDaemom myDaemom = new MyDaemom();
        myDaemom.setDaemon(true);
        myDaemom.start();
        for( int i = 1; i <= 10; i++) {//main线程
            System.out.println("宝强在辛苦的工作...");
            Thread.sleep(1000);
        }
    }
}
class MyDaemom extends Thread {
    @Override
    public void run() {
        for(;;){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("马蓉和宋喆快乐聊天，哈哈哈~~~");
        }
    }
}

14.6 线程的生命周期

14.6.1 线程状态（JDK 中 `Thread.State` 枚举表示）

NEW：线程尚未启动。
RUNNABLE：线程在 Java 虚拟机中执行。
BLOCKED：线程被阻塞，等待监视器锁。
WAITING：线程等待另一个线程执行特定动作。
TIMED_WAITING：线程等待另一个线程执行动作，且有指定等待时间。
TERMINATED：线程已退出。

package com.ming.state_;

/**
 * @author 明
 * @version 1.0
 */
public class ThreadState_ {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        System.out.println(t.getName() + "状态 "+t.getState());
        t.start();
        while(t.getState()!=Thread.State.TERMINATED){
            System.out.println(t.getName() + "状态 "+t.getState());
            Thread.sleep(500);
        }
        System.out.println(t.getName() + "状态 "+t.getState());
    }
}
class T extends Thread {
    @Override
    public void run() {
        for(int i = 1; i <= 10; i++) {
            System.out.println("hi " + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

14.7 线程的同步

14.7.1 问题引出（以窗口售票为例）

多线程同时操作共享资源（如售票系统的余票），可能导致数据不一致（超卖、错卖等问题）。

14.8 `Synchronized` 同步机制

14.8.1 同步原理

多线程编程中，敏感数据不允许被多个线程同时访问，通过同步技术保证同一时刻最多一个线程访问，确保数据完整性。也可理解为：一个线程操作内存时，其他线程无法访问该内存地址，直到操作完成。

14.8.2 同步具体方法

同步代码块：

synchronized (对象) { 
    // 需同步的代码（获得对象锁后执行）
}

同步方法：在方法声明前加 synchronized，表示整个方法为同步方法：
```
public synchronized void method(String name) {
    // 需同步的代码
}
```
理解类比：如同上厕所先关门（上锁），完事再开门（解锁），保证同一时间只有一个“使用者” 。
应用：用 synchronized 解决售票问题，避免多线程竞争导致的错误。

14.9 分析同步原理

14.10 互斥锁

14.10.1 基本介绍

Java 引入对象互斥锁，保证共享数据操作完整性，每个对象对应一个“互斥锁”标记，确保同一时刻只有一个线程访问该对象。
synchronized 关键字与互斥锁关联，修饰对象时，标记对象同一时刻只能被一个线程访问。
同步局限性：会降低程序执行效率；同步方法（非静态）锁对象默认是 this，也可为其他同一对象；静态同步方法锁对象是当前类的 class 对象。

14.10.2使用互斥锁来解决售票问题

package com.ming.syn;

/**
 * @author 明
 * @version 1.0
 * 使用多线程，模拟三个窗口同时售票100张
 */
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();//启动售票线程

//        System.out.println("===使用实现接口方式来售票=====");
//        SellTicket02 sellTicket02 = new SellTicket02();
//
//        new Thread(sellTicket02).start();
//        new Thread(sellTicket02).start();
//        new Thread(sellTicket02).start();

        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;
    private boolean loop = true;
    private Object lock = new Object();

    //同步方法（静态的）的锁为当前类本身
    //解读
    //1. public synchronized static void m1() {} 锁是加在 SellTicket03.class
    //2. 如果在静态方法中，实现一个同步代码块.
    /*
        synchronized (SellTicket03.class) {
            System.out.println("m2");
        }
     */
    public synchronized static void m1() {

    }
   public  static void m2() {
        synchronized (SellTicket03.class) {
            System.out.println("m2");
        }
    }

    //说明
    //1. public synchronized void sell() {} 就是一个同步方法
    //2. 这时锁在 this对象
    //3. 也可以在代码块上写 synchronize ,同步代码块, 互斥锁还是在this对象
        public  void sell(){//同步方法，在同一时刻，只能有一个线程执行run方法
            synchronized (lock) {
                if (ticketNum <= 0) {
                    System.out.println("售票结束~~");
                    loop = false;
                    return;
                }
                //休息50ms
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                        + " 剩余票数=" + (--ticketNum));//1 - 0 - -1  - -2
            }

    }

    @Override
    public  void run() {
        while (loop) {
            sell();
        }
    }
}


//使用Thread方式
class SellTicket01 extends Thread {

    private static int ticketNum = 100;//让多个线程共享ticketNum

    @Override
    public void run() {
        while (true){
            if (ticketNum <= 0){
                System.out.println("售票结束~~");
                break;
            }
            //休息50ms
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                    + " 剩余票数=" + (--ticketNum));//1 - 0 - -1  - -2
        }
    }
}
class SellTicket02 implements  Runnable {
    private int ticketNum = 100;

    @Override
    public void run() {
        while (true) {
            if (ticketNum <= 0) {
                System.out.println("售票结束~~");
                break;
            }
            //休息50ms
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
                    + " 剩余票数=" + (--ticketNum));//1 - 0 - -1  - -2
        }
    }
}

14.10.3 注意事项和细节

同步方法未用 static 修饰，默认锁对象是 this；用 static 修饰，默认锁对象是 当前类.class。
实现步骤：分析上锁代码 → 选择同步代码块或同步方法 → 确保多个线程锁对象相同。

14.11 线程的死锁

14.11.1 基本介绍

多个线程互相占用对方所需的锁资源，且都不释放，导致程序“卡死”，编程需避免。

14.11.2 应用案例（生活场景）

妈妈要求“完成作业才让玩手机”，小明要求“让玩手机才完成作业”，双方互不相让，形成死锁。

14.11.3 应用案例（代码）

DeadLock_.java，演示代码中线程因互相等待锁资源导致死锁的场景。

package com.ming.syn;

/**
 * @author 明
 * @version 1.0
 */
public class DeadLock_ {
    public static void main(String[] args) {
        DeadLockDemo a = new DeadLockDemo(true);
        DeadLockDemo b = new DeadLockDemo(false);
        a.setName("a线程");
        b.setName("b线程");
        a.start();
        b.start();
    }
}
//线程
class DeadLockDemo extends Thread {
    static Object o1 = new Object();// 保证多线程，共享一个对象,这里使用static
    static Object o2 = new Object();
    boolean flag;

    public DeadLockDemo(boolean flag) {//构造器
        this.flag = flag;
    }

    @Override
    public void run() {

        //下面业务逻辑的分析
        //1. 如果flag 为 T, 线程A 就会先得到/持有 o1 对象锁, 然后尝试去获取 o2 对象锁
        //2. 如果线程A 得不到 o2 对象锁，就会Blocked
        //3. 如果flag 为 F, 线程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");
                }
            }
        }
    }
}

14.12 释放锁

14.12.1 会释放锁的操作

同步方法/代码块执行结束（如“上完厕所出来” ）。
同步代码块/方法中遇到 break、return（如“没正常完事，但因特殊情况退出” ）。
同步代码块/方法中出现未处理的 Error 或 Exception，导致异常结束（如“忘带纸，被迫出来” ）。
同步代码块/方法中执行 wait() 方法，当前线程暂停并释放锁（如“觉得需要酝酿，出来等会再进去” ）。

14.12.2 不会释放锁的操作

线程执行同步代码块/方法时，调用 Thread.sleep()、Thread.yield() 暂停执行（如“上厕所时在坑位上眯一会” ，不释放锁）。
其他线程调用当前线程的 suspend() 方法挂起线程（suspend()、resume() 方法已不推荐使用，易导致死锁等问题）。

14.13 本章作业

1. `Homework01.java`（5分钟）

需求：main 方法启动两个线程，第一个线程循环随机打印 100 以内整数，直到第二个线程从键盘读取到“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) {
                e.printStackTrace();
            }
        }
        System.out.println("a线程退出...");

    }

    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;
            }
        }
    }
}

2. `Homework02.java`（5分钟）

需求：模拟 2 个用户从同一银行卡取钱（总额 10000），每次取 1000，余额不足则无法取款，需避免超取（解决线程同步问题）。

（作业需结合多线程、同步机制等知识实现，重点练习线程协作、资源竞争处理。）

package com.ming.homework;


/**
 * @author 明
 * @version 1.0
 */
public class Homework02 {
    public static void main(String[] args) {
        Account account = new Account();
        Thread t1 = new Thread(account);
        Thread t2 = new Thread(account);
        t1.setName("小明");
        t2.setName("张三");
        t1.start();
        t2.start();
    }
}

//编程取款的线程
//1.因为这里涉及到多个线程共享资源，所以我们使用实现Runnable方式
//2. 每次取出 1000
class Account implements Runnable {
    private int balance = 10000;
    private boolean isRunning = true;
    private void drawMoney() {
        //解读
        //1. 这里使用 synchronized 实现了线程同步
        //2. 当多个线程执行到这里时，就会去争夺 this对象锁
        //3. 哪个线程争夺到(获取)this对象锁，就执行 synchronized 代码块, 执行完后，会释放this对象锁
        //4. 争夺不到this对象锁，就blocked ，准备继续争夺
        //5. this对象锁是非公平锁.
        synchronized (this) {
            if (balance  -1000 <= 0) {
                System.out.println("余额不足，不能取款了");
                isRunning = false;
            } else{
                balance = balance - 1000;
                System.out.println(Thread.currentThread().getName() + "正在取钱,取完后还剩"+balance);
            }
        }
    }

    @Override
    public void run() {
        while (isRunning) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            drawMoney();
        }
    }
}

posted @ 2025-08-27 17:06 *珍惜当下* 阅读(27) 评论(0) 收藏举报

刷新页面返回顶部

ming-Infinite-progress

第14章 多线程基础

第14章 多线程基础

14.1 线程相关概念

14.1.1 程序（program）

14.1.2 进程

14.1.3 线程

14.1.4 其他相关概念

14.2 线程基本使用

14.2.1 创建线程的两种方式（Java）

14.2.2 应用案例1 - 继承Thread类

14.2.3 应用案例2 - 实现Runnable接口

14..2.4线程使用应用案例-多线程执行

14.3 继承Thread vs 实现Runnable的区别

14.4 线程终止

14.4.1 基本说明

14.4.2 应用案例（ThreadExit.java）

14.5 线程常用方法

14.5.1 常用方法第一组

14.5.2 注意事项

14.5.3 应用案例（ThreadMethod01.java）

14.5.4 常用方法第二组

14.5.5 应用案例（ThreadMethod02.java）

14.5.6 课堂练习

14.5.7 用户线程和守护线程

14.6 线程的生命周期

14.6.1 线程状态（JDK 中 Thread.State 枚举表示）

14.7 线程的同步

14.7.1 问题引出（以窗口售票为例）

14.8 Synchronized 同步机制

14.8.1 同步原理

14.8.2 同步具体方法

14.9 分析同步原理

14.10 互斥锁

14.10.1 基本介绍

14.10.2使用互斥锁来解决售票问题

14.10.3 注意事项和细节

14.11 线程的死锁

14.11.1 基本介绍

14.11.2 应用案例（生活场景）

14.11.3 应用案例（代码）

14.12 释放锁

14.12.1 会释放锁的操作

14.12.2 不会释放锁的操作

14.13 本章作业

1. Homework01.java（5分钟）

2. Homework02.java（5分钟）

公告

第14章多线程基础

第14章多线程基础

14.2.2 应用案例1 - 继承`Thread`类

14.2.3 应用案例2 - 实现`Runnable`接口

14.3 继承`Thread` vs 实现`Runnable`的区别

14.4.2 应用案例（`ThreadExit.java`）

14.5.3 应用案例（`ThreadMethod01.java`）

14.5.5 应用案例（`ThreadMethod02.java`）

14.6.1 线程状态（JDK 中 `Thread.State` 枚举表示）

14.8 `Synchronized` 同步机制

1. `Homework01.java`（5分钟）

2. `Homework02.java`（5分钟）