Java如何實作多執行緒編程

1、在建構函式中啟動線程

我在很多程式碼中都看到這樣的問題，在建構函式中啟動一個線程，類似這樣：

public class A{     public A(){        this.x=1;        this.y=2;        this.thread=new MyThread();        this.thread.start();     }       }

這個會造成什麼問題呢？如果有個類別B繼承了類別A，依據java類別初始化的順序，A的建構子一定會在B的建構子呼叫前被調用，那麼thread執行緒​​也會在B被完全初始化之前啟動，當thread執行時使用到了類別A中的某些變量，那麼就可能使用的不是你預期中的值，因為在B的建構子中你可能賦給這些變數新的值。也就是說此時將有兩個執行緒在使用這些變量，而這些變數卻沒有同步。

解決這個問題有兩個方法：將A設為final，不可繼承；或提供單獨的start方法用來啟動線程，而不是放在建構函式中。

2、不完全的同步

都知道對變數同步的有效方式是用synchronized保護起來，synchronized可能是物件鎖，也可能是類別鎖，看你是類別方法還是實例方法。但是，當你將某個變數在A方法中同步，那麼在變數出現的其他地方，你也需要同步，除非你允許弱可見性甚至產生錯誤值。類似這樣的程式碼：

class A{    int x;    public int getX(){       return x;    }    public synchronized void setX(int x)    {       this.x=x;    }  }

