欧美bbbwbbbw肥妇,免费乱码人妻系列日韩,一级黄片

Java 多線程synchronized關(guān)鍵字詳解(六)

 更新時間：2015年12月29日 15:03:03   作者：呵呵噠_蕭大大  
這篇文章主要介紹了Java 多線程synchronized關(guān)鍵字詳解(六)的相關(guān)資料,需要的朋友可以參考下

synchronized 關(guān)鍵字，代表這個方法加鎖,相當(dāng)于不管哪一個線程（例如線程A），運行到這個方法時,都要檢查有沒有其它線程B（或者C、 D等）正在用這個方法(或者該類的其他同步方法)，有的話要等正在使用synchronized方法的線程B（或者C 、D）運行完這個方法后再運行此線程A,沒有的話,鎖定調(diào)用者,然后直接運行。它包括兩種用法：synchronized 方法和 synchronized 塊。

多線程的同步機(jī)制對資源進(jìn)行加鎖，使得在同一個時間，只有一個線程可以進(jìn)行操作，同步用以解決多個線程同時訪問時可能出現(xiàn)的問題。

　　同步機(jī)制可以使用synchronized關(guān)鍵字實現(xiàn)。

　　當(dāng)synchronized關(guān)鍵字修飾一個方法的時候，該方法叫做同步方法。

　　當(dāng)synchronized方法執(zhí)行完或發(fā)生異常時，會自動釋放鎖。

　　下面通過一個例子來對synchronized關(guān)鍵字的用法進(jìn)行解析?！　?br />

1.是否使用synchronized關(guān)鍵字的不同

例子程序1

public class ThreadTest
　　{
　　　　public static void main(String[] args)
　　　　{
　　　　　　Example example = new Example();
　　　　　　Thread t1 = new Thread1(example);
　　　　　　Thread t2 = new Thread1(example);
　　　　　　t1.start();
　　　　　　t2.start();
　　　　}
　　}
　　class Example
　　{
　　　　public synchronized void execute()
　　　　{
　　　　　　for (int i = 0; i < 10; ++i)
　　　　　　{
　　　　　　　　try
　　　　　　　　{
　　　　　　　　　　Thread.sleep(500);
　　　　　　　　}
　　　　　　　　catch (InterruptedException e)
　　　　　　　　{
　　　　　　　　　　e.printStackTrace();
　　　　　　　　}
　　　　　　　　System.out.println("Hello: " + i);
　　　　　　}
　　　　}
　　}
　　class Thread1 extends Thread
　　{
　　　　private Example example;
　　　　public Thread1(Example example)
　　　　{
　　　　　　this.example = example;
　　　　}
　　　　@Override
　　　　public void run()
　　　　{
　　　　　　example.execute();
　　　　}
　　}

　　是否在execute()方法前加上synchronized關(guān)鍵字，這個例子程序的執(zhí)行結(jié)果會有很大的不同。

　　如果不加synchronized關(guān)鍵字，則兩個線程同時執(zhí)行execute()方法，輸出是兩組并發(fā)的。

　　如果加上synchronized關(guān)鍵字，則會先輸出一組0到9，然后再輸出下一組，說明兩個線程是順次執(zhí)行的。

2.多個方法的多線程情況

　　將程序改動一下，Example類中再加入一個方法execute2()。

　　之后再寫一個線程類Thread2，Thread2中的run()方法執(zhí)行的是execute2()。Example類中的兩個方法都是被synchronized關(guān)鍵字修飾的。

