0

你好，我试图了解线程，我被要求模拟元素之间的能力，比如对象之间的竞争，但我需要使用 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();
    }
    }

但这是正确的方法吗？为什么使用运行，为什么使用启动？我怎么知道哪个线程先出现？

4

7 回答 7

3

你用ferrari错了方法。你会做

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

两个线程都需要start()编辑。在您当前的使用中，run()实际上并没有在不同的线程中运行。Thread扩展和实现Runnable之间的区别主要是用例的问题，但主要区别在于，this在里面Thread指的是正在运行的线程，而对于Runnable它没有。

于 2013-03-06T19:12:38.097 回答
1

请记住，建议以大写开头的类命名，并且不要忘记格式化您的代码，请使用 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();
    }
}

如果你想启动你的法拉利，正确的方法是创建一个新线程并将你的法拉利设置为参数，这不是线程，因为它是可运行的。

于 2013-03-06T19:13:48.813 回答
0 
lamborgini a = new lamborgini();
 lamborgini.start();

在此代码块中，您将run()异步启动 Lamborgini 内部的方法（实际上应该以大写字母开头）。也就是说，它将与启动它的线程并行运行。

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

这不会启动一个新线程；它将简单地跳转到该run()方法并停止所有程序执行，直到该run()方法完成。

于 2013-03-06T19:11:59.097 回答
0

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

于 2013-03-06T19:12:36.543 回答
0

首先，请为您的课程使用类名约定（类名以大写字母开头）

回答你的问题。当您扩展Thread时，您只需调用start()对象上的方法，因为该对象继承自 的方法Thread，因此该对象本身就是一个线程。

当您使用Runnable时，您不会run()在实现它的对象上调用该方法。相反，您应该做的是将实现的对象传递Runnable给新Thread对象。例如：

ferrari b = new ferrari();
Thread t = new Thread(b);
t.start();

这样，run()来自实现的对象的方法Runnable将执行。

于 2013-03-06T19:14:59.863 回答
0

以下是关于类 Thread 和接口 Runnable 的一些想法：

1）在Java中，一个类不能继承一个类，这意味着您只能扩展一个类。因此，随着您扩展 Thread 类，您将不再有继承。

2) 如果您不向 Thread 添加新功能，请使用 Runnable。

3) Runnable 代表一个任务，可以由 Thread 或 Executors 执行。

4) 完成runnable 可重用后，线程无法重新启动。

6）如果只需要实现Run，就不需要从线程继承所有。

7）扩展线程您将拥有一个与单个对象关联的唯一对象，同时实现 Runnable 它将共享同一个对象给多个线程。

您的线程按照您设置的顺序启动，但无法知道操作系统何时在两个线程之间切换。

于 2013-03-06T19:42:05.963 回答
0

来自 Vmoksha 的 Sunilkumar

如果你使用线程，我们必须只扩展一个类，我们无法获得其他内置类的特性，所以我们尽量避免使用线程类，我们使用可运行接口，如果你使用接口，我们也可以轻松实现其他类

于 2013-03-07T11:54:14.433 回答