在Java中，對於synchronized關鍵字，大家看到的第一反應就是這個關鍵字是進行同步操作的，即得名“同步鎖”。
-
當用它來修飾方法和代碼塊時，默認當前的對象為鎖的對象，即對象鎖。
-
當用來修飾類和靜態方法時，默認當前的類為鎖的對象
對象鎖
修飾在方法上時，多個線程調用同一對象的同步方法時會阻塞，調用不同對象的同步方法時不會阻塞。
在多線程環境下，調用不同對象的同步方法：
public class SynchronizedDemo {
public synchronized void synTest(){
int i = 5;
while (i-- > 0){
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
SynchronizedDemo demo1 = new SynchronizedDemo();
SynchronizedDemo demo2 = new SynchronizedDemo();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
demo1.obj3();
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
demo2.obj3();
}
});
t1.start();
t2.start();
}
}
Output：
Thread-0 : 4
Thread-1 : 4
Thread-0 : 3
Thread-1 : 3
Thread-0 : 2
Thread-1 : 2
Thread-0 : 1
Thread-1 : 1
Thread-0 : 0
Thread-1 : 0
在多線程環境下，調用同一對象的同步方法：
public class SynchronizedDemo {
public synchronized void synTest(){
int i = 5;
while (i-- > 0){
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
SynchronizedDemo demo1 = new SynchronizedDemo();
SynchronizedDemo demo2 = new SynchronizedDemo();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
demo1.synTest();
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
demo1.synTest();
}
});
t1.start();
t2.start();
}
}
Output：
Thread-0 : 4
Thread-0 : 3
Thread-0 : 2
Thread-0 : 1
Thread-0 : 0
Thread-1 : 4
Thread-1 : 3
Thread-1 : 2
Thread-1 : 1
Thread-1 : 0
在多線程環境下，調用不同對象通過this修飾的局部代碼塊
public class SynchronizedDemo {
public void synTest(){
synchronized (this){
int i = 5;
while (i-- > 0){
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public static void main(String[] args) {
SynchronizedDemo demo1 = new SynchronizedDemo();
SynchronizedDemo demo2 = new SynchronizedDemo();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
demo1.synTest();
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
demo2.synTest();
}
});
t1.start();
t2.start();
}
}
Output：
Thread-0 : 4
Thread-1 : 4
Thread-0 : 3
Thread-1 : 3
Thread-0 : 2
Thread-1 : 2
Thread-0 : 1
Thread-1 : 1
Thread-0 : 0
Thread-1 : 0
對於this修飾的其實指的就是類的實例，所以它也屬於對象鎖，並不是類鎖。
在多線程環境下，調用不同對象通過其他實例類修飾的局部代碼塊
public class SynchronizedDemo {
public void synTest(){
String str = new String("lock");
synchronized (str){
int i = 5;
while (i-- > 0){
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public static void main(String[] args) {
SynchronizedDemo demo1 = new SynchronizedDemo();
SynchronizedDemo demo2 = new SynchronizedDemo();
Thread t1 = new Thread(() -> {
demo1.synTest();
});
Thread t2 = new Thread(() -> {
demo2.synTest();
});
t1.start();
t2.start();
}
}
Output：
Thread-0 : 4
Thread-1 : 4
Thread-1 : 3
Thread-0 : 3
Thread-1 : 2
Thread-0 : 2
Thread-1 : 1
Thread-0 : 1
Thread-1 : 0
Thread-0 : 0
我們可以看到，我們通過每次調用時實例一個String來進行同步代碼塊，但是並沒有發生阻塞，因為每次生成的是一個實例String，鎖的是String，每次都是不一樣的，所以不會發生阻塞。
可以通過上述的運行結果可以得到一下結論：
在多線程環境下：
- 調用不同對象的同步方法，不會發生阻塞
- 調用相同對象的同步方法，會發生阻塞
- 調用不同對象通過this修飾的局部代碼塊，不會發生阻塞
- 調用不同對象通過其他實例類修飾的同步代碼塊，不會發生阻塞
類鎖
在多線程環境下，多次調用類的靜態同步方法：
public class SynchronizedDemo {
public static synchronized void synTest(){
int i = 5;
while (i-- > 0){
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
SynchronizedDemo.synTest();
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
SynchronizedDemo.synTest();
}
});
t1.start();
t2.start();
}
Output：
Thread-0 : 4
Thread-0 : 3
Thread-0 : 2
Thread-0 : 1
Thread-0 : 0
Thread-1 : 4
Thread-1 : 3
Thread-1 : 2
Thread-1 : 1
Thread-1 : 0
在多線程環境下，多次調用被類鎖的代碼塊：
public class SynchronizedDemo {
public void synTest(){
synchronized (SynchronizedDemo.class){
int i = 5;
while (i-- > 0){
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public static void main(String[] args) {
SynchronizedDemo demo1 = new SynchronizedDemo();
SynchronizedDemo demo2 = new SynchronizedDemo();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
demo1.synTest();
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
demo2.synTest();
}
});
t1.start();
t2.start();
}
}
Output:
Thread-1 : 4
Thread-1 : 3
Thread-1 : 2
Thread-1 : 1
Thread-1 : 0
Thread-0 : 4
Thread-0 : 3
Thread-0 : 2
Thread-0 : 1
Thread-0 : 0
對於對象SynchronizedDemo.class，實際上就是SynchronizedDemo這個類，也就是對類進行加鎖。
可以通過上述的運行結果可以得到一下結論：
在多線程環境下：
- 多次調用靜態的同步方法，會進行阻塞
- 不同對象調用被類鎖的同步代碼塊，會進行阻塞
類鎖和對象鎖同時存在
在多線程環境下，同時調用同一對象的類鎖和對象鎖
public class SynchronizedDemo {
public static synchronized void synTestStatic() {
int i = 5;
while (i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public synchronized void synTest() {
int i = 5;
while (i-- > 0) {
System.out.println(Thread.currentThread().getName() + " : " + i);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
SynchronizedDemo demo1 = new SynchronizedDemo();
Thread t1 = new Thread(() -> {
demo1.synTest();
});
Thread t2 = new Thread(() -> {
SynchronizedDemo.synTestStatic();
});
t1.start();
t2.start();
}
}
Output：
Thread-1 : 4
Thread-0 : 4
Thread-1 : 3
Thread-0 : 3
Thread-1 : 2
Thread-0 : 2
Thread-1 : 1
Thread-0 : 1
Thread-1 : 0
Thread-0 : 0
我們可以到看到，在多線程環境下，類鎖和對象鎖同時存在的情況下，多線程訪問時不會阻塞，因為他們不是同一個鎖。
可以通過上述的運行結果可以得到一下結論：
在多線程環境下：
- 類鎖和對象鎖同時存在的情況下，不會發生阻塞
總結
