Java多线程——2.创建新线程

目录

• Java多线程
  • 线程的基本概念
  • 创建新线程的两种方式
    • 方式一：继承Thread类并覆写run()方法
    • 方式二：实现Runnable接口并覆写run()方法
    • 两种方式的对比
  • 线程的启动与执行
  • 线程调度与优先级
    • 线程优先级
    • 线程休眠
  • 线程的生命周期
  • 总结

---

Java多线程

线程的基本概念

当一个Java程序启动时，实际上是启动了一个JVM进程，JVM会创建一个主线程来执行main()方法。除此之外，我们还可以创建多个额外的线程，这些线程可以并发执行不同的任务，从而充分利用多核CPU的计算能力。

• 进程：一个正在运行的程序，拥有独立的内存空间和系统资源
• 线程：进程内部的执行单元，共享进程的资源，拥有独立的执行路径
• 多线程：一个进程中同时运行多个线程，实现并发执行

创建新线程的两种方式

Java提供了两种主要方式来创建新线程，各有其适用场景和特点。

方式一：继承Thread类并覆写run()方法

Thread类是Java中线程操作的核心类，通过继承该类并覆写其run()方法，可以定义线程要执行的任务：

// 自定义线程类
class MyThread extends Thread {
    @Override
    public void run() {
        // 线程要执行的任务代码
        System.out.println("新线程执行中...");
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程: " + i);
            try {
                // 让线程暂停500毫秒
                Thread.sleep(500);
            } catch (InterruptedException e) {
                // 处理中断异常
                e.printStackTrace();
            }
        }
        System.out.println("新线程执行完毕");
    }
}

// 测试类
public class ThreadExample {
    public static void main(String[] args) {
        System.out.println("主线程启动");

        // 创建线程实例
        MyThread thread = new MyThread();
        // 启动线程
        thread.start();

        System.out.println("主线程继续执行");
        for (int i = 0; i < 3; i++) {
            System.out.println("主线程: " + i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("主线程执行完毕");
    }
}

执行流程解析：

1. 主线程创建MyThread实例
2. 调用start()方法启动新线程，JVM会创建一个新的执行线程
3. 新线程执行run()方法中的代码
4. 主线程和新线程并发执行

方式二：实现Runnable接口并覆写run()方法

Runnable接口定义了一个单一的run()方法，通过实现该接口并将实例传递给Thread类，可以更灵活地创建线程：

// 实现Runnable接口
class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 线程要执行的任务代码
        System.out.println("新线程执行中...");
        // 任务逻辑...
    }
}

// 测试类
public class RunnableExample {
    public static void main(String[] args) {
        System.out.println("主线程启动");

        // 创建Runnable实例
        MyRunnable runnable = new MyRunnable();
        // 将Runnable实例传递给Thread
        Thread thread = new Thread(runnable);
        // 启动线程
        thread.start();

        System.out.println("主线程继续执行");
        // 主线程逻辑...
    }
}

使用Lambda表达式简化（Java 8+）：

public class LambdaThreadExample {
    public static void main(String[] args) {
        System.out.println("主线程启动");

        // 使用Lambda表达式创建线程
        Thread thread = new Thread(() -> {
            System.out.println("新线程执行中...");
            // 任务逻辑...
        });
        thread.start();

        System.out.println("主线程继续执行");
        // 主线程逻辑...
    }
}

两种方式的对比

方式	优点	缺点	适用场景
继承Thread	代码简单，直接使用this指代当前线程	无法继承其他类（Java单继承）	简单的线程任务
实现Runnable	可继承其他类，适合多个线程共享资源	代码稍复杂，需通过Thread.currentThread()获取当前线程	复杂任务，资源共享场景

推荐实践：优先使用实现Runnable接口的方式，因为它更灵活，也符合面向接口编程的思想。

线程的启动与执行

创建线程实例后，必须调用start()方法才能真正启动一个新线程。需要特别注意的是，直接调用run()方法并不会创建新线程，而只是在当前线程中执行run()方法中的代码：

public class ThreadStartExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("线程执行中，当前线程名: " + Thread.currentThread().getName());
        });

        // 正确启动新线程
        thread.start();  // 输出: 线程执行中，当前线程名: Thread-0

        // 错误方式，不会创建新线程
        thread.run();    // 输出: 线程执行中，当前线程名: main
    }
}

start()方法的工作原理：

1. 向JVM请求创建一个新线程
2. JVM分配线程所需的资源
3. 新线程开始执行run()方法中的代码
4. start()方法立即返回，不等待run()方法执行完毕

一个线程对象只能调用一次start()方法，多次调用会抛出IllegalThreadStateException异常。

线程调度与优先级

线程的调度由操作系统和JVM共同负责，程序员无法精确控制线程的执行顺序，但可以通过设置线程优先级来影响调度器的决策。

线程优先级

Java中线程优先级分为1到10共10个级别，默认优先级为5：

public class ThreadPriorityExample {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                System.out.println("线程1: " + i);
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                System.out.println("线程2: " + i);
            }
        });

        // 设置优先级
        t1.setPriority(Thread.MIN_PRIORITY);  // 优先级1
        t2.setPriority(Thread.MAX_PRIORITY);  // 优先级10

        t1.start();
        t2.start();
    }
}

注意事项：

• 优先级高的线程获得的CPU时间片通常更多，但不保证一定先执行
• 不同操作系统对优先级的支持不同，不能过度依赖优先级来控制执行顺序
• 优先级设置应合理，避免设置过多不同优先级的线程

线程休眠

使用Thread.sleep(long millis)方法可以让当前线程暂停执行指定的毫秒数：

public class ThreadSleepExample {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            try {
                System.out.println("线程开始执行");
                Thread.sleep(2000);  // 休眠2秒
                System.out.println("线程休眠结束");
            } catch (InterruptedException e) {
                System.out.println("线程被中断");
                return;
            }
            System.out.println("线程执行完毕");
        });

        thread.start();
    }
}

sleep()方法会抛出InterruptedException，当线程在休眠期间被中断时会触发该异常。

线程的生命周期

一个线程从创建到结束，会经历以下状态：

1. 新建状态（New）：线程对象创建但未调用start()方法
2. 就绪状态（Runnable）：调用start()方法后，等待CPU调度
3. 运行状态（Running）：获得CPU时间片，执行run()方法
4. 阻塞状态（Blocked）：因某种原因暂停执行（如等待锁、I/O操作）
5. 死亡状态（Terminated）：run()方法执行完毕或因异常终止

理解线程的生命周期有助于更好地调试多线程程序，避免出现线程泄漏或死锁等问题。

总结

• 创建线程有两种方式：继承Thread类或实现Runnable接口
• 必须调用start()方法才能启动新线程，直接调用run()方法无效
• 线程调度由操作系统控制，优先级可以影响但不能决定执行顺序
• Thread.sleep()方法可以暂停线程执行，让出CPU时间片
• 一个线程对象只能启动一次，多次启动会抛出异常
• 理解线程的生命周期