java基礎：多線程的三種實現方式

• 線程運行速度比進程速度快

第一種：繼承抽象類Thread類

• 每個線程同一時間只能運行一次，否則就會拋出IllegalTheadStateException()異常
• 內部是JNI實現（即strat0()方法），JVM根據不同的系統實現不同的start0()方法
• 任何情況下，只要定義了多線程，多線程的啓動永遠只有一種方案，Thread類中的start()方法

import java.util.function.*;
class MyThread extends Thread{
	private String title;
	public MyThread(String title){
		this.title = title;
	}
	@Override
	public void run(){
		for(int i= 0;i< 10;i++){
			System.out.println(this.title + "i = " + i);
		}
	}
}
public class JavaDemo{
    public static void main(String[] arges){
        MyThread myThread01 = new MyThread("TEST01 ");
		myThread01.start();
        MyThread myThread02 = new MyThread("TEST02 ");
		myThread02.start();
        MyThread myThread03 = new MyThread("TEST03 ");
		myThread03.start();
    }
}

第二種：實現Runnable接口

• 1.8之後就變爲函數式接口，可以直接實現lambda函數式
• 開發中首要考慮Runnable實現，並通過Thread.start()方法
• 藉助構造方法：public Thread(Runnable target)實現
  • 這裏是實現接口，所以MyThread可以作爲一個正常的類，去繼承其他類或是實現多個接口（優點）

import java.util.function.*;
class MyThread implements Runnable{
	private String title;
	public MyThread(String title){
		this.title = title;
	}
	@Override
	public void run(){
		for(int i= 0;i< 10;i++){
			System.out.println(this.title + "i = " + i);
		}
	}
}
public class JavaDemo{
    public static void main(String[] arges){
        Thread thread = new Thread(new MyThread("TEST"));
		thread.start();
    }
}

• Lambda函數式(超簡潔)

  public class JavaDemo{
      public static void main(String[] arges){
  		Runnable run = ()->{
  			System.out.println("這裏在多線程中執行");
  		};
          new Thread(run).start();
      }
  }
  

• 再簡化一點

import java.util.function.*;
public class JavaDemo{
    public static void main(String[] arges){
        new Thread(()->{
			System.out.println("dsfsdf");
		}).start();
    }
}

Thread與Runnable的關係

• public class Thread extends Object implements Runnable{}Thread類也是實現了Runnable接口的子類
• 由上面瞭解到，多線程的方法主要都是由Thread實現的，所以操作系統的資源調用也是通過Thread調用的
• Thread爲代理類，MyThread或者實現Runnable接口的類爲真實類
• 多線程開發的本質是在於多個線程可以進行對統一資源的搶佔

第三種：Callable實現多線程

• Runnable的缺點是，執行完畢後，無法給主線程一個返回值，而Callable可以

• 1.5之後實現的新方法java.util.concurrent.Callable接口，使用泛型返回數據

• 方法流程圖

Runnable與Callable

• Runnable是在JDK1.0的時候提出的多線程的實現接口，而Callable是JDK1.5之後提出來的

• java.lang.Runnable接口之中只提出一個run()方法，並沒有返回值

• java.util.concurrent.Callable接口提供有call()方法，可以有返回值;

  import java.util.concurrent.Callable;
  import java.util.concurrent.FutureTask;
  
  class MyThread implements Callable<String>{
  	@Override
  	public String call() throws Exception{
  		for(int i=0;i < 1000;i++){
  			System.out.println("==========" + i);
  		}
  		return "=====end========";
  	}
  }
  public class JavaDemo{
      public static void main(String[] arges)throws Exception{
          FutureTask<String> task = new FutureTask<>(new MyThread());
  		new Thread(task).start();
  		System.out.println(task.get());
      }
  }