Java面向对象（高级）- 多线程

Java 多线程

- 多线程基础（理论）

- Java 线程基础

- Java中线程的状态与转换

• 新建（New）

  当线程对象对创建后，例如Thread t = new Thread()，它并没有开始运行，处于新建状态。

• 可运行(Runnable)

  一个新创建的消除并不自动开始运行，调用 start() 方法处于Ready，调用 run() 方法处于Running，因此包含了操作系统线程状态中的 Ready 和 Running。

• 阻塞(Blocked)

  暂时停止执行，获取一个排它锁，将资源交给其他线程使用，待其他线程释放了锁就会结束此状态，属于被动描述状态。

• 等待(Waiting)

  • 无限等待(Waiting)：调用 Object.wait() 方法，属于主动的挂起线程。
  • 有限等待(Time Waiting)：调用 Thread.sleep() 方法，属于主动的睡眠线程。

• 死亡(Terminated)

  当线程完成执行或被中断，它就进入死亡状态。

- Java中实现多线程的两种方式：

• 继承Thread类

  public class MyThread extends Thread {
      private String name;
  
      public MyThread(String name) {
          this.name = name;
      }
  
      @Override
      public void run() {
          System.out.println("线程 " + name + " 正在运行...");
          // 这里执行具体的线程任务
      }
  
      public static void main(String[] args) {
          MyThread thread1 = new MyThread("线程1");
          thread1.start();
          
          MyThread thread2 = new MyThread("线程2");
          thread2.start();
      }
  }
  

• 实现Runnable接口（无返回值）

  public class RunnableTask implements Runnable {
      private String taskName;
  
      public RunnableTask(String taskName) {
          this.taskName = taskName;
      }
  
      @Override
      public void run() {
          System.out.println("Runnable任务 " + taskName + " 正在运行...");
          // 这里执行具体的线程任务
      }
  
      public static void main(String[] args) {
          RunnableTask task1 = new RunnableTask("任务1");
          Thread thread1 = new Thread(task1);
          thread1.start();
  
          RunnableTask task2 = new RunnableTask("任务2");
          Thread thread2 = new Thread(task2);
          thread2.start();
      }
  }
  
  

• 实现Callable接口（可以有返回值通过java.util.concurrent.FutureTask进行封装）

  import java.util.concurrent.Callable;
  import java.util.concurrent.FutureTask;
  
  public class CallableTask implements Callable<String> {
      private String taskName;
  
      public CallableTask(String taskName) {
          this.taskName = taskName;
      }
  
      @Override
      public String call() throws Exception {
          System.out.println("Callable任务 " + taskName + " 正在运行...");
          // 执行计算任务并返回结果
          return "任务 " + taskName + " 完成后的结果";
      }
  
      public static void main(String[] args) {
          CallableTask task = new CallableTask("可返回结果的任务");
  
          FutureTask<String> futureTask = new FutureTask<>(task);
          Thread thread = new Thread(futureTask);
          thread.start();
  
          try {
              // 获取线程执行结果
              String result = futureTask.get();
              System.out.println("Callable任务的结果：" + result);
          } catch (Exception e) {
              e.printStackTrace();
          }
      }
  }
  

- Java 中的锁

- 涉及的关键词 final 、synchronized、volatile

- J.U.C开发包理解

从JDK5开始，Java提供了一个专门用于多线程开发的包java.util.concurrent，简称J.U.C。

注

待完成：此处还需进一步补充完善...