java创建线程implement runnable 和 extends thread 比较

我们都知道java实现线程有两种方法

一。继承Thread类

二。实现Runnable接口

看到很多说法他们之间有一个区别是：实现Runnable接口才能实现资源共享。继承thread的方式不行

并且附有类似以下的实例：

//Implement Runnable 的方式来实现线程
class ImplementsRunnable implements Runnable {

private int counter = 0;

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

//通过继承 Thread 类的方式
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 {
// 多线程共享同一个变量（rc）
ImplementsRunnable rc = new ImplementsRunnable();
Thread t1 = new Thread(rc);
t1.start();
Thread.sleep(1000); //启动下一个线程前，等待一秒钟
Thread t2 = new Thread(rc);
t2.start();
Thread.sleep(1000); //启动下一个线程前，等待一秒钟
Thread t3 = new Thread(rc);
t3.start();

// 通过extend Thread只能为每一个线程创建新的对象
ExtendsThread tc1 = new ExtendsThread();
tc1.start();
Thread.sleep(1000);
ExtendsThread tc2 = new ExtendsThread();
tc2.start();
Thread.sleep(1000);
ExtendsThread tc3 = new ExtendsThread();
tc3.start();
}
}

输出结果如下：

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

他们通过这个例子得出：实现Runnable接口才能实现资源共享。继承thread的方式不行 这个结论

其实我们仔细看一下这个例子，就会发现这个结论是错的：

1.首先我们看一下通过 Implements Runnable 方式创建线程时，发生了什么

截取上面例子中的两行代码：

ImplementsRunnable rc = new ImplementsRunnable();
Thread t1 = new Thread(rc);

rc对象是一个Runnable类，把它作为参数通过new Thread(Runnable arg)初始化了一个Thread。

我们进入Thread类的源码看一下（经过简化,要查看完整方法，参看java源码）：

当new Thread的时候，会调用Thread的init()方法，初始化这个线程

/**
* 初始化一个Thread
* .......
* @参数 target ：这个target参数的run()方法将会被最后调用（the object whose run() method gets called）
* ........
*/
private void init(...,Runnable target,....) {
......
this.target = target;
......
}

我们看到这个函数的关键是用传递给他的参数初始化这个Thread，注释中明确说道调用Thread的start()方法时，最终会调用的是这个target参数的run方法，当这个Thread调用start()方法后，最终会调用到如下run()方法：

public void run() {
if (target != null) {
target.run();
}
}

我们可以看到正如前面init()方法的注释所描述的一样，最终会调用的是线程init()时传递给这个Thread的target参数的run方法。

所以正如一开始的例子中的代码那样，用同一个Runnable target初始化多个线程，那么这多个线程都会调用同一个target的run()方

法。至始至终这个ImplementsRunnable对象就只有一个。

在这里要加一段话 虽然这样实现了资源的共享，但是并没有实现资源的同步，如下例子，我加入一个条件，如果counter小于10才能继续+1（比如多个窗口同时卖火车票的场景）：

class ImplementsRunnable implements Runnable {
private int counter = 0;
public void run() {
while(counter<10){
counter++;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
System.out.println(Thread.currentThread().getName()+":"+ counter);
}
}
}

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();
}

运行结果如下，出现了同步错误：

Thread-5:2
Thread-6:3
Thread-5:4
Thread-5:6
Thread-6:7
Thread-7:8
Thread-5:9
Thread-6:10
Thread-7:9
Thread-5:10

如果我们要实现同步的话，就需要加入synchronized方式了（当然还可以通过原子操作的方式通过CAS无锁实现）

修改后的代码如下：

class ImplementsRunnable implements Runnable {
private int counter = 0;
public void run() {
while(counter<10){
synchronized(this){
if(counter<10){
counter++;
System.out.println(Thread.currentThread().getName()+":"+ counter);
}
}
}
}
}

运行结果如下，达到了我们的目的：

Thread-5:1
Thread-6:2
Thread-7:3
Thread-7:4
Thread-6:5
Thread-6:6
Thread-6:7
Thread-6:8
Thread-6:9
Thread-5:10

那我们在看看通过extend Thread 的方式。它并没有一个共同的Runnable对象来初始化3个Thread对象。每一个Thread都拥有自己一个独立的Runnable对象。

当然不能实现资源的共享，因为现在每个Thread都有一个自己counter对象了。

那么问题来了：难道用extends Thread的方式就不能实现共享吗，答案是肯定可以实现：

方法有很多。我自己试着写了一个：

package test;
public class TestThread {

public static void main(String args[]) throws Exception {
ExtendsThread tc1 = new ExtendsThread();
tc1.start();
ExtendsThread tc2 = new ExtendsThread();
tc2.start();
ExtendsThread tc3 = new ExtendsThread();
tc3.start();
}
}

class ExtendsThread extends Thread {
public void run() {
while(Resource.getCounter()<10){
Resource.count();
}
}

}

多加入了一个类Resource.java

package test;

public class Resource {
private static int counter = 0;
public static int getCounter(){
return counter;
}
public static synchronized void count(){
if(counter<10){
counter++;
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+counter);
}
}
} 

运行结果如下：

Thread-5:1
Thread-5:2
Thread-6:3
Thread-5:4
Thread-7:5
Thread-6:6
Thread-7:7
Thread-6:8
Thread-7:9
Thread-6:10

可以看到 在这段代码中 我counter设置成了static，相应的用了class级别的锁。

不过相比implement runnable的方式还是麻烦了很多。

所以从上面两个比较我们可以得出

实现Runnable接口相比继承Thread类有如下好处：

　　->避免单点继承的局限，一个类可以继承多个接口。

　　->适合于资源的共享