Java鎖Synchronized，對象鎖和類鎖舉例

　Java的鎖分為對象鎖和類鎖。

　　1. 當兩個並發線程訪問同一個對象object中的這個synchronized(this)同步代碼塊時，一個時間內針對該對象的操作只能有一個線程得到執行。另一個線程必須等待當前線程執行完這個代碼塊以后才能執行該代碼塊。

　　2. 然而，另一個線程仍然可以訪問該object中的非synchronized(this)同步代碼塊。

　　3. 尤其關鍵的是，當一個線程訪問object的一個synchronized(this)同步代碼塊時，其他線程對該object中所有其它synchronized(this)同步代碼塊的訪問將被阻塞。

　　4. 同步加鎖的是對象，而不是代碼。因此，如果你的類中有一個同步方法，這個方法可以被兩個不同的線程同時執行，只要每個線程自己創建一個的該類的實例即可。

　　5. 不同的對象實例的synchronized方法是不相干擾的。也就是說，其它線程照樣可以同時訪問相同類的另一個對象實例中的synchronized方法。

　　6. synchronized關鍵字是不能繼承的，也就是說，基類的方法synchronized f(){} 在繼承類中並不自動是synchronized f(){}，而是變成了f(){}。繼承類需要你顯式的指定它的某個方法為synchronized方法。

　　7.對一個全局對象或者類加鎖時，對該類的所有對象都起作用。

類鎖舉例

對一個全局變量加鎖：

 1 public class MySynchronized extends Thread
 2 {
 3     private int val;
 4     
 5     private static Object lock = new Object();
 6     
 7     public MySynchronized(int v)
 8     {
 9         val = v;
10     }
11     
12     public void printVal(int v)
13     {
14         synchronized (lock)
15         {
16             while (true)
17             {
18                 System.out.println(v);
19             }
20         }
21     }
22     
23     public void run()
24     {
25         printVal(val);
26     }
27 }

　　對整個類加鎖：

1 public class MySynchronized extends Thread
 2 {
 3     private int val;
 4     
 5     public MySynchronized(int v)
 6     {
 7         val = v;
 8     }
 9     
10     public void printVal(int v)
11     {
12         synchronized (MySynchronized.class)
13         {
14             while (true)
15             {
16                 System.out.println(v);
17             }
18         }
19     }
20     
21     public void run()
22     {
23         printVal(val);
24     }
25 }

另外的鎖例子：

String常量的特殊性，屬於同一個對象。

public class MySynchronized extends Thread
{
    private String name;
    
    private String val;
    
    public MySynchronized(String name, String v)
    {
        this.name = name;
        val = v;
    }
    
    public void printVal()
    {
        synchronized (val)
        {
            while (true)
            {
                System.out.println(name + val);
            }
        }
    }
    
    public void run()
    {
        printVal();
    }
    
    public static void main(String args[])
    {
        MySynchronized f1 = new MySynchronized("Foo 1:", "printVal");
        f1.start();
        MySynchronized f2 = new MySynchronized("Foo 2:", "printVal");
        f2.start();
    }
}

　　

總結：synchronized作用於靜態方法和非靜態方法的區別: 

 

/* 
 *  非靜態方法: 
 *  給對象加鎖(可以理解為給這個對象的內存上鎖,注意 只是這塊內存,其他同類對象都會有各自的內存鎖),這時候 
 * 在其他一個以上線程中執行該對象的這個同步方法(注意:是該對象)就會產生互斥 

 *  靜態方法:  
 * 相當於在類上加鎖(*.class 位於代碼區,靜態方法位於靜態區域,這個類產生的對象公用這個靜態方法,所以這塊 
 * 內存，N個對象來競爭), 這時候,只要是這個類產生的對象,在調用這個靜態方法時都會產生互斥 
 */