繼承Thread
通過繼承Thread類來創建并啟動多線程的一般步驟如下
1】d定義Thread類的子類，并重寫該類的run()方法，該方法的方法體就是線程需要完成的任務，run()方法也稱為線程執行體。
2】創建Thread子類的實例，也就是創建了線程對象
3】啟動線程，即調用線程的start()方法
public class MyThread extends Thread{//繼承Thread類
public void run(){
//重寫run方法
}
}
public class Main {
public static void main(String[] args){
new MyThread().start();//創建并啟動線程
}
}
實現Runnable接口
通過實現Runnable接口創建并啟動線程一般步驟如下：
1】定義Runnable接口的實現類，一樣要重寫run()方法，這個run（）方法和Thread中的run()方法一樣是線程的執行體
2】創建Runnable實現類的實例，并用這個實例作為Thread的target來創建Thread對象，這個Thread對象才是真正的線程對象
3】第三部依然是通過調用線程對象的start()方法來啟動線程
public class MyThread2 implements Runnable {//實現Runnable接口
public void run(){
//重寫run方法
}
}
public class Main {
public static void main(String[] args){
//創建并啟動線程
MyThread2 myThread=new MyThread2();
Thread thread=new Thread(myThread);
thread().start();
//或者 new Thread(new MyThread2()).start();
}
}
使用Callable和Future創建線程
和Runnable接口不一樣，Callable接口提供了一個call（）方法作為線程執行體，call()方法比run()方法功能要強大。
》call()方法可以有返回值
》call()方法可以聲明拋出異常
Java5提供了Future接口來代表Callable接口里call()方法的返回值，并且為Future接口提供了一個實現類FutureTask，這個實現類既實現了Future接口，還實現了Runnable接口，因此可以作為Thread類的target。在Future接口里定義了幾個公共方法來控制它關聯的Callable任務。
boolean cancel(boolean mayInterruptIfRunning)：視圖取消該Future里面關聯的Callable任務
V get()：返回Callable里call（）方法的返回值，調用這個方法會導致程序阻塞，必須等到子線程結束后才會得到返回值
V get(long timeout,TimeUnit unit)：返回Callable里call（）方法的返回值，最多阻塞timeout時間，經過指定時間沒有返回拋出TimeoutException
boolean isDone()：若Callable任務完成，返回True
boolean isCancelled()：如果在Callable任務正常完成前被取消，返回True
介紹了相關的概念之后，創建并啟動有返回值的線程的步驟如下：
1】創建Callable接口的實現類，并實現call()方法，然后創建該實現類的實例（從java8開始可以直接使用Lambda表達式創建Callable對象）。
2】使用FutureTask類來包裝Callable對象，該FutureTask對象封裝了Callable對象的call()方法的返回值
3】使用FutureTask對象作為Thread對象的target創建并啟動線程（因為FutureTask實現了Runnable接口）
4】調用FutureTask對象的get()方法來獲得子線程執行結束后的返回值
public class CallableThreadTest implements Callable<Integer> {
@Override
public Integer call() throws Exception {
int i = 0;
for (; i < 100; i++) {
Thread.sleep(300);
Log.i("zhou", Thread.currentThread().getName() + " " + i); //4.執行線程
}
return i;
}
}
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
CallableThreadTest ctt = new CallableThreadTest(); //1.類實現callable接口 實現call為方法體
FutureTask<Integer> ft = new FutureTask<>(ctt); //2.用futruetask包裝
for (int i = 0; i < 100; i++) {
Log.i("zhou", Thread.currentThread().getName() + " 的循環變量i的值" + i);
if (i == 20) {
new Thread(ft, "有返回值的線程").start(); //3.new Thread傳入這個futruetask對象實現線程 啟動
}
}
Log.i("zhou","~~~~~~~~~~~~~~~~~~~~~~~~~~~");
try {
Log.i("zhou", "子線程的返回值：" + ft.get()); //5.線程的返回結果會在線程執行完畢后返回 沒執行完沒返回 且會阻塞下面的代碼
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
Log.i("zhou","!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"); //6.在5沒執行的話6無法執行！ 會造成anr
}
}
這里返回值如果在主線程獲取的話，會阻塞代碼，甚至anr。
AsyncTask內部就是使用的futureTask，FutureTask在高并發環境下確保任務只執行一次，所以多次excute會異常也與這個有關系。
線程池
線程的提供的四種方式，或者工廠方法創建。
ThreadFactory
public class FixCountThreadFactory implements ThreadFactory{
private final int MAX_THREAD;
private final AtomicInteger count = new AtomicInteger(0);
public FixCountThreadFactory(int maxThread) {
MAX_THREAD = maxThread;
}
@Override
public Thread newThread(Runnable r) {
int incrementAndGet = count.incrementAndGet();
if(incrementAndGet > MAX_THREAD)
{
count.decrementAndGet();
return null;
}
return new Thread(r);
}
}
通常實現ThreadFactory接口的newThread方法，用工廠模式。
比如給線程命名。
