實現多執行緒

java實現多執行緒的方法有三種，分別是繼承thread類，實現runnable介面，實現callable介面（call方法有返回值）

/**
 * 繼承Thread
 */
public class MyThread extends Thread{
     int a = 0;
    @Override
    public void run() {
        //執行緒的核心實現
        synchronized (this){
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println( ++a );
        }

    }
}

class MyThreadTest{
    public static void main(String[] args) {
        //例項三個執行緒
        MyThread myThread1 = new MyThread();
        MyThread myThread2 = new MyThread();
        MyThread myThread3 = new MyThread();

        //啟動三個執行緒
        myThread1.start();
        myThread2.start();
        myThread3.start();
        
    }
}
 

輸出結果：

/**
 * 實現Runnable介面
 */
public class MyRunnable implements Runnable {
    int a = 0;

    @Override
    public void run() {
        //執行緒核心處理方法
        System.out.println(++a);
    }

}

class MyRunnableTest {
    public static void main(String[] args) {
        //例項話MyRunnable
        Runnable runnable = new MyRunnable();

        //通過runnable例項化三個執行緒
        Thread thread1 = new Thread(runnable);
        Thread thread2 = new Thread(runnable);
        Thread thread3 = new Thread(runnable);

        //啟動三個執行緒
        thread1.start();
        thread2.start();
        thread3.start();

        // 輸出的結果為1  2  3  ，輸出的順序可能不同

    }
}
 

輸出結果：

/**
 *
 * 實現Callable介面
 */
public class MyCallable implements Callable<String> {

    int a = 0;

    @Override
    public String call() throws Exception {
        ++a;
        System.out.println(Thread.currentThread().getName() + ",a=" + a);
        return String.valueOf(a);
    }
}

class TestCallable {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        Callable callable = new MyCallable();
        FutureTask<String> task = new FutureTask<String>(callable);


        Thread thread1 = new Thread(task,"執行緒一");
        Thread thread2 = new Thread(task,"執行緒二");
        Thread thread3 = new Thread(task,"執行緒三");

        thread1.start();
        thread2.start();
        thread3.start();
        // 取得返回值
        System.out.println(task.get());
        
    }
}
 

輸出結果：

Thread、Runnable、Callable介面實現多執行緒的區別

觀察以上三種實現方式和輸出的結果可得
1.繼承Thread方式，每次new Thread都是獨立的，資源不共享,而Runnable資源共享；
2.實現Callable介面方式，只能執行一次FutureTask

Thread類與Runnable介面實現多執行緒的區別

1.Thread類是Runnable介面的子類，使用runnable介面實現多執行緒可以避免單繼承侷限；

2.Runnable介面實現的多執行緒可以比Thread類實現的多執行緒更加清楚的描述資料共享的概念。

如何理解：
因為一個執行緒只能啟動一次，通過Thread實現執行緒時，執行緒和執行緒所要執行的任務是捆綁在一起的。也就使得一個任務只能啟動一個執行緒，不同的執行緒執行的任務是不相同的，所以沒有必要，也不能讓兩個執行緒共享彼此任務中的資源。

通過Runnable方式實現的執行緒，實際是開闢一個執行緒，將任務傳遞進去，由此執行緒執行。可以例項化多個 Thread物件，將同一任務傳遞進去，也就是一個任務可以啟動多個執行緒來執行它。這些執行緒執行的是同一個任務，所以他們的資源是共享。

Calleble介面

1.最大的特點就是可以通過FutureTask獲得執行緒核心處理方法的返回值(run方法是無返回值的
2.get方法會阻塞主執行緒來等待任務完成。FutureTask非常適合用於耗時的計算，主執行緒可以在完成自己的任務後，再去獲取結果

1. FutureTask被多次呼叫，依然只會執行一次Runnable任務