编辑“︁Java线程创建”︁

{{DISPLAYTITLE:Java线程创建}}

'''Java线程创建'''是Java多线程编程的基础，它允许程序同时执行多个任务。在Java中，线程可以通过两种主要方式创建：继承{{code|Thread}}类或实现{{code|Runnable}}接口。本文将详细介绍这两种方法，并提供代码示例、实际应用场景和比较分析。

== 线程简介 ==
线程是程序执行的最小单元，是进程中的一个独立执行路径。Java通过{{code|java.lang.Thread}}类提供对线程的支持。多线程可以提高程序的并发性和性能，特别是在处理I/O密集型或CPU密集型任务时。

== 线程创建方法 ==

=== 方法1：继承Thread类 ===
通过继承{{code|Thread}}类并重写其{{code|run()}}方法可以创建线程。以下是基本步骤：

1. 创建一个继承自{{code|Thread}}的子类。
2. 重写{{code|run()}}方法，定义线程执行的任务。
3. 创建子类实例并调用{{code|start()}}方法启动线程。

==== 代码示例 ====
<syntaxhighlight lang="java">
public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("线程正在运行: " + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start(); // 启动线程
    }
}
</syntaxhighlight>

==== 输出 ====
<pre>
线程正在运行: Thread-0
</pre>

==== 解释 ====
* {{code|run()}}方法包含线程执行的代码。
* {{code|start()}}方法启动线程，JVM会自动调用{{code|run()}}方法。
* {{code|Thread.currentThread().getName()}}获取当前线程的名称。

=== 方法2：实现Runnable接口 ===
实现{{code|Runnable}}接口是更灵活的线程创建方式，因为Java不支持多重继承。步骤如下：

1. 创建一个实现{{code|Runnable}}接口的类。
2. 实现{{code|run()}}方法。
3. 创建{{code|Thread}}实例并传入{{code|Runnable}}对象。
4. 调用{{code|start()}}方法启动线程。

==== 代码示例 ====
<syntaxhighlight lang="java">
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("线程正在运行: " + Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunnable());
        thread.start();
    }
}
</syntaxhighlight>

==== 输出 ====
<pre>
线程正在运行: Thread-0
</pre>

==== 解释 ====
* {{code|Runnable}}接口只有一个抽象方法{{code|run()}}。
* 通过将{{code|Runnable}}实例传递给{{code|Thread}}构造函数来创建线程。

== 方法比较 ==
{| class="wikitable"
|+ 继承Thread vs. 实现Runnable
|-
! 特性 !! 继承Thread !! 实现Runnable
|-
| 继承限制 || 占用继承名额 || 不占用继承名额
|-
| 代码复用 || 较低 || 较高
|-
| 共享资源 || 较难 || 较易
|}

== 实际应用场景 ==
=== 场景1：多任务处理 ===
在服务器程序中，可以为每个客户端请求创建一个线程，提高并发处理能力。

<syntaxhighlight lang="java">
public class Server {
    public static void main(String[] args) {
        while (true) {
            Runnable task = new ClientHandler();
            new Thread(task).start();
        }
    }
}

class ClientHandler implements Runnable {
    @Override
    public void run() {
        // 处理客户端请求
    }
}
</syntaxhighlight>

=== 场景2：并行计算 ===
将大任务分解为多个子任务并行执行，如矩阵乘法。

<syntaxhighlight lang="java">
public class MatrixMultiplier {
    public static void main(String[] args) {
        int[][] matrixA = {{1, 2}, {3, 4}};
        int[][] matrixB = {{5, 6}, {7, 8}};
        int[][] result = new int[2][2];

        Thread[] threads = new Thread[4];
        for (int i = 0; i < 2; i++) {
            for (int j = 0; j < 2; j++) {
                final int row = i, col = j;
                threads[i*2+j] = new Thread(() -> {
                    for (int k = 0; k < 2; k++) {
                        result[row][col] += matrixA[row][k] * matrixB[k][col];
                    }
                });
                threads[i*2+j].start();
            }
        }

        // 等待所有线程完成
        for (Thread t : threads) {
            try { t.join(); } catch (InterruptedException e) {}
        }

        System.out.println(Arrays.deepToString(result));
    }
}
</syntaxhighlight>

== 线程生命周期 ==
线程有以下状态：
<mermaid>
stateDiagram
    [*] --> New
    New --> Runnable: start()
    Runnable --> Running: 被调度
    Running --> Terminated: 执行完成
    Running --> Blocked: 等待资源
    Blocked --> Runnable: 资源可用
    Running --> Waiting: wait()/join()
    Waiting --> Runnable: notify()/notifyAll()
</mermaid>

== 高级主题 ==
=== 使用Lambda表达式 ===
Java 8+可以使用Lambda简化{{code|Runnable}}实现：
<syntaxhighlight lang="java">
new Thread(() -> System.out.println("Lambda线程")).start();
</syntaxhighlight>

=== 线程优先级 ===
线程优先级用1-10表示，可通过{{code|setPriority()}}设置：
<syntaxhighlight lang="java">
thread.setPriority(Thread.MAX_PRIORITY); // 10
</syntaxhighlight>

== 常见问题 ==
=== Q1: 直接调用run()方法会怎样？ ===
直接调用{{code|run()}}不会创建新线程，代码会在当前线程执行。

=== Q2: 线程可以多次start吗？ ===
不可以，抛出{{code|IllegalThreadStateException}}。

== 总结 ==
Java线程创建有两种主要方式：
1. 继承{{code|Thread}}类 - 简单但灵活性低
2. 实现{{code|Runnable}}接口 - 推荐方式，灵活性高

实际开发中通常使用{{code|Runnable}}或Lambda表达式，特别是在需要共享资源或避免继承限制时。理解线程创建是掌握Java并发编程的第一步。

[[Category:编程语言]]
[[Category:Java]]
[[Category:Java多线程]]