例子程序2

 public class ThreadTest
{
  public static void main(String[] args)
  {
    Example example = new Example();
    Thread t1 = new Thread1(example);
    Thread t2 = new Thread2(example);
    t1.start();
    t2.start();
  }
}
class Example
{
  public synchronized void execute()
  {
    for (int i = 0; i < 20; ++i)
    {
      try
      {
        Thread.sleep((long) Math.random() * 1000);
      }
      catch (InterruptedException e)
      {
        e.printStackTrace();
      }
      System.out.println("Hello: " + i);
    }
  }
  public synchronized void execute2()
  {
    for (int i = 0; i < 20; ++i)
    {
      try
      {
        Thread.sleep((long) Math.random() * 1000);
      }
      catch (InterruptedException e)
      {
        e.printStackTrace();
      }
      System.out.println("World: " + i);
    }
  }
}
class Thread1 extends Thread
{
  private Example example;
  public Thread1(Example example)
  {
    this.example = example;
  }
  @Override
  public void run()
  {
    example.execute();
  }
}
class Thread2 extends Thread
{
  private Example example;
  public Thread2(Example example)
  {
    this.example = example;
  }
  @Override
  public void run()
  {
    example.execute2();
  }
}

 　　如果去掉synchronized關(guān)鍵字，則兩個方法并發(fā)執(zhí)行，并沒有相互影響。

　　但是如例子程序中所寫，即便是兩個方法：

　　執(zhí)行結(jié)果永遠(yuǎn)是執(zhí)行完一個線程的輸出再執(zhí)行另一個線程的?！　?br />

　　說明：

　　如果一個對象有多個synchronized方法，某一時刻某個線程已經(jīng)進(jìn)入到了某個synchronized方法，那么在該方法沒有執(zhí)行完畢前，其他線程是無法訪問該對象的任何synchronized方法的。

　　結(jié)論：

　　當(dāng)synchronized關(guān)鍵字修飾一個方法的時候，該方法叫做同步方法。

　　Java中的每個對象都有一個鎖（lock），或者叫做監(jiān)視器（monitor），當(dāng)一個線程訪問某個對象的synchronized方法時，將該對象上鎖，其他任何線程都無法再去訪問該對象的synchronized方法了（這里是指所有的同步方法，而不僅僅是同一個方法），直到之前的那個線程執(zhí)行方法完畢后（或者是拋出了異常），才將該對象的鎖釋放掉，其他線程才有可能再去訪問該對象的synchronized方法。

　　注意這時候是給對象上鎖，如果是不同的對象，則各個對象之間沒有限制關(guān)系。

　　嘗試在代碼中構(gòu)造第二個線程對象時傳入一個新的Example對象，則兩個線程的執(zhí)行之間沒有什么制約關(guān)系。

3.考慮靜態(tài)的同步方法

　　當(dāng)一個synchronized關(guān)鍵字修飾的方法同時又被static修飾，之前說過，非靜態(tài)的同步方法會將對象上鎖，但是靜態(tài)方法不屬于對象，而是屬于類，它會將這個方法所在的類的Class對象上鎖。

　　一個類不管生成多少個對象，它們所對應(yīng)的是同一個Class對象。

例子程序3

 public class ThreadTest
{
  public static void main(String[] args)
  {
    Example example = new Example();
    Thread t1 = new Thread1(example);
    // 此處即便傳入不同的對象，靜態(tài)方法同步仍然不允許多個線程同時執(zhí)行
    example = new Example();
    Thread t2 = new Thread2(example);
    t1.start();
    t2.start();
  }
}
class Example
{
  public synchronized static void execute()
  {
    for (int i = 0; i < 20; ++i)
    {
      try
      {
        Thread.sleep((long) Math.random() * 1000);
      }
      catch (InterruptedException e)
      {
        e.printStackTrace();
      }
      System.out.println("Hello: " + i);
    }
  }
  public synchronized static void execute2()
  {
    for (int i = 0; i < 20; ++i)
    {
      try
      {
        Thread.sleep((long) Math.random() * 1000);
      }
      catch (InterruptedException e)
      {
        e.printStackTrace();
      }
      System.out.println("World: " + i);
    }
  }
}
class Thread1 extends Thread
{
  private Example example;
  public Thread1(Example example)
  {
    this.example = example;
  }
  @Override
  public void run()
  {
    Example.execute();
  }
}
class Thread2 extends Thread
{
  private Example example;
  public Thread2(Example example)
  {
    this.example = example;
  }
  @Override
  public void run()
  {
    Example.execute2();
  }
}

