多線程 - 練習題（一）

第一章節

線程的定義

一條在程序代碼中獨立執行的路徑

 給出runnable的定義

一段封裝在對象中的代碼序列，它的類實現了runnable接口

thread類和runnable接口完成了什麼

類thread提供了一個底層操作系統線程架構的統一。runnable接口爲關聯thread對象的線程提供執行代碼。

創建一個runnable對象的兩種方式

創建一個實現了runnable的匿名類；使用lambda表達式；

關聯一個runnable到thread對象的兩種方式

把一個runnable傳遞到thread類的接受runnable參數的構造函數；繼承thread類重寫run（）

thread的五種狀態

狀態的5個標識：線程名字，線程存活的標識，線程的執行狀態，線程的優先級，線程是否爲守護線程；

確定線程的死活？

isalive（）方法

thread.state枚舉的所有的常量

new：線程還沒有開始執行

runable：該線程正在jvm中執行

blocked：線程被阻塞，正在等待一個監聽鎖

waitting：無限制地等待另一個線程執行特定的操作

terminated：線程已經退出

 獲取當前線程執行狀態

getState（）

讓一條線程等待另一個線程直到死亡的thread的方法

void join（）

package thread;

public class t20190904 {

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

    Thread t = new Thread(() -> {
      boolean flage = true;
      while (flage){
        System.out.println("hello");
        try {
          Thread.sleep(100);
         
        } catch (InterruptedException e) {
          System.out.println("interrupted");
          flage  = false;
          e.printStackTrace();
        }
      }
    });
    t.start();

    Thread.sleep(2000);
    t.interrupt();
  }
}

這是我寫的，答案用的是while（true） 和break

 第二章

線程相關的三個問題

競態條件；數據競爭；緩存變量

給出同步的定義

同步指的是jvm的特性，它用於保證兩條及兩條以上的線程不會同時在一個臨界區執行

同步的兩種屬性

互斥；可見

同步是如何實現出來的

同步是機遇監聽器出來的，它是控制對臨界區訪問的併發構架，必須不可分割的執行。每個java對象都關聯

着一個監聽器，線程可以通過上鎖或解鎖的方式獲取或者釋放監聽器上的鎖。

 三種活躍性挑戰

死鎖，活鎖，餓死

如何區分volatile和synchronized關鍵字

volatile只處理了可見性，而synchronized處理的可見性和互斥性

第三章

支持條件的api

wait（），notify

判斷：wait（）可以被中斷

對的

判斷：Object的wait（）方法並不會釋放鎖

錯的。和Thread的sleep相反。

 

提示：

 

package thread;


public class t20190910 {

  private static volatile int i = 0;

  static  Object object = new Object();

  public static void main(String[] args) {


    Runnable runnable = new Runnable() {
      @Override
      public void run() {
        System.out.println(Thread.currentThread().getId()+"等待中。。。。");
        synchronized (object){


          i++;
          try {
            //sleep 不會釋放鎖
            Thread.sleep(2000);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }

          try {
            while (i < 3){
              //wait()方法會釋放鎖
              object.wait();
            }
          } catch (InterruptedException e) {
            e.printStackTrace();
          }

        }


        System.out.println(Thread.currentThread().getId()+"線程終止 ");
      }
    };


    Thread t1 = new Thread(runnable);
    Thread t2 = new Thread(runnable);
    Thread t3 = new Thread(runnable);

    t1.start();
    t2.start();
    t3.start();

    Runnable r = new Runnable() {
      @Override
      public void run() {
        while(i<3){
          try {
            Thread.sleep(200);
          } catch (InterruptedException e) {
            e.printStackTrace();
          }
        }
        synchronized (object){
          object.notifyAll();
        }
      }
    };

    Thread tt = new Thread(r);
    tt.start();
  }
}

解釋說明下：

synchronized (object) 很有意思，如果你註釋掉第一個，程序跑2秒多，因爲你3個線程同時跑。不註釋是6秒多，你的線程是順序執行。

如果你註釋第二個報錯，屬於非法獲得監聽。