Java重修笔记 第五十四天 坦克大战（四）多线程基础

• 线程

       当点击运行按钮运行程序时，就相当于启动了一个进程，虚拟机进入 mian 方法后会开启一个名为 mian 的主线程，main 方法体中创建一个线程对象，调用该线程对象的 start 方法又创建一个子线程，子线程的启动并不会阻塞主线程剩余代码继续执行。

        主线程结束后并不会影响进程的结束，只有当该进程下的所有线程全部结束后，该进程才会结束。

• Jconsole 工具的使用

        在程序运行时，打开下面的 Terminal 终端显示框，输入 Jconsole 便可打开监视和管理控制台，其中便可找到对应线程查看状态。

        若无法看到本地线程，可参考以下文章解决：

运行jconsole无法看到本地进程_jconsole找不到本地进程-CSDN博客文章浏览阅读1.2k次，点赞3次，收藏3次。设置完全控制_jconsole找不到本地进程https://blog.csdn.net/weixin_49107940/article/details/127963204

• 关于 start 方法

        只有调用线程对象 start 方法才能创建出一个子线程，子线程不影响主线程的执行，如果只调用线程对象的 run 方法，那就不会创建新线程，还是在主线程中运行，阻塞主线程直到 run 方法执行完毕。

        start 方法底层会调用 start0 方法，此方法才真正实现多线程的效果。当然 start0 并不会直接创建线程，而是将线程的状态改变为“可运行状态”，具体什么时候执行，取决于CPU统一调度。

• 创建线程

1. 通过继承 Thread 类来创建线程

        （1）让对象类继承 Thread 类，而 Thread 类实现了 Runnable 接口，该类就可以当做一个线程使用

        （2）重写 Runnable 接口里的 run 方法，在方法体中写上自己的业务逻辑

        （3）创建线程类对象，调用线程类对象的 start 方法来启动该线程，启动子线程后并不会阻塞主线程下面的代码继续执行

public class Thread01 {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.start();
        try {
            for (int i = 0; i < 10; i++) {
                Thread.sleep(1000);
                System.out.println("主线程输出第" + i + "次");
            }
        } catch (InterruptedException e) {
            System.out.println(e.getMessage());
        }
    }
}

class Cat extends Thread {

    private static int count;

    @Override
    public void run() {
        do {
            count++;
            System.out.println("第" + count + "次输出, 线程名为: " + Thread.currentThread().getName());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                System.out.println(e.getMessage());
            }
        } while (count != 80);
    }
}

2. 通过实现 Runnable 接口来创建线程

        （1）让对象类实现 Runnable 接口

        （2）重写 Runnable 接口里的 run 方法，在方法体中写上自己的业务逻辑

        （3）创建线程类对象，然后创建 Thread 类对象，把线程类对象作为参数放到 Thread 类的构造方法中（静态代理模式）

        （4）调用 Thread 类对象的 start 方法

public class Thread02 {
    public static void main(String[] args) {
        new Thread(new Dog()).start();
    }
}

class Dog implements Runnable {

    public static int count = 0;

    @Override
    public void run() {
        try {
            do {
                count++;
                System.out.println("第" + count + "次输出, 线程名为: " + Thread.currentThread().getName());
                Thread.sleep(1000);
            } while (count < 80);
        } catch (InterruptedException e) {
            System.out.println(e.getMessage());
        }
    }
}

• 线程退出-通知方式

        简单来说就是在线程类中设置一个变量，并向外暴露修改方法，通过线程对象的 set 方法来操作这个变量，以实现手动控制 run 方法退出这个子线程。

public class ThreadExit_ {
    public static void main(String[] args) {
        MyThread04 myThread04 = new MyThread04();
        myThread04.start();
        // 主线程休眠 10 秒后退出子线程
        try {
            Thread.sleep(1000 * 10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        myThread04.setLoop(false);
    }
}

class MyThread04 extends Thread {

    private boolean loop = true;

    private int count = 0;

    public boolean isLoop() {
        return loop;
    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }
    
    @Override
    public void run() {
        try {
            while (loop) {
                if (count++ == 1000) {
                    break;
                }
                Thread.sleep(100);
                System.out.println(Thread.currentThread().getName() + "运行中... " + count);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}