進程和線程

在并行程序中進程和線程是兩個基本的運行單元，在Java并發(fā)編程中，并發(fā)主要核心在于線程

1. 進程

一個進程有其專屬的運行環(huán)境，一個進程通常有一套完整、私有的運行時資源；尤其是每個進程都有其專屬的內存空間。
通常情況下，進程等同于運行的程序或者應用，然而很多情況下用戶看到的一個應用實際上可能是多個進程協(xié)作的。為了達到進程通信的目的，主要的操作系統(tǒng)都實現了Inter Process Communication(IPC)資源，例如pipe和sockets，IPC不僅能支持同一個系統(tǒng)中的進程通信，還能支持跨系統(tǒng)進程通信。

2. 線程

線程通常也被叫做輕量級進程，進程線程都提供執(zhí)行環(huán)境，但是創(chuàng)建一個線程需要的資源更少，線程在進程中，每個進程至少有一條線程，線程共享進程的資源，包括內存空間和文件資源，這種機制會使得處理更高效但是也存在很多問題。
多線程運行是Java的一個主要特性，每個應用至少包含一個線程或者更多。從應用程序角度來講，我們從一條叫做主線程的線程開始，主線程可以創(chuàng)建別的其他的線程。

線程生命周期

一個線程的生命周期包含了一下幾種狀態(tài)

1、新建狀態(tài)

該狀態(tài)線程已經被創(chuàng)建，但未進入運行狀態(tài)，我們可以通過start()方法來調用線程使其進入可執(zhí)行狀態(tài)。

2、可執(zhí)行狀態(tài)/就緒狀態(tài)

在該狀態(tài)下，線程在排隊等待任務調度器對其進行調度執(zhí)行。

3、運行狀態(tài)

在該狀態(tài)下，線程獲得了CPU的使用權并在CPU中運行，在這種狀態(tài)下我們可以通過yield()方法來使得該線程讓出時間片給自己或者其他線程執(zhí)行，若讓出了時間片，則進入就緒隊列等待調度。

4、阻塞狀態(tài)

在阻塞狀態(tài)下，線程不可運行，并且被異除出等待隊列，沒有機會進行CPU執(zhí)行，在以下情況出現時線程會進入阻塞狀態(tài)

• 調用suspend()方法
• 調用sleep()方法
• 調用wait()方法
• 等待IO操作

線程可以從阻塞狀態(tài)重回就緒狀態(tài)等待調度，如IO操作完畢后。

5、終止狀態(tài)

當線程執(zhí)行完畢或被終止執(zhí)行后便會進入終止狀態(tài)，進入終止狀態(tài)后線程將無法再被調度執(zhí)行，徹底喪失被調度的機會。

線程對象

每一條線程都有一個關聯(lián)的Thread對象，在并發(fā)編程中Java提供了兩個基本策略來使用線程對象

• 直接控制線程的創(chuàng)建和管理，在需要創(chuàng)建異步任務時直接通過實例化Thread來創(chuàng)建和使用線程。
• 或者將抽象好的任務傳遞給一個任務執(zhí)行器 executor

1. 定義和開始一條線程

在創(chuàng)建一個線程實例時需要提供在線程中執(zhí)行的代碼，有兩種方式可以實現。

提供一個Runnable對象，Runnable接口定義了一個run方法，我們將要在線程中執(zhí)行的方法放到run方法內部，再將Runnable對象傳遞給一個Thread構造器，代碼如下。

public class ThreadObject {
  public static void main(String args[]) {
    new Thread(new HelloRunnable()).start();
  }
}
// 實現Runnable接口
class HelloRunnable implements Runnable {
  @Override
  public void run() {
    System.out.println("Say hello to world!!!");
  }
}

繼承Thread，Thread類自身實現了Runnable接口，但是其run方法什么都沒做，由我們自己根據需求去擴展。

public class ThreadObject {
  public static void main(String args[]) {
    new HelloThread().start();
  }
}
// 繼承Thread，擴展run方法
class HelloThread extends Thread {
  public void run() {
    System.out.println("Say hello to world!!!");
  }
}

兩種實現方式的選取根據業(yè)務場景和Java中單繼承，多實現的特性來綜合考量。

2. 利用Sleep暫停線程執(zhí)行

sleep()方法會使線程進入阻塞隊列，進入阻塞隊列后，線程會將CPU時間片讓給其他線程執(zhí)行，sleep()有兩個重載方法sleep(long millis)和sleep(long millis, int nanos)當到了指定的休眠時間后，線程將會重新進入就緒隊列等待調度管理器進行調度

