作为经典亮机卡，R7 260X 在 90 度以下风扇不想转，一转起来就是 3000+ rpm，非常吵。需要配下风扇转速到 2500~3000 这样。当然，直接这样调还不行，风扇大概率还是不转，需要 FanControl 再调一下。

FanControl 识别出 GPU 风扇后，点击风扇右侧的省略号，有一个 强制应用 选项，勾上。
先拉到 80，触发它的风扇狂转，然后拉低到 60，此时转速卡在 2800 左右。因为上面 AMD 设置了最小转速，FanControl 拉上来 2800 之后，转速就掉不回 0rpm，就能一直保持着转速，这样就不会让主机太烫。

然后再不断往下试探，调整 AMD 的 rpm 和 FanControl 的 rpm 即可，尽可能降低转速 rpm，减少噪音。

若依部署必须用到的 Nginx 配置：

location / {
    root   /www/wwwroot/dnr/dist;
    try_files $uri $uri/ /index.html;
    index  index.html index.htm;
}

location /prod-api/ {
    proxy_set_header Host $http_host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header REMOTE-HOST $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_pass http://localhost:8081/;
}

配置说明：

• 第一个 location / 块用于前端页面：指定了静态文件的根目录为 /www/wwwroot/dnr/dist，并通过 try_files 指令确保单页面应用（SPA）的路由能正确返回 index.html。
• 第二个 location /prod-api/ 块用于后端 API 代理：将 /prod-api/ 路径下的请求转发到本地后端服务 http://localhost:8081/，同时设置了必要的请求头（如 Host、X-Real-IP、X-Forwarded-For）以保证代理过程中的信息传递。

MyBatis 和 MyBatis-Plus 都是 Java 生态中广泛使用的持久层框架，旨在简化数据库操作。MyBatis-Plus 是在 MyBatis 基础上构建的增强工具，两者在功能、开发效率和使用体验上存在显著差异。以下从多个维度进行详细对比。

1. 功能定位与扩展性

• MyBatis

  • 核心定位：一个半自动化的 ORM 框架，专注于 SQL 与 Java 对象的映射。
  • 功能特点：提供了强大而灵活的方式操作数据库，支持编写自定义 SQL、调用存储过程以及实现复杂的高级结果集映射。它赋予开发者对 SQL 的完全控制权，非常适合复杂、定制化的查询场景。

• MyBatis-Plus

  • 核心定位：MyBatis 的增强工具包，旨在简化开发、提高效率。
  • 功能特点：在保留 MyBatis 所有特性的基础上，内置了大量开箱即用的功能，如通用 CRUD、多种条件构造器、分页插件、代码生成器等，极大地减少了开发者的模板代码编写量。

2. CRUD 操作的实现方式

• MyBatis

  • 需要开发者手动编写每一个增删改查操作的 SQL 语句（在 XML 文件或注解中），并配置对应的参数映射和结果映射。
  • 优点：灵活、精准，能应对所有 SQL 场景。
  • 缺点：对于简单的单表操作，会产生大量重复性代码。

• MyBatis-Plus

  • 提供了通用的 BaseMapper 接口，只需让您的 Mapper 继承该接口，即可直接获得一系列内置方法（如 insert, selectById, update, deleteById 等），无需编写任何 SQL 即可完成基本操作。
  • 配套提供强大的 代码生成器，可一键生成实体类、Mapper 接口、Service、Controller 以及基础的 XML 文件，进一步提升开发速度。

3. 查询条件构建

• MyBatis

  • 构建动态查询条件通常需要在 XML 中使用 <if>, <choose>, <foreach> 等标签拼接 SQL 片段，或者在 Java 代码中拼接 SQL 字符串，过程较为繁琐且不易维护。

