尚矽谷_每日一考_427

427

1.談談你對程式、進程、線程的理解。

程式：programm，為完成某個任務，採用某種編程語言編寫的一組命令的集合，是一段靜態代碼。

進程：process，正在運行的程式。如運行中的wechat等，有一個生命周期。

線程：thread，一個程式內部的執行路徑。

例如，360軟體，啟動後，程式運行，其中每一個功能代表一個線程，表明該軟體是支持多線程的。

重點：如何創建多線程

2.代碼完成繼承 Thread 的方式創建分線程，並遍歷100 以內的自然數。

//步驟
//1.創建一個繼承於thread的子類
class Mythread extends Thread{
    //2.重寫Thread的run()方法-->將此線程執行的操作聲明在run()中
    public void run(){
        for(int i = 0; i < 100; i++){//自然數是指非負整數
                System.out.println(i);
        }
    }
}
public class ThreadTest{
    public static void mian(String[] args){
        //3.創建Thread類的子類
        Mythread t1 = new MyThread();//mian方法，主線程做的
        //4.通過此對象調用start
        t1.start();//Thread中的方法，start方法會自動調用執行run()方法，t1開始獨立執行|1.啟動當前線程2.調用當前線程的run(),已重寫的
    }
}

3.代碼完成實現Runnable 介面的方法創建分線程，並遍歷 100以內的自然數。

/*1.創建一個類實現Runnable介面
2.重寫run方法
3.創建類的實例
4.將實例對象傳入Thread類的構造器，並創建新的線程對象
5.用該對象調用start方法。啟動線程，並調用run方法，從Thread的源碼可知，該方法調用了Runnable類型的target的run()
*/
class Mythread implements Runnable{
    public void run(){
        for(int i = 0; i < 100; i++){
            System.out.println(i);
        }
    }
}
public class Mythread{
    public static void main(String[] args){
        Mythread myThread = new Mythread();
        Thread t1 = new Thread(MyThread);
        t1.start();
    }
}

4.對比兩種創建方式。

1.都重寫run方法

2.用實現Runnable介面的方法創建對象可以避免java單繼承機制帶來的局限；

3.用實現Runnable介面的方法，可以實現多個線程共用同一段代碼(數據，如買票時的票數)；

MyThread myThread = new MyThread();

MyThread t1 = new Thread(myThread);

MyThread t2 = new Thread(myThread);

4.程式有同步邏輯需求，則使用Runnable的方法來創建線程。

5.說說你對 IDEA 中Project 和Module 的理解。

對應Eclipse中的WorkSpace和Project

線程創建方法詳解

1.繼承Thread

//步驟
//1.創建一個繼承於thread的子類
class Mythread extends Thread{
    //2.重寫Thread的run()方法-->將此線程執行的操作聲明在run()中
    public void run(){
        for(int i = 0; i < 100; i++){//自然數是指非負整數
                System.out.println(i);
        }
    }
}
public class ThreadTest{
    public static void mian(String[] args){
        //3.創建Thread類的子類
        Mythread t1 = new MyThread();//mian方法，主線程做的
        //4.通過此對象調用start
        t1.start();//Thread中的方法，start方法會自動調用執行run()方法，t1開始獨立執行|1.啟動當前線程2.調用當前線程的run(),已重寫的    

    	t1.run();//不可以的，沒有啟動新線程,還是main
    	//可以調用獲取當前線程名的方法查看，Thread.currentThread().getName()


        t1.start();//兩次調用，該方法會拋異常
        //可以新建線程對象
        Mythread t2 = new MyThread();
        t2.start();
        
        for(int j = 0; j<=100; j++){
             System.out.println("helloWorld")//主線程執行的，與上條語句共同爭奪線程CUP
        }
    }

}

創建Thread類的匿名子類的方式

new Thread(){
	public void run(){
        for(int i = 0; i <= 100; i++){//自然數是指非負整數
                System.out.println(i);
        }
    }
}.start();

2.實現runnable介面

//1.創建一個實現了Runnable介面的類
class MyThread implements Runnable{
    //2.實現 類去實現Runnable中的方法：run()
    public void run(){
        for(int i = 0; i<100; i++){
            System.out.println(i);
        }
    }
}
public class MyThread{
  	public static void main(String[] args){
	//3.創建實現類的對象
        MyThread myThread = new MyThread();
        //4.將此對象作為參數傳到Thread類的構造器中，創建Thread類的對象
        MyThread t1 = new Thread(myThread);
        //5.通過Thread類的對象調用start()。調用了Runnable類型的target的run()
        t1.start();
	}  
}

拓展

創建線程的方式3：實現 Callable 介面。

特點：

1.與 Runnable 相比，Callable 可以有返回值，返回值通過 FutureTask 進行封裝。

2.Callable需要依賴FutureTask，用於接收運算結果。一個產生結果，一個拿到結果。3.

FutureTask是Future介面的實現類，也可以用作閉鎖。

異同：

（1）Callable規定的方法是call()，而Runnable規定的方法是run().

（2）Callable的任務執行後可返回值，而Runnable的任務是不能返回值的。

（3）call()方法可拋出異常，而run()方法是不能拋出異常的。

（4）運行Callable任務可拿到一個Future對象， Future表示非同步計算的結果

public class MyCallable implements Callable<Integer> {
    public Integer call() {
        return 666;
    }
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
    MyCallable myThread = new MyCallable();
    FutureTask<Integer> ft = new FutureTask<>(myThread);
    Thread t1 = new Thread(ft);
   	t1.start();
    System.out.println(ft.get());
}

參考文章鏈接：https://blog.csdn.net/qq_42253147/article/details/94330841