x的setter方法有同步，然而getter方法卻沒有，那麼就無法保證其他執行緒透過getX得到的x是***的值。事實上，這裡的setX的同步是沒有必要的，因為對int的寫入是原子的，這一點JVM規範已經保證，多個同步沒有任何意義；當然，如果這裡不是int，而是double或者long，那麼getX和setX都將需要同步，因為double和long都是64位，寫入和讀取都是分成兩個32位來進行(這一點取決於jvm的實現，有的jvm實現可能保證對long和double的read、write是原子的），沒有保證原子性。類似上面這樣的程式碼，其實都可以透過宣告變數為volatile來解決。

3、在使用某個物件當鎖時，改變了物件的引用，導致同步失效。

這也是很常見的錯誤，類似下面的程式碼：

synchronized(array[0])  {     ......     array[0]=new A();     ......  }

同步區塊使用array[0]作為鎖，然而在同步區塊中改變了array[0]指向的引用。分析下這個場景，***個線程獲取了array[0]的鎖，第二個線程因為無法獲取array[0]而等待，在改變了array[0]的引用後，第三個線程獲取了新的array[0]的鎖，***和第三兩個執行緒所持有的鎖是不一樣的，同步互斥的目的就完全沒有達到了。這樣程式碼的修改，通常是將鎖宣告為final變數或引入業務無關的鎖對象，保證在同步區塊內不會被修改引用。

4、沒有在迴圈中呼叫wait()。

wait和notify用於實現條件變量，你可能知道需要在同步區塊中呼叫wait和notify，為了保證條件的改變能做到原子性和可見性。常常看見很多程式碼做到了同步，卻沒有在迴圈中呼叫wait，而是使用if甚至沒有條件判斷：

synchronized(lock)  {     if(isEmpty()       lock.wait();       }

對條件的判斷是使用if，這會造成什麼問題呢？在判斷條件之前可能會呼叫notify或notifyAll，那麼條件已經滿足，不會等待，這沒什麼問題。在條件沒有滿足，呼叫了wait()方法，釋放lock鎖定並進入等待休眠狀態。如果執行緒是在正常情況下，也就是條件被改變之後被喚醒，那麼沒有任何問題，條件滿足繼續執行下面的邏輯操作。問題在於執行緒可能被意外甚至惡意喚醒，由於沒有再次進行條件判斷，在條件沒有被滿足的情況下，執行緒執行了後續的操作。意外喚醒的情況，可能是呼叫了notifyAll，可能是有人惡意喚醒，也可能是很少情況下的自動甦醒（稱為「偽喚醒」)。因此為了防止這種條件沒有滿足就執行後續操作的情況，需要在被喚醒後再次判斷條件，如果條件不滿足，繼續進入等待狀態，條件滿足，才進行後續操作。

synchronized(lock)  {     while(isEmpty()       lock.wait();       }

沒有進行條件判斷就調用wait的情況更嚴重，因為在等待之前可能notify已經被調用，那麼在調用了wait之後進入等待休眠狀態後就無法保證線程甦醒過來。

5、同步的範圍太小或過大。

同步的範圍太小，可能完全沒有達到同步的目的；同步的範圍太大，可能會影響效能。同步範圍過小的常見例子是誤認為兩個同步的方法一起呼叫也是將同步的，需要記住的是Atomic Atomic!=Atomic。

Map map=Collections.synchronizedMap(new HashMap());  if(!map.containsKey("a")){           map.put("a", value);  }

这是一个很典型的错误，map是线程安全的，containskey和put方法也是线程安全的，然而两个线程安全的方法被组合调用就不一定是线程安全的了。因为在containsKey和put之间，可能有其他线程抢先put进了a，那么就可能覆盖了其他线程设置的值，导致值的丢失。解决这一问题的方法就是扩大同步范围，因为对象锁是可重入的，因此在线程安全方法之上再同步相同的锁对象不会有问题。

Map map = Collections.synchronizedMap(new HashMap());  synchronized (map) {       if (!map.containsKey("a")) {           map.put("a", value);       }   }

注意，加大锁的范围，也要保证使用的是同一个锁，不然很可能造成死锁。 Collections.synchronizedMap(new HashMap())使用的锁是map本身，因此没有问题。当然，上面的情况现在更推荐使用ConcurrentHashMap，它有putIfAbsent方法来达到同样的目的并且满足线程安全性。

同步范围过大的例子也很多，比如在同步块中new大对象，或者调用费时的IO操作（操作数据库，webservice等）。不得不调用费时操作的时候，一定要指定超时时间，例如通过URLConnection去invoke某个URL时就要设置connect timeout和read timeout，防止锁被独占不释放。同步范围过大的情况下，要在保证线程安全的前提下，将不必要同步的操作从同步块中移出。

6、正确使用volatile

在jdk5修正了volatile的语义后，volatile作为一种轻量级的同步策略就得到了大量的使用。volatile的严格定义参考jvm spec，这里只从volatile能做什么，和不能用来做什么出发做个探讨。

volatile可以用来做什么？

1）状态标志，模拟控制机制。常见用途如控制线程是否停止：

private volatile boolean stopped;  public void close(){     stopped=true;  }   public void run(){      while(!stopped){        //do something     }       }

前提是do something中不会有阻塞调用之类。volatile保证stopped变量的可见性，run方法中读取stopped变量总是main memory中的***值。

2）安全发布，如修复DLC问题。

private volatile IoBufferAllocator instance;  public IoBufferAllocator getInsntace(){      if(instance==null){          synchronized (IoBufferAllocator.class) {              if(instance==null)                  instance=new IoBufferAllocator();          }      }      return instance;  }

3）开销较低的读写锁

public class CheesyCounter {      private volatile int value;       public int getValue() { return value; }       public synchronized int increment() {          return value++;      }  }

synchronized保证更新的原子性，volatile保证线程间的可见性。

volatile不能用于做什么？

1）不能用于做计数器

public class CheesyCounter {      private volatile int value;       public int getValue() { return value; }       public int increment() {          return value++;      }  }

因为value++其实是有三个操作组成的：读取、修改、写入，volatile不能保证这个序列是原子的。对value的修改操作依赖于value的***值。解决这个问题的方法可以将increment方法同步，或者使用AtomicInteger原子类。

2）与其他变量构成不变式

一个典型的例子是定义一个数据范围，需要保证约束lower< upper。

public class NumberRange {      private volatile int lower, upper;       public int getLower() { return lower; }      public int getUpper() { return upper; }       public void setLower(int value) {           if (value > upper)               throw new IllegalArgumentException();          lower = value;      }       public void setUpper(int value) {           if (value < lower)               throw new IllegalArgumentException();          upper = value;      }  }

尽管讲lower和upper声明为volatile，但是setLower和setUpper并不是线程安全方法。假设初始状态为(0,5)，同时调用setLower(4)和setUpper(3)，两个线程交叉进行，***结果可能是(4,3)，违反了约束条件。修改这个问题的办法就是将setLower和setUpper同步：

public class NumberRange {      private volatile int lower, upper;       public int getLower() { return lower; }      public int getUpper() { return upper; }       public synchronized void setLower(int value) {           if (value > upper)               throw new IllegalArgumentException();          lower = value;      }       public synchronized void setUpper(int value) {           if (value < lower)               throw new IllegalArgumentException();          upper = value;      }  }
以上是Java如何實作多執行緒編程的詳細內容。更多資訊請關注PHP中文網其他相關文章！