• MyBatis-Plus

  • 提供了非常直观的 条件构造器（Wrapper），例如 QueryWrapper、LambdaQueryWrapper、UpdateWrapper。
  • 可以通过链式调用的方式，以面向对象的形式构建查询条件，代码可读性高，且能有效防止 SQL 注入。

  • 示例：

    // 查询年龄大于18且姓“张”的用户
    QueryWrapper<User> wrapper = new QueryWrapper<>();
    wrapper.gt("age", 18).likeRight("name", "张");
    List<User> userList = userMapper.selectList(wrapper);
    
    // 使用Lambda表达式，更安全（避免字段名拼写错误）
    LambdaQueryWrapper<User> lambdaWrapper = new LambdaQueryWrapper<>();
    lambdaWrapper.gt(User::getAge, 18).likeRight(User::getName, "张");

4. 分页功能

• MyBatis

  • 原生支持有限，通常需要开发者自己编写 LIMIT 语句或使用第三方分页插件（如 PageHelper）来实现物理分页。

• MyBatis-Plus

  • 内置了成熟、易用的 分页插件（PaginationInterceptor）。
  • 配置后，只需传入一个 Page 对象作为参数，即可自动完成分页查询和总记录数统计，支持多种数据库方言。
  • 示例：

    Page<User> page = new Page<>(1, 10); // 查询第1页，每页10条
    IPage<User> userPage = userMapper.selectPage(page, queryWrapper);
    List<User> records = userPage.getRecords(); // 当前页数据
    long total = userPage.getTotal(); // 总记录数

5. 性能与扩展插件

• MyBatis

  • 拥有一套插件机制（Interceptor），可以用于实现自定义功能，如 SQL 日志打印、执行时间监控、数据脱敏等。社区也有丰富的第三方插件。

• MyBatis-Plus

  • 在 MyBatis 插件机制的基础上，提供了更多内置的、针对性的优化插件：
    • 性能分析插件：输出 SQL 语句及其执行时间，帮助定位慢查询。
    • 乐观锁插件：通过 @Version 注解轻松实现乐观锁，解决并发更新问题。
    • 动态表名插件：支持在运行时动态切换表名，适用于分表场景。
    • SQL 注入器：允许自定义全局通用方法，如“逻辑删除”、“自动填充”等。

6. 使用场景与总结

结论：
MyBatis-Plus 并非要替代 MyBatis，而是作为其强大的“增强包”。如果你的项目追求极致的开发效率，且业务以常规的 CRUD 为主，MyBatis-Plus 是更优的选择。如果你的项目涉及大量复杂的存储过程、动态 SQL 或对 SQL 性能有极致要求，需要完全掌控每一行 SQL 代码，那么原生 MyBatis 可能更适合。两者可以结合使用，在 MyBatis-Plus 项目中，你依然可以完全使用原生 MyBatis 的方式编写复杂 SQL，兼顾效率与灵活性。

每个 Vue 组件都是一个独立的 Vue 实例，具有自己的模板、数据、方法和生命周期钩子，使得组件可以自包含地定义和管理自己的功能和样式。

组件（Component）是 Vue.js 最强大的功能之一。

组件可以扩展 HTML 元素，封装可重用的代码，可以帮助你将用户界面拆分成独立和可复用的部分。

每个 Vue 组件都是一个独立的 Vue 实例，具有自己的模板、数据、方法和生命周期钩子，使得组件可以自包含地定义和管理自己的功能和样式。

Vue 组件的特性和优势

• 复用性: 组件可以在不同的地方多次使用，提高代码的复用性和可维护性。
• 封装性: 每个组件都是独立的作用域，可以封装自己的状态和逻辑，避免全局污染。
• 组合性: 可以通过组合多个小组件构建复杂的界面。
• 响应式: 组件的数据响应式地绑定到视图，数据更新时自动更新视图。
• 模块化: 支持模块化开发，可以使用现代前端工具链进行构建和管理。

组件系统让我们可以用独立可复用的小组件来构建大型应用，几乎任意类型的应用的界面都可以抽象为一个组件树：

每个 Vue 应用都是通过用 createApp 函数创建的，传递给 createApp 的选项用于配置根组件。当我们挂载应用时，该组件被用作渲染的起点。

一个应用需要被挂载到一个 DOM 元素中。

以下实例我们将 Vue 应用挂载到 <div id="app"></div>，应该传入 #app：

const RootComponent = { /* 选项 */ }
const app = Vue.createApp(RootComponent)
const vm = app.mount('#app')

