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

1. 继承 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 实现步骤

1. 创建一个实现了 Runnable 接口的类。
2. 在 run() 方法中写入线程的任务逻辑。
3. 将 Runnable 对象传递给 Thread 对象。
4. 调用 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();
    }
}

代码解释

1. 实现 Runnable 接口：

   • 我们创建了 MyRunnable 类，它实现了 Runnable 接口，并重写了 run() 方法。
   • 在 run() 方法中定义线程的执行逻辑，包括无限循环、每 1 秒输出一次 "Hello world"，并通过 Thread.sleep(1000) 使线程暂停 1 秒。

2. 异常处理：

   • 和 Thread 类中的情况一样，Thread.sleep() 可能抛出 InterruptedException，因此我们需要在 run() 方法中使用 try-catch 来处理这个异常。

3. 创建线程并启动：

   • 我们不能直接调用 myRunnable.run() 来启动线程，而是要将 MyRunnable 对象传递给 Thread 对象，然后通过 Thread 的 start() 方法来启动新线程。
   • 这时，Thread 会自动调用 myRunnable 的 run() 方法，开始执行线程任务。

Runnable 与 Thread 的区别总结

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