从我在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
这两个代码块有什么显著的区别吗？
当前回答
您可以共同使用它们
例子：
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
}
}
其他回答
Runnable是一个接口，而Thread是实现该接口的类。从设计的角度来看，任务的定义方式和执行方式之间应该有明确的区分。前者由Runnalbe实现负责，后者由Thread类负责。在大多数情况下，实现Runnable是正确的做法。
将Thread类与Runnable实现分离还可以避免线程和run（）方法之间的潜在同步问题。单独的Runnable通常在引用和执行可运行代码的方式上提供更大的灵活性。
这也许不是答案，但无论如何；还有一种创建线程的方法：
Thread t = new Thread() {
public void run() {
// Code here
}
}
这就是SOLID的s：单一责任。
线程体现了一段代码的异步执行的运行上下文（如执行上下文：堆栈帧、线程id等）。理想情况下，这段代码应该是相同的实现，无论是同步的还是异步的。
如果将它们捆绑在一个实现中，则会给结果对象两个不相关的更改原因：
应用程序中的线程处理（即查询和修改执行上下文）由代码段（可运行部分）实现的算法
如果您使用的语言支持部分类或多重继承，那么您可以在其自己的超级类中分离每个原因，但归结起来与组成两个对象相同，因为它们的特征集不重叠。这是为了理论。
在实践中，一般来说，一个方案不需要比必要的更复杂。如果您有一个线程在处理一个特定的任务，而不需要更改该任务，那么将任务划分为单独的类可能没有任何意义，并且代码仍然更简单。
在Java环境中，由于该工具已经存在，因此直接从独立的可运行类开始，并将其实例传递给线程（或执行器）实例可能更容易。一旦习惯了这种模式，它就不比简单的可运行线程情况更难使用（甚至读取）。
对于大多数工作线程来说，最好的方法是将线程完全封装在工作线程类中，这样就不会有任何外部干扰，导致不需要的和无效的线程/类状态。
我刚刚发布了一个示例，因此我也将与您分享：
/**
* This worker can only run once
* @author JayC667
*/
public class ProperThreading {
private final Thread mThread = new Thread(() -> runWorkingLoop()); // if you want worker to be able to run multiple times, move initialisation into startThread()
private volatile boolean mThreadStarted = false;
private volatile boolean mStopRequested = false;
private final long mLoopSleepTime;
public ProperThreading(final long pLoopSleepTime /* pass more arguments here, store in members */ ) {
mLoopSleepTime = pLoopSleepTime;
}
public synchronized void startThread() {
if (mThreadStarted) throw new IllegalStateException("Worker Thread may only be started once and is already running!");
mThreadStarted = true;
mThread.start();
}
private void runWorkingLoop() {
while (!mStopRequested /* && other checks */ ) {
try {
// do the magic work here
Thread.sleep(mLoopSleepTime);
} catch (final InterruptedException e) {
break;
} catch (final Exception e) {
// do at least some basic handling here, you should NEVER ignore exception unless you know exactly what you're doing, and then it should be commented!
}
}
}
public synchronized void stopThread() {
if (!mThreadStarted) throw new IllegalStateException("Worker Thread is not even running yet!");
mStopRequested = true;
mThread.interrupt();
}
}