public static void main(String args[]) throws InterruptedException {
  for (int i = 0; i < 4; i++) {
    System.out.println("print number "+ i);
    // 將主線程暫停4秒后執(zhí)行,4秒后重新獲得調度執(zhí)行的機會
    Thread.sleep(4*1000);
  }
}

3. 中斷

當一個線程被中斷后就代表這個線程再無法繼續(xù)執(zhí)行，將放棄所有在執(zhí)行的任務，程序可以自己決定如何處理中斷請求，但通常都是終止執(zhí)行。

在Java中與中斷相關的有Thread.interrupt()、Thread.isInterrupted()、Thread.interrupted()三個方法

Thread.interrupt()為設置中斷的方法，該方法會將線程狀態(tài)設置為確認中斷狀態(tài)，但程序并不會立馬中斷執(zhí)行只是設置了狀態(tài)，而Thread.isInterrupted()、Thread.interrupted()這兩個方法可以用于捕獲中斷狀態(tài)，區(qū)別在于Thread.interrupted()會重置中斷狀態(tài)。

4. Join

join方法允許一條線程等待另一條線程執(zhí)行完畢，例如t是一條線程，若調用t.join()方法，則當前線程會等待t線程執(zhí)行完畢后再執(zhí)行。

線程同步 Synchronization

各線通信方式

• 共享對象的訪問權限 如. A和B線程都有訪問和操作某一個對象的權限
• 共享 對象的引用對象的訪問權限 如. A和B線程都能訪問C對象，C對象引用了D對象，則A和B能通過C訪問D對象

這種通信方式使得線程通訊變得高效，但是也帶來一些列的問題例如線程干擾和內存一致性錯誤。那些用于防止出現這些類型的錯誤出現的工具或者策略就叫做同步。

1. 線程干擾 Thread Interference

線程干擾是指多條線同時操作某一個引用對象時造成計算結果與預期不符，彼此之間相互干擾。如例

public class ThreadInterference{
  public static void main(String args[]) throws InterruptedException {
    Counter ctr = new Counter();
    // 累加線程
    Thread incrementThread = new Thread(()->{
      for(int i = 0; i<10000;i++) {
        ctr.increment();
      }
    }); 
    // 累減線程
    Thread decrementThread = new Thread(()->{
      for(int i = 0; i<10000;i++) {
        ctr.decrement();
      }
    }); 
    incrementThread.start();
    decrementThread.start();
    incrementThread.join();
    decrementThread.join();
    System.out.println(String.format("最終執(zhí)行結果：%d", ctr.get()));
  }
}
class Counter{
  private int count = 0;
  // 自增
  public void increment() {
    ++this.count;
  }
  // 自減
  public void decrement() {
    --this.count;
  }
  public int get() {
    return this.count;
  }
}

理論上來講，如果按照正常的思路理解，一個累加10000次一個累減10000次最終結果應該是0 ，但實際結果卻是每次運行結果都不一致，產生這個結果的原因便是線程之間相互干擾。

我們可以把自增和自減操作拆解為以下幾個步驟

• 獲取count變量當前值
• 自增/自減 獲取到的值
• 將結果保存回count變量

當多個線程同時對count進行操作時，便可能產生如下這一種狀態(tài)

• 線程A : 獲取count
• 線程B : 獲取count
• 線程A: 自增，結果 為 1
• 線程B: 自減，結果為 -1
• 線程A: 將結果1 保存到count; 當前count = 1
• 線程B: 將結果-1 保存到count; 當前count = -1

當線程以上面所示的順序執(zhí)行時，線程B就會覆蓋掉線程A的結果，當然這只是其中一種情況。

2. 內存一致性錯誤 Memory Consistency Errors

當不同的線程對應相同數據具有不一致的視圖時，會發(fā)生內存一致性錯誤，詳細信息參見 JVM內存模型

3. 同步方法

Java提供了兩種同步的慣用方法：同步方法 synchronized methods 、同步語句 synchronized statements 。要使方法變成同步方法只需要在方法聲明時加入synchronized關鍵字，如

class Counter{
  private int count = 0;
  // 自增
  public synchronized void increment() {
    ++this.count;
  }
  // 自減
  public synchronized void decrement() {
    --this.count;
  }
  public synchronized int get() {
    return this.count;
  }
}

聲明為同步方法之后將會使得對象產生如下所述的影響

