当前位置：文江博客话题详情

当子类从线程父类扩展时，我们是否重写 run 方法

发布于 2024-10-02 09:33:21 字数 289 浏览 0 评论 0原文

当我们子类化Thread时，我们是否重写它的run方法？我们知道Thread类本身实现了Runnable，但是Runnable类中没有定义run方法的主体。

这是我脑海中的画面：

Runnable - 父类 - 它有一个 run 方法，主体为空。

Thread- Child，

classA 扩展了 Thread- Child of Child，

当我们在“classA”中定义 run() 方法时，我们是否覆盖了 Runnable 类中声明的 run 方法？感谢您抽出时间。

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

泪之魂 2024-10-09 09:33:21

有两种方法可以定义线程的行为：子类化 Thread 类，或者实现 Runnable 接口。

对于第一种方法，只需扩展 Thread 类并使用您自己的实现覆盖 run() 方法：

public class HelloThread extends Thread {
    @Override
    public void run() {
        System.out.println("Hello from a thread!");
    }
}

public class Main { 
    // main method just starts the thread 
    public static void main(String args[]) {
        (new HelloThread()).start();
    }
}

但是，实现 Thread 逻辑的首选方法是创建一个实现 Runnable 接口的类：

public class HelloRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Hello from a thread!");
    }
}

public class Main {
    // notice that we create a new Thread and pass it our custom Runnable
    public static void main(String args[]) {
        (new Thread(new HelloRunnable())).start();
    }
}

实现 Runnable 的原因首选的是它在线程的行为和线程本身之间提供了清晰的分离。例如，当使用线程池时，您实际上从未从头开始创建线程，您只需将 Runnable 传递给框架，它就会在可用线程上为您执行它：

public class Main {
    public static void main(String args[]) {
        int poolSize = 5;
        ExecutorService pool = Executors.newFixedThreadPool(poolSize);
        pool.execute(new HelloRunnable());
    }
 }

进一步阅读：

线程基础知识：http://download.oracle.com/javase/tutorial/essential/concurrency/runthread.html< /a>
执行器： http:// download.oracle.com/javase/1.5.0/docs/api/java/util/concurrent/ExecutorService.html
接口基础知识：http://download.oracle.com/javase/tutorial/java/concepts/interface.html

There are two ways to define the behavior of a thread: subclass the Thread class, or implement the Runnable interface.

For the first way, simply extend the Thread class and override the run() method with your own implementation:

public class HelloThread extends Thread {
    @Override
    public void run() {
        System.out.println("Hello from a thread!");
    }
}

public class Main { 
    // main method just starts the thread 
    public static void main(String args[]) {
        (new HelloThread()).start();
    }
}

However, the preferred way of implementing the logic for a Thread is by creating a class that implements the Runnable interface:

public class HelloRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Hello from a thread!");
    }
}

public class Main {
    // notice that we create a new Thread and pass it our custom Runnable
    public static void main(String args[]) {
        (new Thread(new HelloRunnable())).start();
    }
}

The reason that implementing Runnable is preferred is that it provides a clear separation between the behavior of the thread and the thread itself. For instance, when using a thread-pool you never actually create the thread from scratch, you just pass a Runnable to the framework and it'll execute it on an available thread for you:

public class Main {
    public static void main(String args[]) {
        int poolSize = 5;
        ExecutorService pool = Executors.newFixedThreadPool(poolSize);
        pool.execute(new HelloRunnable());
    }
 }