从我在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是实现该接口的类。从设计的角度来看，任务的定义方式和执行方式之间应该有明确的区分。前者由Runnalbe实现负责，后者由Thread类负责。在大多数情况下，实现Runnable是正确的做法。
其他回答
将Thread类与Runnable实现分离还可以避免线程和run（）方法之间的潜在同步问题。单独的Runnable通常在引用和执行可运行代码的方式上提供更大的灵活性。
线程和可运行线程之间的差异。若我们使用线程类创建线程，则线程数等于我们创建的对象数。如果我们通过实现可运行接口来创建线程，那么我们可以使用单个对象来创建多个线程。因此，单个对象由多个线程共享。因此，它将占用更少的内存
因此，如果我们的数据不敏感，则取决于要求。所以它可以在多个线程之间共享，我们可以使用Runnable接口。
这里的每个人似乎都认为实现Runnable是一条路，我并不真的不同意他们的观点，但在我看来，扩展Thread也是有道理的，事实上，您已经在代码中演示了这一点。
如果您实现Runnable，那么实现Runnable的类对线程名称没有控制权，调用代码可以设置线程名称，如下所示：
new Thread(myRunnable,"WhateverNameiFeelLike");
但是如果您扩展了Thread，那么您可以在类本身中管理它（就像在您的示例中，您将线程命名为“ThreadB”）。在这种情况下，您：
A） 可能会为调试目的提供一个更有用的名称
B） 强制将该名称用于该类的所有实例（除非您忽略了它是一个线程的事实，并将其作为Runnable来执行上述操作，但我们在这里讨论的是约定，所以可以忽略我认为的可能性）。
例如，您甚至可以对其创建进行堆栈跟踪，并将其用作线程名称。这可能看起来很奇怪，但取决于代码的结构，它对调试非常有用。
这看起来可能是一件小事，但如果你有一个非常复杂的应用程序，其中有很多线程，并且突然“停止”了（可能是因为死锁，也可能是因为网络协议中的一个不太明显的缺陷，或者其他无休止的原因），然后从Java获取堆栈转储，其中所有线程都被称为“线程-1”、“线程-2”、，“Thread-3”并不总是非常有用（这取决于线程的结构，以及您是否可以仅通过它们的堆栈跟踪来有效地区分哪个线程是哪个线程-如果您使用的是多个线程组，它们都运行相同的代码，则不总是可能的）。
尽管如此，您当然也可以通过创建线程类的扩展来以通用的方式执行上述操作，该扩展将其名称设置为其创建调用的堆栈跟踪，然后将其用于Runnable实现而不是标准的java线程类（见下文），但是除了堆栈跟踪之外用于调试的线程名称（对它可能处理的许多队列或套接字之一的引用，例如，在这种情况下，您可能更希望专门针对这种情况扩展thread，以便编译器强制您（或其他使用库的人）传递某些信息（例如，有问题的队列/套接字）以用于名称）。
以下是以调用堆栈跟踪为名称的通用线程的示例：
public class DebuggableThread extends Thread {
private static String getStackTrace(String name) {
Throwable t= new Throwable("DebuggableThread-"+name);
ByteArrayOutputStream os = new ByteArrayOutputStream();
PrintStream ps = new PrintStream(os);
t.printStackTrace(ps);
return os.toString();
}
public DebuggableThread(String name) {
super(getStackTrace(name));
}
public static void main(String[] args) throws Exception {
System.out.println(new Thread());
System.out.println(new DebuggableThread("MainTest"));
}
}
下面是比较两个名称的输出示例：
Thread[Thread-1,5,main]
Thread[java.lang.Throwable: DebuggableThread-MainTest
at DebuggableThread.getStackTrace(DebuggableThread.java:6)
at DebuggableThread.<init>(DebuggableThread.java:14)
at DebuggableThread.main(DebuggableThread.java:19)
,5,main]
1.扩展线程接口，就像让类只作为线程一样。您的新类将像一个增强的线程。
jshell> public class Test extends Thread{
...> public Test(String name){
...> super(name);
...> }
...> public void run(){
...> System.out.println(Thread.currentThread().getName());
...> }
...> }
| created class Test
jshell> Test t1=new Test("MyThread");
t1 ==> Thread[MyThread,5,main]
它创建一个线程，而不是Test对象。所以它会像一个线程。不能在线程之间共享Test类的实例。
2.实现可运行接口。
jshell> public class Test1 implements Runnable{
...> public void run(){
...> System.out.println(Thread.currentThread().getName());
...> }
...> public String getName(){
...> return "testing";}
...> }
| created class Test1
jshell> Test1 t1=new Test1();
t1 ==> Test1@396a51ab --> this creates Test1 object.
该对象可以通过以下方式跨线程共享，
jshell> Thread t1=new Thread(t1,"Hai");
t ==> Thread[Hai,5,main]
jshell> Thread t=new Thread(t1,"Hai");
t ==> Thread[Hai,5,main]
我认为已经有很多关于这个话题的讨论，认为这可能对基础知识有所帮助。
是的：implements Runnable是首选的实现方式，IMO。你并没有真正专门研究线程的行为。你只是在给它一些东西。这意味着构图是哲学上“更纯粹”的方式。
实际上，这意味着您可以实现Runnable并从另一个类扩展。。。您还可以通过lambda表达式实现Runnable，如Java 8。