• 首先，不可以在同一對象上多次調用同步方法來交錯執(zhí)行，同步聲明使得同一個時間只能有一條線程調用該對象的同步方法，當一條線程已經在調用同步方法時，其他線程會被阻塞block，無法調用該對象的所有同步方法。
• 其次，當同步方法調用結束時，會自動與同一對象的任何后續(xù)調用方法建立一個happens-before關聯(lián)，這保證對對象狀態(tài)的更改對所有線程可見。

4. 內部鎖和同步

同步是圍繞對象內部實體構建的，API規(guī)范通常將此類實體稱之為監(jiān)視器，內部鎖有兩個至關重要的作用

• 強制對對象狀態(tài)的獨占訪問
• 建立至關重要的happens-before關系

每個對象都有與其關聯(lián)的固有鎖，通常，需要對對象的字段進行獨占且一致的訪問前需要獲取對象的內部鎖，然后再使用完成時釋放內部鎖，線程在獲取后釋放前擁有該對象的內部鎖。只要線程擁有了內部鎖其他任何線程都無法獲取相同的鎖，其他線程在嘗試獲取鎖時將被阻塞。在線程釋放內部鎖時，該操作將會在該對象的任何后續(xù)操作間建立happens-before關系。

4.1 同步方法中的鎖

當線程調用同步方法時，線程會自動獲得該方法所屬對象得內部鎖，并且在方法返回時自動釋放，即使返回是由未捕獲異常導致。靜態(tài)同步方法的鎖不同于實例方法的鎖，靜態(tài)方法是圍繞該類進行控制而非該類的某一個實例。

4.2 同步語句

另外一個提供同步的方法是同步代語句，與同步方法不同的是，同步語句必須指定一個對象來提供內部鎖。

public class IntrinsicLock {
  private List<String> nameList = new LinkedList<String>();
  private String lastName;
  private int nameCount;

  public void addName(String name) {
    // 當多條線程對同一個實例對象的addName()方法操作時將會是同步的，提供鎖的對象為該實例對象本身
    synchronized(this) {
      lastName = name;
      nameCount++;
    }
    nameList.add(name);
  }
}

同步語句對細粒度同步提高并發(fā)性也很有用，比如我們需要對同一個對象的不同屬性進行同步修改我們可以通過如下代碼來提高細粒度同步控制下的并發(fā)。

public class IntrinsicLock {
  // 1. 該屬性需要基于同步的修改
  private String lastName;
  // 1. 該屬性也需要基于同步的修改
  private int count;
  
  // 該對象用于對lastName提供內部鎖
  private Object nameLock = new Object();
  // 該對象用于對nameCount提供內部鎖
  private Object countLock = new Object();
  
  public void addName(String name) {
    synchronized(nameLock) {
      lastName = name;
    }
  }
  public void increment() {
    synchronized(countLock) {
      count++;
    }
  }
}

這樣，對lastName的操作不會阻塞count屬性的自增操作，因為他們分別使用了不同的對象來提供鎖。若像上一個例子中使用this來提供鎖的話，則在調用addName()方法時increment()也被阻塞，反之亦然，這樣將會增加不必要的阻塞。

4.3 可重入同步

線程無法獲取另外一個線程已經擁有的鎖，但是線程可以多次獲取它已經擁有的鎖，允許線程多次獲取同一鎖可以實現可重入的同步，即同步方法或者同步代碼塊中又調用了由同一個對象提供鎖的其他同步方法時，該鎖可以多次被獲取

public class IntrinsicLock {
  private int count;
  public void decrement(String name) {
    synchronized(this) {
      count--;
      // 調用其他由同一個對象提供鎖的同步方法時，鎖可以重復獲取
      // 但只能由當前有用鎖的線程重復獲取
      increment();
    }
  }
  public void increment() {
    synchronized(this) {
      count++;
    }
  }
}

4.4 原子訪問

在編程中，原子操作指的是指所有操作一行性完成，原子操作不可能執(zhí)行一半，要么全都執(zhí)行，要么都不執(zhí)行。在原子操作完成之前，其修改都是不可見的。在Java中以下操作是原子性的。

• 讀寫大部分原始變量（除了long和double）
• 讀寫所有使用volatile聲明的變量
  

原子操作的特性使得我們不必擔心線程干擾帶來的同步問題，但是原子操作依然會發(fā)生內存一致性錯誤。需要使用volatile聲明變量以有效防止內存一致性錯誤，因為寫volatile標記的變量時會與讀取該變量的后續(xù)操作建立happens-before關系，所以改變使用volatile標記變量時對其他線程總是可見的。也就是它不僅可以觀測最新的改變，也能觀測到尚未使其改變的操作。