　　所以如果是靜態(tài)方法的情況（execute()和execute2()都加上static關(guān)鍵字），即便是向兩個線程傳入不同的Example對象，這兩個線程仍然是互相制約的，必須先執(zhí)行完一個，再執(zhí)行下一個。

　　結(jié)論：

　　如果某個synchronized方法是static的，那么當(dāng)線程訪問該方法時，它鎖的并不是synchronized方法所在的對象，而是synchronized方法所在的類所對應(yīng)的Class對象。Java中，無論一個類有多少個對象，這些對象會對應(yīng)唯一一個Class對象，因此當(dāng)線程分別訪問同一個類的兩個對象的兩個static，synchronized方法時，它們的執(zhí)行順序也是順序的，也就是說一個線程先去執(zhí)行方法，執(zhí)行完畢后另一個線程才開始。

4. synchronized塊

　　synchronized塊寫法：

　　synchronized(object)
　　{　   
　　}

　　表示線程在執(zhí)行的時候會將object對象上鎖。（注意這個對象可以是任意類的對象，也可以使用this關(guān)鍵字）。

　　這樣就可以自行規(guī)定上鎖對象?！?/p>

例子程序4

 public class ThreadTest
{
  public static void main(String[] args)
  {
    Example example = new Example();
    Thread t1 = new Thread1(example);
    Thread t2 = new Thread2(example);
    t1.start();
    t2.start();
  }
}
class Example
{
  private Object object = new Object();
  public void execute()
  {
    synchronized (object)
    {
      for (int i = 0; i < 20; ++i)
      {
        try
        {
          Thread.sleep((long) Math.random() * 1000);
        }
        catch (InterruptedException e)
        {
          e.printStackTrace();
        }
        System.out.println("Hello: " + i);
      }
    }
  }
  public void execute2()
  {
    synchronized (object)
    {
      for (int i = 0; i < 20; ++i)
      {
        try
        {
          Thread.sleep((long) Math.random() * 1000);
        }
        catch (InterruptedException e)
        {
          e.printStackTrace();
        }
        System.out.println("World: " + i);
      }
    }
  }
}
class Thread1 extends Thread
{
  private Example example;
  public Thread1(Example example)
  {
    this.example = example;
  }
  @Override
  public void run()
  {
    example.execute();
  }
}
class Thread2 extends Thread
{
  private Example example;
  public Thread2(Example example)
  {
    this.example = example;
  }
  @Override
  public void run()
  {
    example.execute2();
  }
}

　　例子程序4所達(dá)到的效果和例子程序2的效果一樣，都是使得兩個線程的執(zhí)行順序進(jìn)行，而不是并發(fā)進(jìn)行，當(dāng)一個線程執(zhí)行時，將object對象鎖住，另一個線程就不能執(zhí)行對應(yīng)的塊。

　　synchronized方法實際上等同于用一個synchronized塊包住方法中的所有語句，然后在synchronized塊的括號中傳入this關(guān)鍵字。當(dāng)然，如果是靜態(tài)方法，需要鎖定的則是class對象。

　　可能一個方法中只有幾行代碼會涉及到線程同步問題，所以synchronized塊比synchronized方法更加細(xì)粒度地控制了多個線程的訪問，只有synchronized塊中的內(nèi)容不能同時被多個線程所訪問，方法中的其他語句仍然可以同時被多個線程所訪問（包括synchronized塊之前的和之后的）。

　　注意：被synchronized保護(hù)的數(shù)據(jù)應(yīng)該是私有的。

　　結(jié)論：

　　synchronized方法是一種粗粒度的并發(fā)控制，某一時刻，只能有一個線程執(zhí)行該synchronized方法；

　　synchronized塊則是一種細(xì)粒度的并發(fā)控制，只會將塊中的代碼同步，位于方法內(nèi)、synchronized塊之外的其他代碼是可以被多個線程同時訪問到的。

相關(guān)文章

最新評論