Thread t1 = new Thread(mr) 原理

核心原理

1. Thread构造方法的重载

Thread类有多个构造方法，其中一个是：

java 复制代码

public Thread(Runnable target) {
    // 将Runnable对象保存到Thread的target字段
    this.target = target;
}

2. Thread的run方法实现

Thread类的run方法是这样实现的：

java 复制代码

@Override
public void run() {
    if (target != null) {
        target.run();  // 调用传入的Runnable对象的run方法
    }
}

详细执行流程

步骤1：创建Runnable对象

java 复制代码

Myrun mr = new Myrun();

创建了一个实现了Runnable接口的对象

这个对象有run方法的具体实现

步骤2：创建Thread对象

java 复制代码

Thread t1 = new Thread(mr);

调用Thread(Runnable target)构造方法

将mr对象保存到Thread的target字段中

步骤3：启动线程

java 复制代码

t1.start();

启动线程t1

线程开始执行run方法

步骤4：执行run方法

java 复制代码

// Thread的run方法内部
if (target != null) {
    target.run();  // 调用mr.run()
}

代码结构分析

Thread类的内部结构

java 复制代码

public class Thread implements Runnable {
    private Runnable target;  // 保存Runnable对象的字段
    
    // 构造方法
    public Thread(Runnable target) {
        this.target = target;
    }
    
    // run方法
    @Override
    public void run() {
        if (target != null) {
            target.run();  // 调用传入对象的run方法
        }
    }
}

实际执行示例

完整流程演示

java 复制代码

public class ThreadDemo {
    public static void main(String[] args) {
        // 1. 创建任务对象
        Myrun mr = new Myrun();
        
        // 2. 创建线程对象，传入任务
        Thread t1 = new Thread(mr);
        Thread t2 = new Thread(mr);
        
        // 3. 启动线程
        t1.start();
        t2.start();
    }
}

class Myrun implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + " 执行第" + i + "次");
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

执行结果

java 复制代码

Thread-0 执行第0次
Thread-1 执行第0次
Thread-0 执行第1次
Thread-1 执行第1次
...

总结

Thread t1 = new Thread(mr) 的原理是：

构造方法：Thread(Runnable target)将mr保存到target字段

run方法：Thread的run方法调用target.run()

任务执行：实际执行的是mr.run()方法

设计模式：使用组合模式，Thread管理线程，Runnable定义任务

这种设计让线程管理和任务逻辑分离，提高了代码的灵活性和可维护性！