1. synchronized 可以作爲一個method的修飾符
public synchronized void aMethod() {
//some code
}
相當於：
public void aMethod() {
synchronized(this) {
//some code
}
}
說明：
(1) 它是對類中的同一對象負責
(2)在同一個類對象實例內，synchronized aMethod(){}可以防止多個線程同時訪問這個對象的synchronized方法
舉例：
public class Thread1 extends Thread{
public void run(){
/*synchronized (this) {
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " " + i);
}
}*/
myRun();
}
//與synchronized(this){}效果是一致的
public synchronized void myRun(){
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " " + i);
}
}
public static void main(String[] args) {
Thread1 t = new Thread1();
Thread myA = new Thread(t,"A");
Thread myB = new Thread(t,"B");
myA.start();
myB.start();
}
運行結果：
A 0
A 1
A 2
A 3
A 4
B 0
B 1
B 2
B 3
B 4
(3) 如果是一個類中的不同對象，多個線程可以同時訪問synchronized方法：
將main()方法修改：
Thread1 t1 = new Thread1();
Thread1 t2 = new Thread1();
t1.setName("t1");
t2.setName("t2");
t1.start();
t2.start();
運行結果：
t1 0
t2 0
t1 1
t2 1
t1 2
t2 2
t1 3
t2 3
t1 4
t2 4
(4) 如果是類的同一個對象存在多個synchronized方法，只要一個線程訪問了其中的一個synchronized方法，其它線程不能同時訪問這個對象 中任何一個synchronized方法，但可以訪問非synchronized方法。
public class Thread2 extends Thread {
/**
* (1) 當一個線程訪問object的一個synchronized(this)同步代碼塊時，
* 另一個線程仍然可以訪問該object中的非synchronized(this)同步代碼塊
*
* (2)當一個線程訪問object的一個synchronized(this)同步代碼塊時，
* 其他線程對object中所有其它synchronized(this)同步代碼塊的訪問將被阻塞
* @param args
*/
public synchronized void method1(){
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " " + i);
}
}
public synchronized void method2(){
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " " + i);
}
}
public static void main(String[] args) {
final Thread2 t2 = new Thread2();
Thread myThreadA = new Thread(
new Runnable(){
public void run(){
t2.method1();
}
},"myThreadA");
Thread myThreadB = new Thread(
new Runnable(){
public void run(){
t2.method2();
}
},"myThreadB");
myThreadA.start();
myThreadB.start();
}
}
運行結果：
myThreadA 0
myThreadA 1
myThreadA 2
myThreadA 3
myThreadA 4
myThreadB 0
myThreadB 1
myThreadB 2
myThreadB 3
myThreadB 4
2. synchronized修飾一個 static的method，
如：
public static synchronized void aMethod() {
//some code
}
相當於：
public static synchronized void aMethod() {
synchronized(XX.class) {
//some code
}
}
說明：
synchronized static aStaticMethod{}防止多個線程同時訪問這個類中的synchronized static 方法。它可以對類的所有對象實例起作用。
public class ThreadTestE extends Thread {
public void run(){
myRun();
}
public static synchronized void myRun(){
for (int i = 0; i < 5; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " " + i);
}
}
public static void main(String[] args) {
ThreadTestE e1 = new ThreadTestE();
ThreadTestE e2 = new ThreadTestE();
ThreadTestE e3 = new ThreadTestE();
e1.start();
e2.start();
e3.start();
}
}
運行結果：
Thread-0 0
Thread-0 1
Thread-0 2
Thread-0 3
Thread-0 4
Thread-1 0
Thread-1 1
Thread-1 2
Thread-1 3
Thread-1 4
Thread-2 0
Thread-2 1
Thread-2 2
Thread-2 3
Thread-2 4
總結：
無論synchronized關鍵字加在方法上還是對象上，它取得的鎖都是對象。
synchronized(object){
}
線程獲得了object對象鎖，執行裏面的代碼，其它線程阻塞，直至其它線程也獲得了該對象鎖才能執行裏面的代碼；
補充說明：
synchronized關鍵字是不能繼承的，也就是說，基類的方法synchronized f(){} 在繼承類中並不自動是synchronized f(){}，而是變成了f() {}。繼承類需要你顯式的指定它的某個方法爲synchronized方法
參考文章：
（1）java synchronized 用法 http://www.360doc.com/showWeb/0/0/493058.aspx
（2）java synchronized的幾個規則 http://blog.donews.com/dyhcn/archive/2005/07/14/465420.aspx