注册一个全局组件语法格式如下：

const app = Vue.createApp({...})

app.component('my-component-name', {
  /* ... */
})

my-component-name 为组件名，/ ... / 部分为配置选项。注册后，我们可以使用以下方式来调用组件：

<my-component-name></my-component-name>

一个简单的 Vue 组件的实例：

全局组件实例

注册一个简单的全局组件 runoob，并使用它：

<div id="app">
    <runoob></runoob>
</div>

<script>
// 创建一个Vue 应用
const app = Vue.createApp({})

// 定义一个名为 runoob的新全局组件
app.component('runoob', {
    template: '<h1>自定义组件!</h1>'
})

app.mount('#app')
</script>

接下来我们再注册一个 button-counter 组件，在每次点击后，计数器会加 1:

实例

// 创建一个Vue 应用
const app = Vue.createApp({})

// 定义一个名为 button-counter 的新全局组件
app.component('button-counter', {
  data() {
    return {
      count: 0
    }
  },
  template: `
    <button @click="count++">
      点了 {{ count }} 次！
    </button>`
})
app.mount('#app')
</script>

注意：template 中 ` 是反引号，不是单引号 '。

组件的复用

你可以将组件进行任意次数的复用：

实例

<div id="components-demo">
  <button-counter></button-counter>
  <button-counter></button-counter>
  <button-counter></button-counter>
</div>

全局组件

以上的实例中我们的组件都只是通过 component 全局注册的。

全局注册的组件可以在随后创建的 app 实例模板中使用，也包括根实例组件树中的所有子组件的模板中。

全局组件实例

注册一个简单的全局组件 runoob，并使用它：

<div id="app">
    <runoob></runoob>
</div>

<script>
// 创建一个Vue 应用
const app = Vue.createApp({})

// 定义一个名为 runoob 的新全局组件
app.component('runoob', {
    template: '<h1>自定义组件!</h1>'
})

app.mount('#app')
</script>

局部组件

全局注册往往是不够理想的。比如，如果你使用一个像 webpack 这样的构建系统，全局注册所有的组件意味着即便你已经不再使用一个组件了，它仍然会被包含在你最终的构建结果中。这造成了用户下载的 JavaScript 的无谓的增加。

在这些情况下，你可以通过一个普通的 JavaScript 对象来定义组件：

const ComponentA = {
  /* ... */
}
const ComponentB = {
  /* ... */
}
const ComponentC = {
  /* ... */
}

然后在 components 选项中定义你想要使用的组件：

const app = Vue.createApp({
  components: {
    'component-a': ComponentA,
    'component-b': ComponentB
  }
})

对于 components 对象中的每个属性来说，其属性名就是自定义元素的名字（component-a、component-b），其属性值就是这个组件的选项对象（ComponentA、ComponentB）。

我们也可以在实例选项中注册局部组件，这样组件只能在这个实例中使用：

局部组件实例

注册一个简单的局部组件 runoobA，并使用它：

<div id="app">
    <runoob-a></runoob-a>
</div>
<script>
var runoobA = {
  template: '<h1>自定义组件!</h1>'
}

const app = Vue.createApp({
  components: {
    'runoob-a': runoobA
  }
})

app.mount('#app')
</script>

单文件组件 (.vue 文件)

使用单文件组件能够更好地组织和管理 Vue 组件，一个组件通常由三部分组成：模板、脚本和样式。

实例

<!-- MyComponent.vue -->
<template>
  <div>
    <p>{{ message }}</p>
    <button @click="increment">Increment</button>
  </div>
</template>

<script>
export default {
  data() {
    return {
      message: 'Hello from MyComponent',
      count: 0
    };
  },
  methods: {
    increment() {
      this.count++;
    }
  }
};
</script>

<style scoped>
/* 组件私有样式 */
p {
  color: blue;
}
</style>

Prop

prop 是子组件用来接受父组件传递过来的数据的一个自定义属性。

父组件的数据需要通过 props 把数据传给子组件，子组件需要显式地用 props 选项声明 "prop"：

Prop 实例

<div id="app">
  <site-name title="Google"></site-name>
  <site-name title="Runoob"></site-name>
  <site-name title="Taobao"></site-name>
</div>

<script>
const app = Vue.createApp({})

app.component('site-name', {
  props: ['title'],
  template: `<h4>{{ title }}</h4>`
})

app.mount('#app')
</script>

一个组件默认可以拥有任意数量的 prop，任何值都可以传递给任何 prop。

动态 Prop

类似于用 v-bind 绑定 HTML 特性到一个表达式，也可以用 v-bind 动态绑定 props 的值到父组件的数据中。每当父组件的数据变化时，该变化也会传导给子组件：

Prop 实例

<div id="app">
  <site-info
    v-for="site in sites"
    :id="site.id"
    :title="site.title"
  ></site-info>
</div>

<script>
const Site = {
  data() {
    return {
      sites: [
        { id: 1, title: 'Google' },
        { id: 2, title: 'Runoob' },
        { id: 3, title: 'Taobao' }
      ]
    }
  }
}

const app = Vue.createApp(Site)

app.component('site-info', {
  props: ['id','title'],
  template: `<h4>{{ id }} - {{ title }}</h4>`
})

app.mount('#app')
</script>

Prop 验证

组件可以为 props 指定验证要求。

为了定制 prop 的验证方式，你可以为 props 中的值提供一个带有验证需求的对象，而不是一个字符串数组。例如：

Vue.component('my-component', {
  props: {
    // 基础的类型检查 (`null` 和 `undefined` 会通过任何类型验证)
    propA: Number,
    // 多个可能的类型
    propB: [String, Number],
    // 必填的字符串
    propC: {
      type: String,
      required: true
    },
    // 带有默认值的数字
    propD: {
      type: Number,
      default: 100
    },
    // 带有默认值的对象
    propE: {
      type: Object,
      // 对象或数组默认值必须从一个工厂函数获取
      default: function () {
        return { message: 'hello' }
      }
    },
    // 自定义验证函数
    propF: {
      validator: function (value) {
        // 这个值必须匹配下列字符串中的一个
        return ['success', 'warning', 'danger'].indexOf(value) !== -1
      }
    }
  }
})

当 prop 验证失败的时候，(开发环境构建版本的) Vue 将会产生一个控制台的警告。

type 可以是下面原生构造器：

• String
• Number
• Boolean
• Array
• Object
• Date
• Function
• Symbol

type 也可以是一个自定义构造器，使用 instanceof 检测。

OpenClaw 是一款功能强大的开源工具，其设计旨在满足多样化的应用需求，主要适用于以下几个关键领域：

1. 自动化测试与质量保证

在软件开发周期中，OpenClaw 能够高效执行自动化测试任务。它支持多种测试框架和协议，适用于 Web 应用、移动应用及 API 接口的测试。通过模拟用户操作和系统交互，OpenClaw 帮助团队快速识别缺陷，提升软件质量，并缩短发布周期。

2. 数据抓取与处理

对于需要从网络或本地资源中提取数据的场景，OpenClaw 提供了灵活的抓取能力。它可以处理结构化与非结构化数据，适用于市场调研、竞品分析、内容聚合等任务。结合其数据处理模块，用户能够轻松清洗、转换并存储数据，为后续分析奠定基础。

3. 系统监控与运维自动化

在 IT 运维领域，OpenClaw 可用于监控系统性能、日志分析和故障响应。通过预设脚本和规则，它能自动执行日常维护操作，如备份、部署和警报处理，从而降低人工干预成本，提高系统稳定性和运维效率。

4. 教育与研究

OpenClaw 的开源特性使其成为教育和研究的理想工具。学生和研究人员可以利用其模块化架构学习自动化技术原理，或将其应用于实验数据收集、模拟仿真等学术项目中，促进技术创新与知识共享。

5. 定制化业务集成

凭借可扩展的插件体系，OpenClaw 能够适应特定行业的业务需求。无论是金融、电商还是制造业，用户均可通过定制开发，将其集成到现有工作流中，实现业务流程的自动化优化，提升整体运营效能。

总结

OpenClaw 以其多功能、易扩展的特点，广泛适用于测试自动化、数据处理、运维监控、教育研究及业务集成等多个领域。无论是个人开发者、企业团队还是学术机构，都能从中受益，推动效率提升与数字化转型。

写之前参考了其他大佬的方法，说class要加什么@Component（“bean名称”）啥的比较麻烦，自己捋了一下，整理成文

后台手册 | RuoYi

首先是👆官方教程链接，接下来我想把自己写的实现类中的某个方法也加进去

👆一个若依代码生成的实现类

👆实现类中一个普通的方法，里面需要调用mapper查询数据库表。可以看到我没有直接用系统生成的qcNewRiverBoatmapper

若依定时任务调用有两种方式：

1. Spring Bean 方式（目标字符串不包含多个.）- 通过 SpringUtils.getBean() 获取
2. 普通类方式（目标字符串包含多个.）- 通过反射创建新实例
   当定时任务配置的目标方法使用的是类全路径名（如 com.ruoyi.system.service.impl.QcNewRiverBoatServiceImpl.updateRiverBoatListStatusOnline）时，会通过 Class.forName().newInstance() 创建新实例，导致 @Autowired 注入的 qcNewRiverBoatMapper 为 null。

需要修改 Service 实现类，使用 Spring 上下文工具类手动获取 Mapper，也就是👆第一张图的getMapper（）

有个地方需要加白名单，这里官方教程没有说，但是是要加上的，复制一下内容使用全局搜索搜出这个变量，加上实现类的路径，如下图所示：

public static final String[] JOB_WHITELIST_STR = {"com.ruoyi.quartz.task",

这里是我配置的定时任务，每天零点执行。这里把cron表达式也复制在这里

0 0 0 ?

面向对象编程（OOP）是Java的核心思想，它通过模拟现实世界中的对象来构建程序，使代码更易于理解、维护和扩展。Java的面向对象特性主要包括以下四个方面：

1. 封装（Encapsulation）

封装是将数据（属性）和操作数据的方法（行为）捆绑在一起的过程，同时对外隐藏对象的内部实现细节。通过使用private访问修饰符限制对属性的直接访问，并提供公共的getter和setter方法来控制访问和修改，封装提高了代码的安全性和可维护性。

public class Person {
    private String name; // 私有属性
    private int age;

    // 公共方法访问私有属性
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

2. 继承（Inheritance）

继承允许一个类（子类）基于另一个类（父类）来构建，从而获得父类的属性和方法。这促进了代码的重用，并建立了类之间的层次关系。Java使用extends关键字实现单继承。

// 父类
class Animal {
    void eat() {
        System.out.println("动物在吃东西");
    }
}

// 子类继承父类
class Dog extends Animal {
    void bark() {
        System.out.println("狗在叫");
    }
}

3. 多态（Polymorphism）

多态意味着“多种形态”，它允许使用统一的接口处理不同类型的对象。Java通过方法重载（编译时多态）和方法重写（运行时多态）实现多态。父类引用可以指向子类对象，调用方法时会根据实际对象类型执行相应的方法。

class Shape {
    void draw() {
        System.out.println("绘制形状");
    }
}

class Circle extends Shape {
    @Override
    void draw() {
        System.out.println("绘制圆形");
    }
}

// 多态示例
Shape shape = new Circle();
shape.draw(); // 输出：绘制圆形

4. 抽象（Abstraction）

抽象是通过抽象类和接口来隐藏复杂性的过程，只展示必要的特征。抽象类用abstract关键字声明，可以包含抽象方法和具体方法；接口用interface声明，定义了一组方法规范，由类来实现。

// 抽象类
abstract class Vehicle {
    abstract void run(); // 抽象方法
}

// 接口
interface Flyable {
    void fly();
}

class Airplane extends Vehicle implements Flyable {
    void run() {
        System.out.println("飞机在跑道上滑行");
    }

    public void fly() {
        System.out.println("飞机在空中飞行");
    }
}

总结

Java的面向对象特性使程序结构更加清晰，提高了代码的可重用性、灵活性和可扩展性。掌握封装、继承、多态和抽象是学习Java编程的基础，也是构建复杂应用程序的关键。

Servlet 是什么？

Java Servlet 是运行在 Web 服务器或应用服务器上的程序，它是作为来自 Web 浏览器或其他 HTTP 客户端的请求和 HTTP 服务器上的数据库或应用程序之间的中间层。

使用 Servlet，您可以收集来自网页表单的用户输入，呈现来自数据库或者其他源的记录，还可以动态创建网页。

Java Servlet 通常情况下与使用 CGI（Common Gateway Interface，公共网关接口）实现的程序可以达到异曲同工的效果。但是相比于 CGI，Servlet 有以下几点优势：

• 性能明显更好。
• Servlet 在 Web 服务器的地址空间内执行。这样它就没有必要再创建一个单独的进程来处理每个客户端请求。
• Servlet 是独立于平台的，因为它们是用 Java 编写的。
• 服务器上的 Java 安全管理器执行了一系列限制，以保护服务器计算机上的资源。因此，Servlet 是可信的。
• Java 类库的全部功能对 Servlet 来说都是可用的。它可以通过 sockets 和 RMI 机制与 applets、数据库或其他软件进行交互。

Servlet 架构

下图显示了 Servlet 在 Web 应用程序中的位置。

Servlet 任务

Servlet 执行以下主要任务：

• 读取客户端（浏览器）发送的显式的数据。这包括网页上的 HTML 表单，或者也可以是来自 applet 或自定义的 HTTP 客户端程序的表单。
• 读取客户端（浏览器）发送的隐式的 HTTP 请求数据。这包括 cookies、媒体类型和浏览器能理解的压缩格式等等。
• 处理数据并生成结果。这个过程可能需要访问数据库，执行 RMI 或 CORBA 调用，调用 Web 服务，或者直接计算得出对应的响应。
• 发送显式的数据（即文档）到客户端（浏览器）。该文档的格式可以是多种多样的，包括文本文件（HTML 或 XML）、二进制文件（GIF 图像）、Excel 等。
• 发送隐式的 HTTP 响应到客户端（浏览器）。这包括告诉浏览器或其他客户端被返回的文档类型（例如 HTML），设置 cookies 和缓存参数，以及其他类似的任务。

Servlet 包

Java Servlet 是运行在带有支持 Java Servlet 规范的解释器的 web 服务器上的 Java 类。

Servlet 可以使用 javax.servlet 和 javax.servlet.http 包创建，它是 Java 企业版的标准组成部分，Java 企业版是支持大型开发项目的 Java 类库的扩展版本。

这些类实现 Java Servlet 和 JSP 规范。在写本教程的时候，二者相应的版本分别是 Java Servlet 2.5 和 JSP 2.1。

Java Servlet 就像任何其他的 Java 类一样已经被创建和编译。在您安装 Servlet 包并把它们添加到您的计算机上的 Classpath 类路径中之后，您就可以通过 JDK 的 Java 编译器或任何其他编译器来编译 Servlet。

目标：删除haibo分支，切换回master分支

点击签出

签出后即可删除haibo分支

操作完成！

在 Git 中，签出分支是一个常用的操作，它允许开发者在不同的分支之间切换，从而在不同的开发线上工作。签出（checkout）一般指的是切换到某个分支，或者将文件恢复到某个特定的版本。

签出一个已存在的分支可以使用 git checkout 命令。例如，如果要切换到名为 feature 的分支，可以执行以下命令：

git checkout feature

如果要创建一个新的分支并立即切换到该分支，可以使用 -b 参数：

git checkout -b new_feature

​

/**
 * 单线程示例：所有任务按顺序执行
 */
public class SingleThreadExample {
    public static void main(String[] args) {
        // 记录程序开始时间
        long startTime = System.currentTimeMillis();

        // 任务1：模拟耗时操作（比如计算）
        System.out.println("开始执行任务1...");
        for (int i = 0; i < 1000000000; i++) {
            // 空循环模拟耗时计算
        }
        System.out.println("任务1执行完成！");

        // 任务2：模拟另一个耗时操作
        System.out.println("开始执行任务2...");
        for (int i = 0; i < 1000000000; i++) {
            // 空循环模拟耗时计算
        }
        System.out.println("任务2执行完成！");

        // 计算总耗时
        long endTime = System.currentTimeMillis();
        System.out.println("单线程总耗时：" + (endTime - startTime) + " 毫秒");
    }
}

执行结果（示例）：
plaintext
开始执行任务1...
任务1执行完成！
开始执行任务2...
任务2执行完成！
单线程总耗时：800 毫秒
核心解释：
主线程（main 线程）是唯一的执行线程，任务 1 必须完全执行完，任务 2 才会开始。
总耗时约等于任务 1 耗时 + 任务 2 耗时。
二、多线程示例
多线程程序中，多个任务可以并发（宏观上同时）执行，多个线程各自独立运行，互不阻塞。
java
运行

/**
 * 多线程示例：多个任务并发执行
 */
public class MultiThreadExample {
    // 定义一个耗时任务的线程类
    static class TaskThread extends Thread {
        private String taskName;

        public TaskThread(String taskName) {
            this.taskName = taskName;
        }

        @Override
        public void run() {
            // 线程的核心执行逻辑
            System.out.println("开始执行" + taskName + "...");
            long startTime = System.currentTimeMillis();

            // 模拟耗时操作
            for (int i = 0; i < 1000000000; i++) {
                // 空循环模拟耗时计算
            }

            long endTime = System.currentTimeMillis();
            System.out.println(taskName + "执行完成！耗时：" + (endTime - startTime) + " 毫秒");
        }
    }

    public static void main(String[] args) {
        // 记录程序开始时间
        long mainStartTime = System.currentTimeMillis();

        // 创建两个线程
        Thread thread1 = new TaskThread("任务1");
        Thread thread2 = new TaskThread("任务2");

        // 启动线程（注意：是start()不是run()，start()才会创建新线程）
        thread1.start();
        thread2.start();

        // 等待两个线程都执行完成（避免主线程先结束）
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 计算总耗时
        long mainEndTime = System.currentTimeMillis();
        System.out.println("多线程总耗时：" + (mainEndTime - mainStartTime) + " 毫秒");
    }
}

执行结果（示例）：
plaintext
开始执行任务1...
开始执行任务2...
任务2执行完成！耗时：400 毫秒
任务1执行完成！耗时：405 毫秒
多线程总耗时：410 毫秒
核心解释：
start() 方法会创建新的线程，线程的执行逻辑在 run() 方法中。
任务 1 和任务 2 会并发执行（宏观上同时跑），总耗时约等于耗时最长的那个任务的时间，而不是两者相加。
join() 方法的作用是让主线程等待子线程执行完毕，否则主线程可能会先输出 “总耗时”，导致结果不准确。
三、关键补充：线程的另一种创建方式（Runnable 接口）
除了继承 Thread 类，更推荐实现 Runnable 接口（因为 Java 单继承的限制），效果完全一样：
java
运行

/**
 * 实现Runnable接口的多线程示例（推荐方式）
 */
public class RunnableExample {
    static class Task implements Runnable {
        private String taskName;

        public Task(String taskName) {
            this.taskName = taskName;
        }

        @Override
        public void run() {
            System.out.println("开始执行" + taskName + "...");
            // 模拟耗时操作
            for (int i = 0; i < 1000000000; i++) {}
            System.out.println(taskName + "执行完成！");
        }
    }

    public static void main(String[] args) {
        // 创建Runnable任务
        Runnable task1 = new Task("任务1");
        Runnable task2 = new Task("任务2");

        // 包装成Thread并启动
        new Thread(task1).start();
        new Thread(task2).start();
    }
}

总结
单线程：代码串行执行，任务按顺序完成，总耗时 = 各任务耗时之和，适用于简单、无耗时操作的场景。
多线程：任务并发执行，总耗时≈最长任务耗时，适用于有耗时操作（如 IO、计算、网络请求）的场景，能充分利用 CPU 资源。
核心方法：启动线程用 start()（创建新线程），不要直接调用 run()（只是普通方法调用，不会创建新线程）；join() 可让主线程等待子线程完成。