JavaEE 多线程第二节 (多线程的简单实现Thread/Runable)

1. 创建线程（继承 `Thread` 类）步骤：

继承 Thread 类：
创建一个类并继承 Thread 类，然后重写 run() 方法，在该方法中写入线程执行的代码

class MyThread extends Thread {
    @Override
    public void run() {
        // 线程执行的代码
        System.out.println("这是新线程执行的代码");
    }
}

2. 实例化线程类：

代码示例：

创建 MyThread 类的实例，用于启动线程。
```
MyThread t = new MyThread();
```
3. 启动线程：
调用线程对象的 start() 方法来启动新线程。start() 方法会自动调用重写的 run() 方法，并在新线程中执行其中的代码。
```
t.start();  // 启动线程
```
解释：
run() 方法：run() 方法包含线程需要执行的代码。当线程启动时，系统会自动调用该方法。当你在 run() 方法里编写代码，这些代码是线程执行时会运行的内容。
但是，如果你直接调用 run()，不会启动新的线程，它只会像普通方法一样在当前线程中运行。

start() 方法：调用 start() 方法来启动线程，而不是直接调用 run() 方法。start() 会在后台启动一个新的线程，并且自动调用 run()。

public class Main implements Callback {
    public static void main(String[] args) {
        MyThreadWithCallback thread = new MyThreadWithCallback(new Main());  // 传递回调对象
        thread.start();
    }

    @Override
    public void onComplete() {
        System.out.println("任务已完成！");
    }
}

为什么不直接调用 run()？

如果你直接调用 run() 方法，它会在当前线程中执行，而不会创建新的线程。而 start() 方法则会告诉 JVM 创建一个新线程来执行 run() 方法。

3. 处理异常

/**
 * Description:
 * Date: 2024-10-11
 * Time: 22:20
 */
package thread;
class MyThread extends Thread{
    @Override
    public void run(){
        while(true){
            System.out.println("Hello world");
            Thread.sleep(1000);
        }

    }
}
public class Main {


        public static void main(String[] args) {

            MyThread t = new MyThread();
            t.start();
        }
    }

此时注意到sleep报错,但是提示只有一种try catch,而没有throws

这是为什么呢?

原因是父类run中,没有throws这样的异常声明,父类重写的时候就不能添加

4.调用jconsole查看线程状态

首先,找到jdk所在位置,找不到jdk的可以从 project sturcture

然后就能找到了

找到之后打开bin文件夹

打开jconsole

线程中的main就是我们运行的main函数

2. 创建线程（继承 `Thread` 类）步骤：

Runnable 与 Thread 的区别

Thread 类：继承 Thread 类后，每个线程是独立的对象，并且可以直接通过调用 start() 来启动线程。
Runnable 接口：实现 Runnable 接口后，线程任务的执行逻辑放在 run() 方法中，但是要通过 Thread 类来启动线程。

Runnable 实现步骤

创建一个实现了 Runnable 接口的类。
在 run() 方法中写入线程的任务逻辑。
将 Runnable 对象传递给 Thread 对象。
调用 Thread 对象的 start() 方法，启动线程。

// 1. 实现 Runnable 接口
class MyRunnable implements Runnable {
    @Override
    public void run() {
        while (true) {
            System.out.println("Hello world");

            // 2. 捕获 InterruptedException 异常
            try {
                Thread.sleep(1000);  // 线程休眠 1 秒
            } catch (InterruptedException e) {
                System.out.println("线程被中断");
                break;  // 当线程被中断时，退出循环
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        // 3. 创建 MyRunnable 对象
        MyRunnable myRunnable = new MyRunnable();

        // 4. 将 MyRunnable 对象传递给 Thread 对象
        Thread t = new Thread(myRunnable);

        // 5. 启动线程
        t.start();
    }
}

代码解释

实现 Runnable 接口：
- 我们创建了 MyRunnable 类，它实现了 Runnable 接口，并重写了 run() 方法。
- 在 run() 方法中定义线程的执行逻辑，包括无限循环、每 1 秒输出一次 "Hello world"，并通过 Thread.sleep(1000) 使线程暂停 1 秒。
异常处理：
- 和 Thread 类中的情况一样，Thread.sleep() 可能抛出 InterruptedException，因此我们需要在 run() 方法中使用 try-catch 来处理这个异常。
创建线程并启动：
- 我们不能直接调用 myRunnable.run() 来启动线程，而是要将 MyRunnable 对象传递给 Thread 对象，然后通过 Thread 的 start() 方法来启动新线程。
- 这时，Thread 会自动调用 myRunnable 的 run() 方法，开始执行线程任务。

Runnable 与 Thread 的区别总结

Thread 类：继承 Thread 类时，线程逻辑直接写在 run() 方法中，线程对象自己持有执行逻辑和启动逻辑（通过 start() 启动）。
Runnable 接口：实现 Runnable 接口时，Runnable 对象只是持有线程的执行逻辑，但启动逻辑由 Thread 类负责。需要将 Runnable 对象交给 Thread 对象来启动线程。