Java线程与可运行[重复]

Question

在阅读here Thread 和 Runnable 之间的显着差异时，我遇到了一个差异：

当您扩展 Thread 类时，您的每个线程都会创建唯一的对象并与之关联。其中

当您实现 Runnable 时，它​​会将同一个对象共享给多个线程。。

有代码给：

class ImplementsRunnable implements Runnable {

  private int counter = 0;

  public void run() {
    counter++;
    System.out.println("ImplementsRunnable : Counter : " + counter);
  }
}

 class ExtendsThread extends Thread {

   private int counter = 0;

   public void run() {
     counter++;
     System.out.println("ExtendsThread : Counter : " + counter);
   }
 }

 public class ThreadVsRunnable {

   public static void main(String args[]) throws Exception {
     //Multiple threads share the same object.
     ImplementsRunnable rc = new ImplementsRunnable();
     Thread t1 = new Thread(rc);
     t1.start();
     Thread.sleep(1000); // Waiting for 1 second before starting next thread
     Thread t2 = new Thread(rc);
     t2.start();
     Thread.sleep(1000); // Waiting for 1 second before starting next thread
     Thread t3 = new Thread(rc);
     t3.start();

     //Creating new instance for every thread access.
     ExtendsThread tc1 = new ExtendsThread();
     tc1.start();
     Thread.sleep(1000); // Waiting for 1 second before starting next thread
     ExtendsThread tc2 = new ExtendsThread();
     tc2.start();
     Thread.sleep(1000); // Waiting for 1 second before starting next thread
     ExtendsThread tc3 = new ExtendsThread();
     tc3.start();
   }
 }

输出是这样的：

ImplementsRunnable : Counter : 1
ImplementsRunnable : Counter : 2
ImplementsRunnable : Counter : 3
ExtendsThread : Counter : 1
ExtendsThread : Counter : 1
ExtendsThread : Counter : 1

它证明了上面给出的差异。我对下面给出的代码稍作修改：

class ImplementsRunnable implements Runnable {

  private int counter = 0;

  public void run() {
    counter++;
    System.out.println("ImplementsRunnable : Counter : " + counter);
  }
}

class ExtendsThread extends Thread {

  private int counter = 0;

  public void run() {
    counter++;
    System.out.println("ExtendsThread : Counter : " + counter);
  }
}

public class ThreadVsRunnable {

  public static void main(String args[]) throws Exception {
    //Multiple threads share the same object.
    ImplementsRunnable rc = new ImplementsRunnable();
    Thread t1 = new Thread(rc);
    t1.start();
    Thread.sleep(1000); // Waiting for 1 second before starting next thread
    Thread t2 = new Thread(rc);
    t2.start();
    Thread.sleep(1000); // Waiting for 1 second before starting next thread
    Thread t3 = new Thread(rc);
    t3.start();

    //Modification done here. Only one object is shered by multiple threads here also.
    ExtendsThread extendsThread = new ExtendsThread();
    Thread thread11 = new Thread(extendsThread);
    thread11.start();
    Thread.sleep(1000);
    Thread thread12 = new Thread(extendsThread);
    thread12.start();
    Thread.sleep(1000);
    Thread thread13 = new Thread(extendsThread);
    thread13.start();
    Thread.sleep(1000);
  }
}

现在的输出是：

ImplementsRunnable : Counter : 1
ImplementsRunnable : Counter : 2
ImplementsRunnable : Counter : 3
ExtendsThread : Counter : 1
ExtendsThread : Counter : 2
ExtendsThread : Counter : 3

我理解这样一个事实，这里同一个对象（extendsThread）由三个线程共享。但是我在这里感到困惑，它与实现 Runnable 有何不同。在这里，即使 *ExtendsThread * 扩展了 Thread，我们仍然可以将这个类的对象共享给其他线程。在我看来，上述差异没有任何意义。

谢谢。

Answer 1

实现 Runnable 的主要区别在于您不会“消耗”您的单一继承。考虑这些类声明：

public class HelloRunnable implements Runnable extends AbstractHello

public class HelloRunnable extends Thread

在继承方面，您可以使用 Runnable 做更多事情。

Answer 2

@BalwantChauhan：Runnable 接口的一种常见用法是，我们知道在 Java 的情况下多重继承是不可能的。现在假设您有一个场景，您想要扩展一个类并且还想要实现线程。因此，对于那些场景，如果我们继续使用 Thread，那么就不可能实现它。 例如：假设（在 Java Swing 的情况下），如果你想创建一个框架，并且你想在那个框架类中实现线程，那么就不可能扩展 JFrame 和 Thread 类，所以在这种情况下我们扩展 JFrame 和实现 Runnable。

public class HelloFrame extends JFrame implements Runnable{

  ...

  public void run(){
    //  thread code
  }

  ...
}  

Answer 3

javadoc 声明如下

有两种方法可以创建新的执行线程。一种是 将一个类声明为 Thread 的子类。这个子类应该 重写类 Thread 的 run 方法。子类的一个实例 然后可以分配和启动。例如，计算线程 大于规定值的素数可以写成如下：

创建线程的另一种方法是声明一个实现的类 可运行接口。然后该类实现 run 方法。一个 然后可以分配类的实例，作为参数传递 在创建线程时，并启动。 这个其他的相同示例 样式如下所示：

两种方式

public class MyThread extends Thread {
    // overriden from Runnable, which Thread implements
    public void run() {
        ...
    }
}

...
MyThread thread = new MyThread();
thread.start();

或者

public class MyRunnable implements Runnable{
    public void run() {
        ...
    }
}
...
Thread thread = new Thread(new MyRunnable());
thread.start();

您的 counter 字段是一个实例字段。

在您的第一种情况下，这里创建的每个对象

 ExtendsThread tc1 = new ExtendsThread();
 tc1.start();
 Thread.sleep(1000); // Waiting for 1 second before starting next thread
 ExtendsThread tc2 = new ExtendsThread();
 tc2.start();
 Thread.sleep(1000); // Waiting for 1 second before starting next thread
 ExtendsThread tc3 = new ExtendsThread();
 tc3.start();

会有自己的副本（这就是实例变量的工作方式）。因此，当您启动每个线程时，每个线程都会增加自己的字段副本。

在您的第二种情况下，您将 Thread 子类用作 Runnable 构造函数的 Runnable 参数。

ExtendsThread extendsThread = new ExtendsThread();
Thread thread11 = new Thread(extendsThread);
thread11.start();
Thread.sleep(1000);
Thread thread12 = new Thread(extendsThread);
thread12.start();
Thread.sleep(1000);
Thread thread13 = new Thread(extendsThread);
thread13.start();
Thread.sleep(1000);

它与您传递的ExtendsThread 对象相同，因此其counter 字段会被所有线程递增。它几乎等同于您之前使用的ImplementsRunnable。

从 cmets 添加：

首先要了解的是Thread 类实现了Runnable，因此您可以在任何可以使用Runnable 的地方使用Thread 实例。 例如，

new Thread(new Thread()); // won't do anything, but just to demonstrate

当你用

创建Thread时

new Thread(someRunnable);

并启动它，线程调用给定的Runnable 实例的run() 方法。如果那个Runnable 实例恰好也是Thread 的一个实例，那就这样吧。这不会改变任何事情。

当你创建一个自定义线程时

new ExtendsThread();

并启动它，它会自行调用run()。