跟著例項學習java多執行緒3-synchronized的多種寫法有何區別？
同步程式碼塊是一種有效實現操作原子性的方法，上一章我們講了一些同步的原子操作的基礎。
現在我們回憶一下上一章的兩個問題。
1：不同的synchronized的寫法有什麼區別，又該怎麼寫建立執行緒的程式碼呢？
以class例項物件作為鎖的寫法
寫法1
package com.home.thread; /** * @author gaoxu * */ public class SafeThread { @safe public void testPrint(){ synchronized(SafeThread.class){ System.out.println("Enter testPrint method !"); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Exit testPrint method !"); } } }
寫法2
package com.home.thread; /** * @author gaoxu * */ public class SafeThread { public static synchronized void testPrint(){ System.out.println("Enter testPrint method !"); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("Exit testPrint method !"); } }
以上兩種寫法是以class例項物件為鎖的寫法，這兩種寫法的呼叫執行緒該怎麼寫呢？讓我們來看下面的例子
寫法1，建立當前物件例項，並使用物件例項初始化執行緒。
package com.home.thread; /** * @author gaoxu * */ public class ThreadStart { public static void main(String[] para){ SafeThread safe = new SafeThread(); for(int i=0;i<3;i++){ ThreadRead1 t1 = new ThreadRead1(safe); t1.start(); } } }
package com.home.thread;
/**
* @author gaoxu
*
*/
public class ThreadRead1 extends Thread{
SafeThread safe = null;
public ThreadRead1(){
}
public ThreadRead1(SafeThread o){
safe = o;
}
public void run()
{
safe.testPrint();
}
}
寫法2，可以線上程中建立類例項。
package com.home.thread;
/**
* @author gaoxu
*
*/
public class ThreadStart {
public static void main(String[] para){
for(int i=0;i<3;i++){
ThreadRead1 t1 = new ThreadRead1();
t1.start();
}
}
}</span><span style="font-size:14px;">package com.home.thread;
/**
* @author gaoxu
*
*/
public class ThreadRead1 extends Thread{
SafeThread safe = null;
public ThreadRead1(){
}
public void run()
{
safe = new SafeThread();
safe.testPrint();
}
}
這兩總寫法可以起到相同的作用，都可以實現原子的操作，實現同步互斥的呼叫。
建立內部同步程式碼塊，以當前例項物件作為鎖的物件。
寫法1
package com.home.thread;
/**
* @author gaoxu
*
*/
public class SafeThread {
public synchronized void testPrint(){
System.out.println("Enter testPrint method !");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Exit testPrint method !");
}
}
package com.home.thread;
/**
* @author gaoxu
*
*/
public class SafeThread {
public void testPrint(){
synchronized(this){
System.out.println("Enter testPrint method !");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Exit testPrint method !");
}
}
}<span style="font-size:14px;">
</span>package com.home.thread;
/**
* @author gaoxu
*
*/
public class SafeThread {
Object a = new Object();
public void testPrint(){
synchronized(a){
System.out.println("Enter testPrint method !");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Exit testPrint method !");
}
}
}這三種寫法都是以類的當前例項物件作為鎖物件，所以執行緒呼叫寫法如下;
package com.home.thread;
/**
* @author gaoxu
*
*/
public class ThreadStart {
public static void main(String[] para){
SafeThread safe = new SafeThread();//當前例項物件
for(int i=0;i<3;i++){
ThreadRead1 t1 = new ThreadRead1(safe);
t1.start();
}
}
}
package com.home.thread;
/**
* @author gaoxu
*
*/
public class ThreadRead1 extends Thread{
SafeThread safe = null;
public ThreadRead1(){
}
public ThreadRead1(SafeThread o){
safe = o;
}
public void run()
{
safe.testPrint();
}
}下面讓我們來看一下以class物件和當前物件的區別：
類.class和static synchronized是對該類所有例項物件枷鎖。
synchronized(this),synchronized,synchronized(object)都是對類的當前例項物件加鎖。
具體說明：
synchronized是對類的當前例項進行加鎖，防止其他執行緒同時訪問該類的當前例項的所有synchronized塊。static synchronized是控制類的所有例項的訪問了，static synchronized是限制執行緒同時訪問jvm中該類的所有例項對應的程式碼快。在類中某方法或某程式碼塊中有 synchronized，那麼在生成一個該類例項後，該類也就有一個監視塊，放置執行緒併發訪問該例項synchronized保護塊，這個保護塊只對當前例項有效，而static
synchronized則是所有該類的例項公用一個監視塊，放置執行緒併發訪問該類所有例項的保護塊，synchronized相當於 this.synchronized，而
static synchronized相當於Something.synchronized。
2：死鎖、活躍性問題都是怎麼產生的。
後續章節我們重點討論。
今天的問題是：
1：執行緒安全除了原子操作還有什麼需要注意的。
2：如何確定自己需要實現一個執行緒安全類。