摘要：下面我們通過代碼來看一下實現和區別三種實現繼承，重寫方法實現接口，實現方法實現接口，實現方法，帶有返回值和異常如何使用第一種實現方式第二種實現方式第三種實現從代碼可以看出以上提到的區別，，。第二種方式并沒有體現共用同一個。

Java實現線程的三種方式：

繼承Thread

實現Runnable接口

實現Callable接口

區別：

第一種方式繼承Thread就不能繼承其他類了，后面兩種可以；

使用后兩種方式可以多個線程共享一個target；

Callable比Runnable多一個返回值，并且call()方法可以拋出異常；

訪問線程名，第一種直接使用this.getName()，后兩種使用Thread.currentThread().getName()。

下面我們通過代碼來看一下實現和區別：

三種實現：

//1. 繼承Thread，重寫run()方法
class Thread1 extends Thread {
    
    private int n = 5;
    
    @Override
    public void run() {
        while(n > 0) {
            System.out.println("name:" + this.getName() + ", n:" + n);
            n--;
        }
    }
}
//2. 實現Runnable接口，實現run()方法
class Thread2 implements Runnable {
    
    private int n = 5; 
    
    @Override
    public void run() {
        while(n > 0) {
            System.out.println("name:" + Thread.currentThread().getName() + ", n:" + n);
            n--;
        }
    }
}
//3. 實現Callable接口，實現call()方法，帶有返回值和異常
class Thread3 implements Callable {
    
    private int n = 5;

    @Override
    public String call() throws Exception {
        while(n > 0) {
            System.out.println("name:" + Thread.currentThread().getName() + ", n:" + n);
            n--;
        }
        return String.valueOf(n);
    }
    
}

如何使用：

//第一種實現方式
Thread1 t11 = new Thread1();
Thread1 t12 = new Thread1();
Thread1 t13 = new Thread1();

t11.start();
t12.start();
t13.start();

//第二種實現方式
Thread2 t21 = new Thread2();
Thread2 t22 = new Thread2();
Thread2 t23 = new Thread2();

Thread t211 = new Thread(t21);
Thread t212 = new Thread(t22);
Thread t213 = new Thread(t23);

t211.start();
t212.start();
t213.start();

//第三種實現
Thread3 t31 = new Thread3();
Thread3 t32 = new Thread3();
Thread3 t33 = new Thread3();

FutureTask f1 = new FutureTask<>(t31);
FutureTask f2 = new FutureTask<>(t32);
FutureTask f3 = new FutureTask<>(t33);

Thread t311 = new Thread(f1);
Thread t312 = new Thread(f2);
Thread t313 = new Thread(f3);

t311.start();
t312.start();
t313.start();

從代碼可以看出以上提到的區別1，3，4。那么區別2共享一個target是什么意思呢？

首先我們看一下上述代碼的運行結果，

第一種：

name:Thread-1, n:5
name:Thread-1, n:4
name:Thread-1, n:3
name:Thread-1, n:2
name:Thread-1, n:1
name:Thread-2, n:5
name:Thread-2, n:4
name:Thread-2, n:3
name:Thread-2, n:2
name:Thread-2, n:1
name:Thread-0, n:5
name:Thread-0, n:4
name:Thread-0, n:3
name:Thread-0, n:2
name:Thread-0, n:1

第二種：

name:Thread-4, n:5
name:Thread-4, n:4
name:Thread-4, n:3
name:Thread-3, n:5
name:Thread-5, n:5
name:Thread-3, n:4
name:Thread-4, n:2
name:Thread-4, n:1
name:Thread-3, n:3
name:Thread-3, n:2
name:Thread-3, n:1
name:Thread-5, n:4
name:Thread-5, n:3
name:Thread-5, n:2
name:Thread-5, n:1

可以看到，這兩種方式的結果一樣，都是new了三個線程，每個線程內部循環5次。d第二種方式并沒有體現共用同一個target。如果我們將第二種創建線程的方式改為：

//第二種實現方式
Thread2 t21 = new Thread2();
Thread2 t22 = new Thread2();
Thread2 t23 = new Thread2();

Thread t211 = new Thread(t21);
Thread t212 = new Thread(t21);
Thread t213 = new Thread(t21);

t211.start();
t212.start();
t213.start();

看一下運行結果：

name:Thread-4, n:5
name:Thread-4, n:4
name:Thread-4, n:3
name:Thread-4, n:2
name:Thread-4, n:1
name:Thread-3, n:5
name:Thread-5, n:5

可以看到，雖然也啟動了3個線程，但是由于共享一個target，n的值改變了，其他兩個線程也會知道，所以因此一共循環了5次。但是這里明明是7次啊，這是由于多線程的同步問題，可以給run方法加上synchronized關鍵字解決：

@Override
public synchronized void run() {
  while(n > 0) {
    System.out.println("name:" + Thread.currentThread().getName() + ", n:" + n);
    n--;
  }
}

運行結果：

name:Thread-3, n:5
name:Thread-3, n:4
name:Thread-3, n:3
name:Thread-3, n:2
name:Thread-3, n:1

這里可能有點迷惑，只啟動了一個線程啊。其實另外兩個線程也啟動了，只是這個時候n=0無法進入循環。我們可以加一行打印：

@Override
public synchronized void run() {
  System.out.println("進入" + Thread.currentThread().getName() + "線程");
  while(n > 0) {
    System.out.println("name:" + Thread.currentThread().getName() + ", n:" + n);
    n--;
  }
}

可以看到運行結果：

進入Thread-3線程
name:Thread-3, n:5
name:Thread-3, n:4
name:Thread-3, n:3
name:Thread-3, n:2
name:Thread-3, n:1
進入Thread-5線程
進入Thread-4線程