Java ExtendThread vs实现runnable以模拟能力

您好，我试图了解线程，我被要求模拟to元素之间的能力，比如to对象之间的竞争，但我需要使用java线程并比较线程和可运行线程。我实施了以下措施：

public class lamborgini extends Thread {

     public void run() {
     int distance = 1000;
     int steps = 0;
     int velocity = 45;
     int acelerationTime = 800;
     while (steps < distance) {
     System.out.println("Lamborgini running");
     steps+=velocity;
     Thread.sleep(acelerationTime);
    }
    }
    }

    public class ferrari implements Runnable {
    @Override
     public void run() {
     int distance = 1000;
     int steps = 0;
     int velocity = 130;
     int acelerationTime = 950;
     while (steps < distance) {
     System.out.println("Lamborgini running");
     steps+=velocity;
     Thread.sleep(acelerationTime);
    }
    }
    }

    public class RaceMain {
     public static void main(String[] args){
     lamborgini a = new lamborgini();
     lamborgini.start();

     ferrari b = new ferrari();
     ferrari.run();
    }
    }

公共类lamborgini扩展线程{
公开募捐{
整数距离=1000；
int步数=0；
int速度=45；
int acelerationTime=800；
while（步数<距离）{
System.out.println（“兰博基尼运行”）；
步数+=速度；
线程。睡眠（acelerationTime）；
}
}
}
公共级法拉利实现可运行{
@凌驾
公开募捐{
整数距离=1000；
int步数=0；
int速度=130；
int acelerationTime=950；
while（步数<距离）{
System.out.println（“兰博基尼运行”）；
步数+=速度；
线程。睡眠（acelerationTime）；
}
}
}
公共级赛马场{
公共静态void main（字符串[]args）{
兰博基尼a=新兰博基尼（）；
lamborgini.start（）；
法拉利b=新法拉利（）；
法拉利跑（）；
}
}

但这是正确的方法吗？为什么使用run和start？我怎么知道哪一条线是第一条线呢

lamborgini a = new lamborgini();
 lamborgini.start();

在这个代码块中，您正在异步启动lamborgini内部的

run（）

方法（实际上应该以大写字母开头）。也就是说，它将与启动它的线程并行运行

 ferrari b = new ferrari();
 ferrari.run();

这不会启动新线程；它将直接跳转到

run（）

方法，并将停止所有程序执行，直到

run（）

方法完成

在这个代码块中，您正在异步启动lamborgini内部的

run（）

方法（实际上应该以大写字母开头）。也就是说，它将与启动它的线程并行运行

 ferrari b = new ferrari();
 ferrari.run();

---

这不会启动新线程；它将直接跳转到

run（）

方法，并将停止所有程序执行，直到

run（）

方法完成。

实现可运行接口是首选方法。您在这里专注于运行一些不改变线程行为的东西。

实现Runnable接口是首选方式。您在这里集中精力运行一些不改变线程行为的东西。

您使用法拉利的方式是错误的。你会的

Thread ferrariThread = new Thread(new ferrari());
ferrariThread.start();

---

两个线程都需要

start（）。扩展
线程
和实现
可运行
之间的区别是，但主要区别是
线程
内部的
这个
指的是运行中的线程，而
可运行
则不是。
您使用法拉利的方式是错误的。你会的

Thread ferrariThread = new Thread(new ferrari());
ferrariThread.start();

两个线程都需要
start（）。扩展
线程
和实现
可运行
之间的区别是，但主要区别是
线程
内的
此
指的是正在运行的线程，而对于
可运行的
则没有。
请记住，建议以大写开头命名类，不要忘记格式化代码，请使用Eclipse或Netbeans之类的IDE

如果您想知道线程何时完成运行（在本例中是您的汽车），只需在while结束后添加println，当您超出while时，这意味着您完成了所有距离

public class Lamborgini extends Thread {

    public void run() {
        int distance = 1000;
        int steps = 0;
        int velocity = 45;
        int acelerationTime = 800;
        while (steps < distance) {
            System.out.println("Lamborgini running");
            steps += velocity;
            try {
                Thread.sleep(acelerationTime);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("Lamborgini finished the race");
    }
}

public class Ferrari implements Runnable {
    @Override
    public void run() {
        int distance = 1000;
        int steps = 0;
        int velocity = 130;
        int acelerationTime = 950;
        while (steps < distance) {
            System.out.println("Ferrari running");
            steps += velocity;
            try {
                Thread.sleep(acelerationTime);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
        System.out.println("Ferrari finished the race");
    }
}

public static class RaceMain {
    public static void main(String[] args) {
        Lamborgini lamborgini = new Lamborgini();
        lamborgini.start();

        Thread ferrari = new Thread(new Ferrari());
        ferrari.start();
    }
}

公共类Lamborgini扩展线程{
公开募捐{
整数距离=1000；
int步数=0；
int速度=45；
int acelerationTime=800；
while（步数<距离）{
System.out.println（“兰博基尼运行”）；
步数+=速度；
试一试{
线程。睡眠（acelerationTime）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
}
System.out.println（“兰博基尼完成了比赛”）；
}
}
公共级法拉利实现可运行{
@凌驾
公开募捐{
整数距离=1000；
int步数=0；
int速度=130；
int acelerationTime=950；
while（步数<距离）{
System.out.println（“法拉利跑”）；
步数+=速度；
试一试{
线程。睡眠（acelerationTime）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
}
System.out.println（“法拉利完成了比赛”）；
}
}
公共静态类RaceMain{
公共静态void main（字符串[]args）{
Lamborgini Lamborgini=新的Lamborgini（）；
lamborgini.start（）；
螺纹法拉利=新螺纹（新法拉利（））；
法拉利。开始（）；
}
}

如果你想启动你的法拉利，正确的方法是创建一个新的线程，并将你的法拉利设置为一个参数，它不是线程，因为它是可运行的
 请记住，建议以大写开头命名类，不要忘记格式化代码，请使用Eclipse或Netbeans之类的IDE

如果您想知道线程何时完成运行（在本例中是您的汽车），只需在while结束后添加println，当您超出while时，这意味着您完成了所有距离

public class Lamborgini extends Thread {

    public void run() {
        int distance = 1000;
        int steps = 0;
        int velocity = 45;
        int acelerationTime = 800;
        while (steps < distance) {
            System.out.println("Lamborgini running");
            steps += velocity;
            try {
                Thread.sleep(acelerationTime);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("Lamborgini finished the race");
    }
}

public class Ferrari implements Runnable {
    @Override
    public void run() {
        int distance = 1000;
        int steps = 0;
        int velocity = 130;
        int acelerationTime = 950;
        while (steps < distance) {
            System.out.println("Ferrari running");
            steps += velocity;
            try {
                Thread.sleep(acelerationTime);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
        System.out.println("Ferrari finished the race");
    }
}

public static class RaceMain {
    public static void main(String[] args) {
        Lamborgini lamborgini = new Lamborgini();
        lamborgini.start();

        Thread ferrari = new Thread(new Ferrari());
        ferrari.start();
    }
}

公共类Lamborgini扩展线程{
公开募捐{
整数距离=1000；
int步数=0；
int速度=45；
int acelerationTime=800；
while（步数<距离）{
System.out.println（“兰博基尼运行”）；
步数+=速度；
试一试{
线程。睡眠（acelerationTime）；
}捕捉（中断异常e）{