从我在Java中使用线程的时间来看，我发现了两种编写线程的方法：
使用可运行的机具：
public class MyRunnable implements Runnable {
public void run() {
//Code
}
}
//Started with a "new Thread(new MyRunnable()).start()" call
或者，使用扩展线程：
public class MyThread extends Thread {
public MyThread() {
super("MyThread");
}
public void run() {
//Code
}
}
//Started with a "new MyThread().start()" call
这两个代码块有什么显著的区别吗？
当前回答
我发现使用Runnable是最有用的，因为上面提到的所有原因，但有时我喜欢扩展Thread，这样我就可以创建自己的线程停止方法，并直接在我创建的线程上调用它。
其他回答
线程保持不打算访问的行为；
它的同步锁用于连接等。它有一些你可以偶然访问的方法。
但是，如果您的子类Thread必须考虑实现更多Thread。
public class ThreadMain {
public int getId() {
return 12345678;
}
public String getName() {
return "Hello World";
}
public String getState() {
return "testing";
}
public void example() {
new Thread() {
@Override
public void run() {
System.out.println("id: "+getId()+", name: "+getName()+", state: "+getState());
}
}.start();
}
public static void main(String[] args) {
new ThreadMain().example();
}
}
如果你运行这个，你可能会期望
id: 12345678, name: Hello World, state: testing
然而，您并没有调用您认为是的方法，因为您使用的是Thread而不是ThreadMain中的方法，相反，您会看到类似
id: 11, name: Thread-0, state: RUNNABLE
在这里加上我的两分钱-始终尽可能使用机具Runnable。以下是关于为什么不应该使用扩展线程
理想情况下，您不应该扩展Thread类；线程类应为最终类。至少它的方法像thread.getId（）。有关扩展线程的错误，请参阅本讨论。那些喜欢解谜的人可以看到扩展线程的另一个副作用。以下代码将在无人通知时打印无法访问的代码。
请参见http://pastebin.com/BjKNNs2G.
public class WaitPuzzle {
public static void main(String[] args) throws InterruptedException {
DoNothing doNothing = new DoNothing();
new WaitForever(doNothing).start();
new WaitForever(doNothing).start();
new WaitForever(doNothing).start();
Thread.sleep(100);
doNothing.start();
while(true) {
Thread.sleep(10);
}
}
static class WaitForever extends Thread {
private DoNothing doNothing;
public WaitForever(DoNothing doNothing) {
this.doNothing = doNothing;
}
@Override
public void run() {
synchronized (doNothing) {
try {
doNothing.wait(); // will wait forever here as nobody notifies here
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Unreachable Code");
}
}
}
static class DoNothing extends Thread {
@Override
public void run() {
System.out.println("Do Nothing ");
}
}
}
您可以共同使用它们
例子：
public class A implements Runnable{
@Override
public void run() {
while(true){
System.out.println("Class A is running");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}}
}
}
public class Test {
public static void main(String[] args) {
Thread myThread =new Thread(new A());// 1
myThread.start();
System.out.println(" executed after thread A");//will never be reached
}
}
通过扩展线程类，派生类不能扩展任何其他基类，因为java只允许单一继承。相反，通过实现可运行接口，类仍然扩展了其他基类。
实现Runnable和扩展Thread之间最显著的区别如下：
通过扩展Thread，派生类本身就是一个线程对象，而实现Runnable接口则将同一对象共享给多个线程。
这在Oracle的“定义和启动线程”教程中进行了讨论：
你应该使用这些成语中的哪一个？第一个成语，使用Runnable对象更一般，因为Runnable对象可以子类线程以外的类。第二个成语更容易使用在简单的应用程序中，但受限于您的任务类必须是线程的后代。本课重点介绍第一节方法，它将Runnable任务与Thread对象分离执行任务的。这种方法不仅更加灵活，而且它适用于所涵盖的高级线程管理API后来
换句话说，实现Runnable将在类扩展线程以外的类的情况下工作。Java不支持多重继承。此外，在使用某些高级线程管理API时，无法扩展线程。扩展Thread的唯一方案是在一个将来不会更新的小应用程序中。实现Runnable几乎总是更好的，因为随着项目的增长，它更加灵活。设计更改不会产生重大影响，因为您可以在java中实现许多接口，但只能扩展一个类。
