進程和線程

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

1. 進程

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

2. 線程

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

線程生命周期

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

1、新建狀態(tài)

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

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

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

3、運行狀態(tài)

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

4、阻塞狀態(tài)

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

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

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

5、終止狀態(tài)

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

線程對象

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

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

1. 定義和開始一條線程

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

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

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

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

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!!!");
  }
}

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

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

sleep()方法會使線程進入阻塞隊列，進入阻塞隊列后，線程會將CPU時間片讓給其他線程執(zhí)行，sleep()有兩個重載方法sleep(long millis)和sleep(long millis, int nanos)當(dāng)?shù)搅酥付ǖ男菝邥r間后，線程將會重新進入就緒隊列等待調(diào)度管理器進行調(diào)度

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

3. 中斷

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

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

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

4. Join

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

線程同步 Synchronization

各線通信方式

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

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

1. 線程干擾 Thread Interference

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

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í)行結(jié)果：%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次最終結(jié)果應(yīng)該是0 ，但實際結(jié)果卻是每次運行結(jié)果都不一致，產(chǎn)生這個結(jié)果的原因便是線程之間相互干擾。

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

• 獲取count變量當(dāng)前值
• 自增/自減 獲取到的值
• 將結(jié)果保存回count變量

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

• 線程A : 獲取count
• 線程B : 獲取count
• 線程A: 自增，結(jié)果 為 1
• 線程B: 自減，結(jié)果為 -1
• 線程A: 將結(jié)果1 保存到count; 當(dāng)前count = 1
• 線程B: 將結(jié)果-1 保存到count; 當(dāng)前count = -1

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

2. 內(nèi)存一致性錯誤 Memory Consistency Errors

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

3. 同步方法

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

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;
  }
}

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

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

4. 內(nèi)部鎖和同步

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

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

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

4.1 同步方法中的鎖

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

4.2 同步語句

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

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

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

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

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

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

4.3 可重入同步

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

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

4.4 原子訪問

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

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

原子操作的特性使得我們不必擔(dān)心線程干擾帶來的同步問題，但是原子操作依然會發(fā)生內(nèi)存一致性錯誤。需要使用volatile聲明變量以有效防止內(nèi)存一致性錯誤，因為寫volatile標記的變量時會與讀取該變量的后續(xù)操作建立happens-before關(guān)系，所以改變使用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. 饑餓和活鎖

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

6.1 饑餓

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

6.2 活鎖

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

7. 保護塊/守護塊

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

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

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

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

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

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

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

以上就是本文的全部內(nèi)容，希望對大家的學(xué)習(xí)有所幫助，也希望大家多多支持腳本之家。

最新評論