詳解Java多線程編程中的線程同步方法

更新時間：2016年05月10日 08:59:48 作者：arthinking

這篇文章主要介紹了Java多線程編程中的線程同步方法,使用synchronized關鍵字創(chuàng)建線程同步方法是實現(xiàn)線程同步的關鍵,需要的朋友可以參考下

1、多線程的同步：
1.1、同步機制：
在多線程中，可能有多個線程試圖訪問一個有限的資源，必須預防這種情況的發(fā)生。所以引入了同步機制：在線程使用一個資源時為其加鎖，這樣其他的線程便不能訪問那個資源了，直到解鎖后才可以訪問。

1.2、共享成員變量的例子：
成員變量與局部變量：
成員變量：

如果一個變量是成員變量，那么多個線程對同一個對象的成員變量進行操作，這多個線程是共享一個成員變量的。

局部變量：

如果一個變量是局部變量，那么多個線程對同一個對象進行操作，每個線程都會有一個該局部變量的拷貝。他們之間的局部變量互不影響。

下面舉例說明：
實現(xiàn)了Runnable的線程類：

class MyThread3 implements Runnable{

 //兩個線程操作同一個對象，共享成員變量
 //int i;
 @Override
 public void run() {
  //兩個線程操作同一個對象，各自保存局部變量的拷貝
  int i = 0;
  while(i<100){
   System.out.println(i);
   i++;
   try {
    Thread.sleep(100);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
  }
 }
}

在main方法中用兩個線程操作同一個對象：

public static void main(String[] args) {

 MyThread3 myThread = new MyThread3();
 //下面兩個線程對同一個對象(Runnable的實現(xiàn)類對象)進行操作
 Thread thread = new Thread(myThread);
 Thread thread2 = new Thread(myThread);
 //各自保存局部變量的拷貝，互不影響，輸出200個數(shù)字
 thread.start();
 thread2.start();
}

這里如果把i變成成員變量，則輸出100個數(shù)字。

1.3、共享資源導致的讀取錯誤
下面舉個例子，兩個線程共用一個Number對象，通過Number類的getNumber方法獲取數(shù)據(jù)，讀取數(shù)據(jù)并改寫時，發(fā)現(xiàn)了重復讀操作：

首先創(chuàng)建一個Number類：

class Number{
 private int number = 10;
 public String getNumber(int i){
  if(number > 0){
   try {
    Thread.sleep(100);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   number -= i;
   return "取出"+i+"成功，剩余數(shù)量："+number;
  }
  return "取出"+i+"失敗，剩余數(shù)量："+number;
 }
}

線程類，在線程類中的私有屬性包含了Number類的引用：

class MyThread4 extends Thread{

 //兩個線程操作同一個對象，共享成員變量
 Number number;
 public MyThread4(Number number){
  this.number = number;
 }
 @Override
 public void run() {
  System.out.println(number.getNumber(8));
 }
}

在main函數(shù)中創(chuàng)建兩個線程類，包含了同一個Number類實例的引用：

public static void main(String[] args) {

 Number number = new Number();
 //兩個線程操作同一個對象，共享對象number的成員變量number
 MyThread4 myThread = new MyThread4(number);
 MyThread4 myThread2 = new MyThread4(number);
 myThread.start();
 myThread2.start();
}

這樣，當?shù)谝粋€線程讀取Number中的number變量時先保存下來再休眠0.1秒，然后第二個線程再讀取number變量并保存，此時兩個線程保存了同樣的數(shù)字，在修改時，也就導致修改了同一個數(shù)字兩次。

2、同步機制的實現(xiàn)：

在多線程并發(fā)編程中Synchronized一直是元老級角色，很多人都會稱呼它為重量級鎖，但是隨著Java SE1.6對Synchronized進行了各種優(yōu)化之后，有些情況下它并不那么重了”
Java中的每一個對象都可以作為鎖。

對于同步方法，鎖是當前實例對象。
對于靜態(tài)同步方法，鎖是當前對象的Class對象。
對于同步方法塊，鎖是Synchonized括號里配置的對象。
當一個線程試圖訪問同步代碼塊時，它首先必須得到鎖，退出或拋出異常時必須釋放鎖。
2.1、使用synchronized關鍵字創(chuàng)建synchronized方法：
使用synchronized關鍵字，該關鍵字修飾的方法叫做同步方法。

Java中每個對象都有一個鎖或者稱為監(jiān)視器，當訪問某個對象的synchronized方法時，表示將該對象上鎖，而不僅僅是為該方法上鎖。

這樣如果一個對象的synchronized方法被某個線程執(zhí)行時，其他線程無法訪問該對象的任何synchronized方法（但是可以調用其他非synchronized的方法）。直至該synchronized方法執(zhí)行完。

靜態(tài)的synchronized方法調用情況：
當調用一個對象的靜態(tài)synchronized方法時，它鎖定的并不是synchronized方法所在的對象，而是synchronized方法所在對象對應的Class對象。這樣，其他線程就不能調用該類的其他靜態(tài)synchronized方法了，但是可以調用非靜態(tài)的synchronized方法。

結論：執(zhí)行靜態(tài)synchronized方法鎖方法所在對象，執(zhí)行非靜態(tài)synchronized方法鎖方法所在對象對應的Class對象。

下面是多線程調用靜態(tài)的方法的例子，由于鎖定了方法所在對象對應的Class對象，其他線程無法調用該方法所在對象其他的靜態(tài)synchronized方法：

/**
 * 定義一個類，包含了線程類需要調用的方法
 */
class Compute1{
 //這時如果某個線程調用該方法，
 //將鎖定synchronized方法所在對象對應的class對象，
 //而不是鎖定synchronized方法所在對象
 public synchronized static void execute(){
  for(int i = 0; i<100; i++){
   try {
    Thread.sleep(100);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   System.out.println("compute1:execute1 " + i++);
  }
 }
 public synchronized static void execute2(){
  for(int i = 0; i<100; i++){
   try {
    Thread.sleep(100);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   System.out.println("compute1:execute2 " + i++);
  }
 }
}

main方法中兩個線程分別調用同一個對象的兩個static synchronized方法：

public static void main(String[] args) {
 Compute1 com = new Compute1();
 Thread thread1 = new Thread1(com);
 Thread thread2 = new Thread2(com);
 thread1.start();
 thread2.start();
}

一次只能調用一個靜態(tài)方法，直到執(zhí)行完成。

2.2、使用synchronized創(chuàng)建同步代碼塊：
通過使用synchronized同步代碼塊，鎖定一個對象，該對象作為可執(zhí)行的標志從而達到同步的效果：

/**
 * 定義一個類，包含了線程類需要調用的方法
 */
class Compute1{
 //通過同步代碼塊鎖定object1對象進行鎖定了其他同樣的synchronized代碼塊
 private Object object1 = new Object();
 public void execute(){
  synchronized(object1){
   for(int i = 0; i<100; i++){
    try {
     Thread.sleep(100);
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
    System.out.println("compute1:execute1 " + i++);
   }
  }

 }
 public synchronized void execute2(){
  synchronized(object1){
   for(int i = 0; i<100; i++){
    try {
     Thread.sleep(100);
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
    System.out.println("compute1:execute2 " + i++);
   }
  }
 }
}

如果想要使用synchronized同步代碼塊達到和使用synchronized方法同樣的效果，可以鎖定this引用：