public class ThreadDemo1 { public static void main(String[] args) { Thread t1 = new MyThread1(); Thread t2 = new MyThread2(); t1.start(); t2.start(); } } class MyThread1 extends Thread{//1继承Thread public void run(){//重写run方法 for(int i=0;i<1000;i++){ System.out.println("你是谁啊?"); } } } class MyThread2 extends Thread{ public void run(){ for(int i=0;i<1000;i++){ System.out.println("开门!查水表的!"); } } }

这是一个Java多线程的示例代码，创建了两个线程，分别输出不同的信息。MyThread1和MyThread2都继承了Thread类，并重写了run()方法，run()方法是线程的执行体，当线程启动后会自动调用run()方法。在main()方法中，分别创建了MyThread1和MyThread2的实例，并调用start()方法启动线程。start()方法会使线程进入就绪状态，并自动调用run()方法开始执行线程。由于是多线程执行，因此输出的信息会交替出现。

相关问题

1.将下图代码保存到该ThreadDemo.java中。查阅API文档等，为代码添加注释。 功能：分别以两种方式创建线程对象 class MyThread extends Thread { public void run() { // System.out.println("线程1运行了。"); } } class MyRunnable implements Runnable {// public void run() { System.out.println("线程2运行了。"); } } public class ThreadDemo { // public static void main(String[] args) { Thread t1 = new MyThread(); // Runnable target = new MyRunnable(); // Thread t2 = new Thread(target); // // 创建线程对象t3(本质上仍是方式2，但使用了Lambda表达式以简化代码) Thread t3 = new Thread(() -> System.out.println("线程3运行了。")); t1.start(); // t2.start(); // t3.start(); // } }

// 定义一个继承自Thread类的线程
class MyThread extends Thread {
    // 重写Thread类的run方法
    public void run() {
        // 打印信息
        // System.out.println("线程1运行了。");
    }
}

// 定义一个实现了Runnable接口的线程
class MyRunnable implements Runnable {
    // 实现Runnable接口的run方法
    public void run() {
        // 打印信息
        System.out.println("线程2运行了。");
    }
}

// 主类
public class ThreadDemo {
    public static void main(String[] args) {
        // 创建线程对象t1，该线程是继承自Thread类的线程
        Thread t1 = new MyThread();
        // 创建线程对象t2，该线程是实现了Runnable接口的线程
        Runnable target = new MyRunnable();
        Thread t2 = new Thread(target);
        
        // 创建线程对象t3，使用Lambda表达式简化代码
        Thread t3 = new Thread(() -> System.out.println("线程3运行了。"));
        
        // 开始运行线程
        t1.start();
        t2.start();
        t3.start();
    }
}

注释已经添加在代码中了。

3.实现Runnable接口创建线程。程序填空：利用Runnable接口创建线程。 class RunnableClass{ public static void main(String[] args) { MyThread m1=new MyThread("thread1"); MyThread m2=new MyThread("thread2"); 【1】创建Thread对象t1，以m1作为参数绑定 写出代码： Thread t2=new Thread(m2); //m2为第5行的m2 【2】启动线程t1 写出代码： t2.start(); System.out.println("主方法main运行结束"); } } public class MyThread implements Runnable { String name; public MyThread(String str) { 【3】把参数str赋值给成员变量name 写出代码： } public void run(){ //实现接口中的run()方法 for(int i=0;i<3;i++) { System.out.println(name+"在运行"); try { 【4】当前运行线程休眠1000ms 写出代码： } catch(InterruptedException e) {} } System.out.println(name+"已结束"); } }

以下是完整的程序代码：

class RunnableClass {
    public static void main(String[] args) {
        MyThread m1 = new MyThread("thread1");
        MyThread m2 = new MyThread("thread2");
        Thread t1 = new Thread(m1); // 创建Thread对象t1，以m1作为参数绑定
        Thread t2 = new Thread(m2); // m2为第5行的m2
        t1.start(); // 启动线程t1
        t2.start();
        System.out.println("主方法main运行结束");
    }
}

public class MyThread implements Runnable {
    String name;

    public MyThread(String str) {
        name = str; // 把参数str赋值给成员变量name
    }

    public void run() { // 实现接口中的run()方法
        for (int i = 0; i < 3; i++) {
            System.out.println(name + "在运行");
            try {
                Thread.sleep(1000); // 当前运行线程休眠1000ms
            } catch (InterruptedException e) {
            }
        }
        System.out.println(name + "已结束");
    }
}

解释：

1. 在 `main` 方法中，首先创建两个 `MyThread` 类的对象 `m1`、`m2`。

2. 然后，用这两个对象分别创建 2 个线程对象 `t1`、`t2`。

3. 接着，启动线程 `t1` 和 `t2`，它们分别执行 `MyThread` 类中的 `run` 方法。

4. 在 `MyThread` 类的 `run` 方法中，每个线程都会输出它的名字，并且每隔 1 秒钟休眠一次，共输出 3 次，最后输出结束信息。

5. 最后，在 `main` 方法中输出主方法运行结束信息。