5. 死鎖

死鎖是描述一種兩條或多條線程相互等待（阻塞）的場景，如下例子所示

public class DeadLock {
  static class Friend {
    String name;
    public Friend(String name) {
      super();
      this.name = name;
    }
    public String getName() {
      return name;
    }
    public synchronized void call(Friend friend) {
      System.out.println(String.format("%s被%s呼叫...", name,friend.getName()));
      friend.callBack(this);
    }
    public synchronized void callBack(Friend friend) {
      System.out.println(String.format("%s呼叫%s...", friend.getName(),name));
    }
  }
  
  public static void main(String args[]) {
    final Friend zhangSan = new Friend("張三");
    final Friend liSi = new Friend("李四");
    new Thread(new Runnable() {
      public void run() { zhangSan.call(liSi); }
    }).start();
    new Thread(new Runnable() {
      public void run() { liSi.call(zhangSan); }
    }).start();
  }
}

如果張三呼叫李四的同時，李四呼叫張三，那么他們會永遠等待對方，線程永遠阻塞。

6. 饑餓和活鎖

相對死鎖而言，饑餓和活鎖問題要少得多，但是也應注意。

6.1 饑餓

饑餓是一種描述線程無法定期訪問共享資源，程序無法取得正常執(zhí)行的一種場景，比如一個同步方法執(zhí)行時間很長，但是多條線程爭搶且頻繁的執(zhí)行，那么將會有大量線程無法在正常的情況下獲得使用權，造成大量阻塞和積壓，我們使用饑餓來描述這種并發(fā)場景。

6.2 活鎖

活鎖是一種描述線程在執(zhí)行同步方法的過程中依賴其他外部資源，而該部分獲取緩慢而無保障造成無法進一步執(zhí)行的的場景，相對于死鎖，活鎖是有機會進一步執(zhí)行的，只是執(zhí)行過程緩慢，造成部分資源被 正在等待其他資源的線程占用。

7. 保護塊/守護塊

通常，線程會根據其需要來協(xié)調其操作。最常用的協(xié)調方式便是通過守護塊的方式，用一個代碼塊來輪詢一個一條件，只有到該條件滿足時，程序才繼續(xù)執(zhí)行。要實現這個功能通常有幾個要遵循的步驟，先給出一個并不是那么好的例子請勿在生產代碼使用以下示例

public void guardedJoy() {
  // 這是一個簡單的輪詢守護塊，但是極其消耗資源
  // 請勿在生產環(huán)境中使用此類代碼，這是一個不好的示例
  while(!joy) {}
  System.out.println("Joy has been achieved!");
}

這個例子中，只有當別的線程講joy變量設置為true時，程序才會繼續(xù)往下執(zhí)行，在理論上該方法確實能實現守護的功能，利用簡單的輪詢，一直等待條件滿足后，才繼續(xù)往下執(zhí)行，這是這種輪詢方式是極其消耗資源的，因為輪詢會一直占用CPU資源。別的線程便無法獲得CPU進行處理。

一個更為有效的守護方式是調用Object.wait方法來暫停線程執(zhí)行，暫停后線程會被阻塞，讓出CPU時間片給其他線程使用，直到其他線程發(fā)出一個某些條件已經滿足的通知事件后，該線程會被喚醒重新執(zhí)行，即使其他線程完成的條件并非它等的哪一個條件。更改上面的代碼

public synchronized void guardedJoy() {
  // 正確的例子,該守護快每次被其他線程喚醒之后只會輪詢一次，
  while(!joy) {
    try{
      wait();
    }catch(Exception e) {}
  }
  System.out.println("Joy has been achieved!");
}

為什么這個版本的守護塊需要同步的？假設d是一個我們調用wait方法的對象，當線程調用d.wait()方法時線程必須擁有對象d的內部鎖，否則將會拋出異常。在一個同步方法內部調用wait()方法是一個簡單的獲取對象內部鎖的方式。當wait()方法被調用后，當前線程會釋放內部鎖并暫停執(zhí)行，在將來的某一刻，其他線程將會獲得d的內部鎖，并調用d.notifyAll()方法，來喚醒由對象d.wait()方法暫停執(zhí)行的線程。

public synchronized notifyJoy() {
  joy = true;
  // 喚醒所有被wait()方法暫停的線程
  notifyAll();
}

以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持腳本之家。

最新評論