继承Thread类，使用这个继承的类，传入runnable开启线程的代码实现

可以使用以下代码实现：

public class MyThread extends Thread {
    private Runnable runnable;

    public MyThread(Runnable runnable) {
        this.runnable = runnable;
    }

    @Override
    public void run() {
        if (runnable != null) {
            runnable.run();
        }
    }
}

使用时，可以传入一个实现了Runnable接口的类的实例，例如：

MyThread myThread = new MyThread(new Runnable() {
    @Override
    public void run() {
        // 线程要执行的代码
    }
});
myThread.start();

这样就可以开启一个新的线程，并执行传入的Runnable实例中的代码。

相关问题

使用继承Thread类和实现Runnable接口两种方式实现多线程。要求： （1）定义一个名为“CopyFile”的类，该类继承Thread类，并重写Thread类的run()方法，其功能是使用字节缓冲输入输出流复制文件。 （2）使用CopyFile类产生4个线程对象，并启动这4个线程对象，即同时复制4个文件。

下面是使用继承Thread类的方式实现多线程的示例代码：

import java.io.*;

public class CopyFile extends Thread {
    private String sourceFile;
    private String destinationFile;

    public CopyFile(String sourceFile, String destinationFile) {
        this.sourceFile = sourceFile;
        this.destinationFile = destinationFile;
    }

    public void run() {
        try (BufferedInputStream in = new BufferedInputStream(new FileInputStream(sourceFile));
             BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(destinationFile))) {
            byte[] buffer = new byte[1024];
            int length;
            while ((length = in.read(buffer)) > 0) {
                out.write(buffer, 0, length);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        String[] sourceFiles = {"file1.txt", "file2.txt", "file3.txt", "file4.txt"};
        String[] destinationFiles = {"file1_copy.txt", "file2_copy.txt", "file3_copy.txt", "file4_copy.txt"};
        CopyFile[] threads = new CopyFile[4];
        for (int i = 0; i < 4; i++) {
            threads[i] = new CopyFile(sourceFiles[i], destinationFiles[i]);
            threads[i].start();
        }
        for (int i = 0; i < 4; i++) {
            try {
                threads[i].join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("All files have been copied.");
    }
}

上面的代码中，我们定义了一个名为CopyFile的类，它继承自Thread类，并重写了Thread类的run()方法。在run()方法中，我们使用字节缓冲输入输出流来复制文件。

在main()方法中，我们创建了4个CopyFile对象，并启动这4个线程。在启动线程之后，我们使用join()方法来等待这4个线程都执行完毕，然后输出一条消息表示所有文件都已经被复制。

需要注意的是，由于我们在CopyFile类的构造函数中传入了源文件名和目标文件名，因此每个线程会复制不同的文件。如果要复制相同的文件，可以在main()方法中传入相同的文件名。

练习: ​ 抢火车票； ​ 成都 -> 宜宾 有1000张票，有4个窗口同时卖票 ， 同步方法 ，同步代码块，线程的常用方法， 继承Thread类，实现Runnable接口，使用多线程相关知识写出代码，不要写太复杂，并且每一行带有注释

// 定义一个火车票类
class TrainTicket {
// 票数
private int ticketNum = 1000;

// 同步方法，保证线程安全
public synchronized boolean sellTicket() {
// 如果还有票，售票员卖出一张票
if (ticketNum > 0) {
ticketNum--;
System.out.println(Thread.currentThread().getName() + "售出一张票，剩余：" + ticketNum + "张");
return true;
}
// 如果没有票了，返回false
else {
return false;
}
}
}

// 定义售票员类
class Seller extends Thread {
// 声明火车票对象
private TrainTicket trainTicket;

// 构造方法，传入火车票对象
public Seller(TrainTicket trainTicket) {
this.trainTicket = trainTicket;
}

// 重写run方法
@Override
public void run() {
// 循环卖票，直到所有票都卖完
while (trainTicket.sellTicket()) {
// 模拟售票员卖票的过程
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

// 定义主类
public class TrainTicketDemo {
public static void main(String[] args) {
// 创建火车票对象
TrainTicket trainTicket = new TrainTicket();

// 创建4个售票员对象
Seller s1 = new Seller(trainTicket);
Seller s2 = new Seller(trainTicket);
Seller s3 = new Seller(trainTicket);
Seller s4 = new Seller(trainTicket);

// 启动线程，开始售票
s1.start();
s2.start();
s3.start();
s4.start();
}
}