淺談Synchronized:
synchronized是Java的一個關鍵字,也就是Java語言內置的特性,如果一個代碼塊被synchronized修飾了,當一個線程獲取了對應的鎖,執行代碼塊時,其他線程
便只能一直等待,等待獲取鎖的線程釋放鎖,而獲取鎖的線程釋放鎖會有三種情況:
1).獲取鎖的線程執行完該代碼塊,然后線程釋放對鎖的占有;
2).線程執行發生異常,此時JVM會讓線程自動釋放鎖;
3).調用wait方法,在等待的時候立即釋放鎖,方便其他的線程使用鎖.
Lock的特性:
1).Lock不是Java語言內置的;
2).synchronized是在JVM層面上實現的,如果代碼執行出現異常,JVM會自動釋放鎖,但是Lock不行,要保證鎖一定會被釋放,就必須將unLock放到finally{}中(手動釋放);
3).在資源競爭不是很激烈的情況下,Synchronized的性能要優於ReetarntLock,但是在很激烈的情況下,synchronized的性能會下降幾十倍;
4).ReentrantLock增加了鎖:
a. void lock(); // 無條件的鎖;
b. void lockInterruptibly throws InterruptedException;//可中斷的鎖;
解釋: 使用ReentrantLock如果獲取了鎖立即返回,如果沒有獲取鎖,當前線程處於休眠狀態,直到獲得鎖或者當前線程可以被別的線程中斷去做其他的事情;但是如果是synchronized的話,如果沒有獲取到鎖,則會一直等待下去;
c. boolean tryLock();//如果獲取了鎖立即返回true,如果別的線程正持有,立即返回false,不會等待;
d. boolean tryLock(long timeout,TimeUnit unit);//如果獲取了鎖立即返回true,如果別的線程正持有鎖,會等待參數給的時間,在等待的過程中,如果獲取鎖,則返回true,如果等待超時,返回false;
Condition的特性:
1.Condition中的await()方法相當於Object的wait()方法，Condition中的signal()方法相當於Object的notify()方法，Condition中的signalAll()相當於Object的notifyAll()方法。不同的是，Object中的這些方法是和同步鎖捆綁使用的；而Condition是需要與互斥鎖/共享鎖捆綁使用的。
2.Condition它更強大的地方在於：能夠更加精細的控制多線程的休眠與喚醒。對於同一個鎖，我們可以創建多個Condition，在不同的情況下使用不同的Condition。
例如，假如多線程讀/寫同一個緩沖區：當向緩沖區中寫入數據之后，喚醒"讀線程"；當從緩沖區讀出數據之后，喚醒"寫線程"；並且當緩沖區滿的時候，"寫線程"需要等待；當緩沖區為空時，"讀線程"需要等待。
如果采用Object類中的wait(), notify(), notifyAll()實現該緩沖區，當向緩沖區寫入數據之后需要喚醒"讀線程"時，不可能通過notify()或notifyAll()明確的指定喚醒"讀線程"，而只能通過notifyAll喚醒所有線程(但是notifyAll無法區分喚醒的線程是讀線程，還是寫線程)。 但是，通過Condition，就能明確的指定喚醒讀線程。
package com.imooc.locks;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Task {
private final Lock lock = new ReentrantLock();
private final Condition addCondition = lock.newCondition();
private final Condition subCondition = lock.newCondition();
private static int num = 0;
private List<String> lists = new LinkedList<String>();
public void add() {
lock.lock();
try {
while(lists.size() == 10) {//當集合已滿,則"添加"線程等待
addCondition.await();
}
num++;
lists.add("add Banana" + num);
System.out.println("The Lists Size is " + lists.size());
System.out.println("The Current Thread is " + Thread.currentThread().getName());
System.out.println("==============================");
this.subCondition.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {//釋放鎖
lock.unlock();
}
}
public void sub() {
lock.lock();
try {
while(lists.size() == 0) {//當集合為空時,"減少"線程等待
subCondition.await();
}
String str = lists.get(0);
lists.remove(0);
System.out.println("The Token Banana is [" + str + "]");
System.out.println("The Current Thread is " + Thread.currentThread().getName());
System.out.println("==============================");
num--;
addCondition.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
package com.imooc.locks;
public class AddThread implements Runnable {
private Task task;
public AddThread(Task task) {
this.task = task;
}
@Override
public void run() {
task.add();
}
}
package com.imooc.locks;
public class SubThread implements Runnable {
private Task task;
public SubThread(Task task) {
this.task = task;
}
@Override
public void run() {
task.sub();
}
}
package com.imooc.locks;
public class TestLock {
public static void main(String[] args) {
Task task = new Task();
Thread t1=new Thread(new AddThread(task));
Thread t3=new Thread(new AddThread(task));
Thread t7=new Thread(new AddThread(task));
Thread t8=new Thread(new AddThread(task));
Thread t2 = new Thread(new SubThread(task));
Thread t4 = new Thread(new SubThread(task));
Thread t5 = new Thread(new SubThread(task));
Thread t6 = new Thread(new SubThread(task));
t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
t6.start();
t7.start();
t8.start();
}
}