什么是線程安全和線程不安全
- 線程安全就是多線程訪問時山卦，采用了加鎖機制，當(dāng)一個線程訪問該類的某個數(shù)據(jù)時诵次，進行保護账蓉，其他線程不能進行訪問直到該線程讀取完，其他線程才可使用逾一。不會出現(xiàn)數(shù)據(jù)不一致或者數(shù)據(jù)污染铸本。
- 線程不安全就是不提供數(shù)據(jù)訪問保護，有可能出現(xiàn)多個線程先后更改數(shù)據(jù)造成所得到的數(shù)據(jù)是臟數(shù)據(jù)遵堵。
java內(nèi)置的線程鎖機制
關(guān)鍵字synchronized
- synchronized是java中的一個關(guān)鍵字归敬，也就是說是Java語言內(nèi)置的特性。
- 實現(xiàn)方式
加同步格式：
synchronized( 需要一個任意的對象（鎖） ){
代碼塊中放操作共享數(shù)據(jù)的代碼鄙早。
}
- synchronized的缺陷
- 如果一個代碼塊被synchronized修飾了汪茧，當(dāng)一個線程獲取了對應(yīng)的鎖，并執(zhí)行該代碼塊時限番，其他線程便只能一直等待舱污，等待獲取鎖的線程釋放鎖，而這里獲取鎖的線程釋放鎖只會有兩種情況：
- 獲取鎖的線程執(zhí)行完了該代碼塊弥虐，然后線程釋放對鎖的占有扩灯；
- 線程執(zhí)行發(fā)生異常，此時JVM會讓線程自動釋放鎖霜瘪。
- 例子1：
- 如果一個代碼塊被synchronized修飾了汪茧，當(dāng)一個線程獲取了對應(yīng)的鎖，并執(zhí)行該代碼塊時限番，其他線程便只能一直等待舱污，等待獲取鎖的線程釋放鎖，而這里獲取鎖的線程釋放鎖只會有兩種情況：
如果這個獲取鎖的線程由于要等待IO或者其他原因（比如調(diào)用sleep方法）被阻塞了珠插，但是又沒有釋放鎖，其他線程便只能干巴巴地等待颖对，試想一下捻撑，這多么影響程序執(zhí)行效率。
因此就需要有一種機制可以不讓等待的線程一直無期限地等待下去（比如只等待一定的時間或者能夠響應(yīng)中斷），通過Lock就可以辦到顾患。
- 例子2：
當(dāng)有多個線程讀寫文件時番捂，讀操作和寫操作會發(fā)生沖突現(xiàn)象，寫操作和寫操作會發(fā)生沖突現(xiàn)象江解，但是讀操作和讀操作不會發(fā)生沖突現(xiàn)象设预。
但是采用synchronized關(guān)鍵字來實現(xiàn)同步的話，就會導(dǎo)致一個問題：
如果多個線程都只是進行讀操作犁河，當(dāng)一個線程在進行讀操作時鳖枕，其他線程只能等待無法進行讀操作。
- 因此就需要一種機制來使得多個線程都只是進行讀操作時桨螺，線程之間不會發(fā)生沖突宾符，通過Lock就可以辦到。
- 另外彭谁，通過Lock可以知道線程有沒有成功獲取到鎖。這個是synchronized無法辦到的允扇。
- 總的來說缠局，也就是說Lock提供了比synchronized更多的功能。
Lock
- 首先要說明的就是Lock考润，通過查看Lock的源碼可知狭园，Lock是一個接口
public interface Lock {
void lock();
void lockInterruptibly() throws InterruptedException;
boolean tryLock();
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
void unlock();
}
-
Lock接口中每個方法的使用:
-
lock()、tryLock()糊治、tryLock(long time, TimeUnit unit)唱矛、lockInterruptibly()是用來獲取鎖的。 -
unLock()方法是用來釋放鎖的井辜。
-
-
四個獲取鎖方法的區(qū)別：
- lock()方法
- 是平常使用得最多的一個方法绎谦，就是用來獲取鎖。如果鎖已被其他線程獲取粥脚，則進行等待窃肠。
- 由于在前面講到如果采用Lock，必須主動去釋放鎖刷允，并且在發(fā)生異常時冤留，不會自動釋放鎖。因此一般來說树灶，使用Lock必須在try{}catch{}塊中進行纤怒，并且將釋放鎖的操作放在finally塊中進行，以保證鎖一定被被釋放天通，防止死鎖的發(fā)生泊窘。
- tryLock()方法
- 是有返回值的，它表示用來嘗試獲取鎖，如果獲取成功州既，則返回true谜洽，如果獲取失敗（即鎖已被其他線程獲任庖丁）阐虚，則返回false，也就說這個方法無論如何都會立即返回蚌卤。在拿不到鎖時不會一直在那等待实束。
- tryLock(long time, TimeUnit unit)方法
- 和tryLock()方法是類似的，只不過區(qū)別在于這個方法在拿不到鎖時會等待一定的時間逊彭，在時間期限之內(nèi)如果還拿不到鎖咸灿，就返回false。如果如果一開始拿到鎖或者在等待期間內(nèi)拿到了鎖侮叮，則返回true避矢。
- lockInterruptibly()方法
- 比較特殊，當(dāng)通過這個方法去獲取鎖時囊榜，如果線程正在等待獲取鎖审胸，則這個線程能夠響應(yīng)中斷，即中斷線程的等待狀態(tài)卸勺。也就使說砂沛，當(dāng)兩個線程同時通過lock.lockInterruptibly()想獲取某個鎖時，假若此時線程A獲取到了鎖曙求，而線程B只有等待碍庵，那么對線程B調(diào)用threadB.interrupt()方法能夠中斷線程B的等待過程。
- 注意悟狱，當(dāng)一個線程獲取了鎖之后静浴，是不會被interrupt()方法中斷的。
- 因此當(dāng)通過lockInterruptibly()方法獲取某個鎖時挤渐，如果不能獲取到马绝，只有進行等待的情況下，是可以響應(yīng)中斷的挣菲。
- 而用synchronized修飾的話富稻，當(dāng)一個線程處于等待某個鎖的狀態(tài)，是無法被中斷的白胀，只有一直等待下去椭赋。
- lock()方法
-
Lock和synchronized的區(qū)別
- Lock不是Java語言內(nèi)置的，synchronized是Java語言的關(guān)鍵字或杠，因此是內(nèi)置特性哪怔。Lock是一個類，通過這個類可以實現(xiàn)同步訪問；
- Lock和synchronized有一點非常大的不同认境，采用synchronized不需要用戶去手動釋放鎖胚委，當(dāng)synchronized方法或者synchronized代碼塊執(zhí)行完之后，系統(tǒng)會自動讓線程釋放對鎖的占用叉信；而Lock則必須要用戶去手動釋放鎖亩冬，如果沒有主動釋放鎖，就有可能導(dǎo)致出現(xiàn)死鎖現(xiàn)象硼身。
ReentrantLock
- 直接使用lock接口的話硅急，我們需要實現(xiàn)很多方法，不太方便佳遂，ReentrantLock是唯一實現(xiàn)了Lock接口的類营袜，并且ReentrantLock提供了更多的方法，ReentrantLock丑罪，意思是“可重入鎖”荚板。
lock()的使用方法
import java.util.ArrayList;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class MyLockTest {
private static ArrayList<Integer> arrayList = new ArrayList<Integer>();
static Lock lock = new ReentrantLock(); // 注意這個地方
public static <E> void main(String[] args) {
new Thread() {
public void run() {
Thread thread = Thread.currentThread();
lock.lock();
try {
System.out.println(thread.getName() + "得到了鎖");
for (int i = 0; i < 5; i++) {
arrayList.add(i);
}
} catch (Exception e) {
// TODO: handle exception
} finally {
System.out.println(thread.getName() + "釋放了鎖");
lock.unlock();
}
};
}.start();
new Thread() {
public void run() {
Thread thread = Thread.currentThread();
lock.lock();
try {
System.out.println(thread.getName() + "得到了鎖");
for (int i = 0; i < 5; i++) {
arrayList.add(i);
}
} catch (Exception e) {
// TODO: handle exception
} finally {
System.out.println(thread.getName() + "釋放了鎖");
lock.unlock();
}
};
}.start();
}
}
tryLock()的使用方法
import java.util.ArrayList;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 觀察現(xiàn)象：一個線程獲得鎖后，另一個線程取不到鎖吩屹，不會一直等待
* @author
*
*/
public class MyTryLock {
private static ArrayList<Integer> arrayList = new ArrayList<Integer>();
static Lock lock = new ReentrantLock(); // 注意這個地方
public static void main(String[] args) {
new Thread() {
public void run() {
Thread thread = Thread.currentThread();
boolean tryLock = lock.tryLock();
System.out.println(thread.getName()+" "+tryLock);
if (tryLock) {
try {
System.out.println(thread.getName() + "得到了鎖");
for (int i = 0; i < 5; i++) {
arrayList.add(i);
}
} catch (Exception e) {
// TODO: handle exception
} finally {
System.out.println(thread.getName() + "釋放了鎖");
lock.unlock();
}
}
};
}.start();
new Thread() {
public void run() {
Thread thread = Thread.currentThread();
boolean tryLock = lock.tryLock();
System.out.println(thread.getName()+" "+tryLock);
if (tryLock) {
try {
System.out.println(thread.getName() + "得到了鎖");
for (int i = 0; i < 5; i++) {
arrayList.add(i);
}
} catch (Exception e) {
// TODO: handle exception
} finally {
System.out.println(thread.getName() + "釋放了鎖");
lock.unlock();
}
}
};
}.start();
}
}
lockInterruptibly()響應(yīng)中斷的使用方法
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* 觀察現(xiàn)象：如果thread-0得到了鎖跪另，阻塞。祟峦。罚斗。thread-1嘗試獲取鎖徙鱼，如果拿不到宅楞，則可以被中斷等待
* @author
*
*/
public class MyInterruptibly {
private Lock lock = new ReentrantLock();
public static void main(String[] args) {
MyInterruptibly test = new MyInterruptibly();
MyThread thread0 = new MyThread(test);
MyThread thread1 = new MyThread(test);
thread0.start();
thread1.start();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
thread1.interrupt();
System.out.println("=====================");
}
public void insert(Thread thread) throws InterruptedException{
lock.lockInterruptibly(); //注意，如果需要正確中斷等待鎖的線程袱吆，必須將獲取鎖放在外面厌衙，然后將InterruptedException拋出
try {
System.out.println(thread.getName()+"得到了鎖");
long startTime = System.currentTimeMillis();
for( ; ;) {
if(System.currentTimeMillis() - startTime >= Integer.MAX_VALUE)
break;
//插入數(shù)據(jù)
}
}
finally {
System.out.println(Thread.currentThread().getName()+"執(zhí)行finally");
lock.unlock();
System.out.println(thread.getName()+"釋放了鎖");
}
}
}
class MyThread extends Thread {
private MyInterruptibly test = null;
public MyThread(MyInterruptibly test) {
this.test = test;
}
@Override
public void run() {
try {
test.insert(Thread.currentThread());
} catch (Exception e) {
System.out.println(Thread.currentThread().getName()+"被中斷");
}
}
}
ReadWriteLock讀寫鎖
- ReadWriteLock也是一個接口，在它里面只定義了兩個方法.
public interface ReadWriteLock {
/**
* Returns the lock used for reading.
*
* @return the lock used for reading.
*/
Lock readLock();
/**
* Returns the lock used for writing.
*
* @return the lock used for writing.
*/
Lock writeLock();
}
- 一個用來獲取讀鎖绞绒，一個用來獲取寫鎖婶希。也就是說將文件的讀寫操作分開，分成2個鎖來分配給線程蓬衡，從而使得多個線程可以同時進行讀操作。
ReentrantReadWriteLock
- ReentrantReadWriteLock里面提供了很多豐富的方法狰晚，不過最主要的有兩個方法：readLock()和writeLock()用來獲取讀鎖和寫鎖。
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* 使用讀寫鎖壁晒，可以實現(xiàn)讀寫分離鎖定，讀操作并發(fā)進行，寫操作鎖定單個線程
*
* 如果有一個線程已經(jīng)占用了讀鎖谬晕，則此時其他線程如果要申請寫鎖，則申請寫鎖的線程會一直等待釋放讀鎖攒钳。
* 如果有一個線程已經(jīng)占用了寫鎖，則此時其他線程如果申請寫鎖或者讀鎖夕玩，則申請的線程會一直等待釋放寫鎖。
* @author
*
*/
public class MyReentrantReadWriteLock {
private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
public static void main(String[] args) {
final MyReentrantReadWriteLock test = new MyReentrantReadWriteLock();
new Thread(){
public void run() {
test.get(Thread.currentThread());
test.write(Thread.currentThread());
};
}.start();
new Thread(){
public void run() {
test.get(Thread.currentThread());
test.write(Thread.currentThread());
};
}.start();
}
/**
* 讀操作,用讀鎖來鎖定
* @param thread
*/
public void get(Thread thread) {
rwl.readLock().lock();
try {
long start = System.currentTimeMillis();
while(System.currentTimeMillis() - start <= 1) {
System.out.println(thread.getName()+"正在進行讀操作");
}
System.out.println(thread.getName()+"讀操作完畢");
} finally {
rwl.readLock().unlock();
}
}
/**
* 寫操作燎孟，用寫鎖來鎖定
* @param thread
*/
public void write(Thread thread) {
rwl.writeLock().lock();;
try {
long start = System.currentTimeMillis();
while(System.currentTimeMillis() - start <= 1) {
System.out.println(thread.getName()+"正在進行寫操作");
}
System.out.println(thread.getName()+"寫操作完畢");
} finally {
rwl.writeLock().unlock();
}
}
}
注意事項
- 如果有一個線程已經(jīng)占用了讀鎖，則此時其他線程如果要申請寫鎖揩页，則申請寫鎖的線程會一直等待釋放讀鎖。
- 如果有一個線程已經(jīng)占用了寫鎖爆侣，則此時其他線程如果申請寫鎖或者讀鎖，則申請的線程會一直等待釋放寫鎖兔仰。
Lock和synchronized的選擇
- Lock是一個接口茫负，而synchronized是Java中的關(guān)鍵字，synchronized是內(nèi)置的語言實現(xiàn)乎赴；
- synchronized在發(fā)生異常時忍法，會自動釋放線程占有的鎖，因此不會導(dǎo)致死鎖現(xiàn)象發(fā)生榕吼；而Lock在發(fā)生異常時饿序，如果沒有主動通過unLock()去釋放鎖，則很可能造成死鎖現(xiàn)象羹蚣，因此使用Lock時需要在finally塊中釋放鎖原探；
- Lock可以讓等待鎖的線程響應(yīng)中斷，而synchronized卻不行顽素，使用synchronized時咽弦，等待的線程會一直等待下去，不能夠響應(yīng)中斷胁出；
- 通過Lock可以知道有沒有成功獲取鎖型型，而synchronized卻無法辦到.
- Lock可以提高多個線程進行讀操作的效率。
- 在性能上來說划鸽，如果競爭資源不激烈输莺，兩者的性能是差不多的戚哎，而當(dāng)競爭資源非常激烈時（即有大量線程同時競爭），此時Lock的性能要遠(yuǎn)遠(yuǎn)優(yōu)于synchronized嫂用。所以說型凳，在具體使用時要根據(jù)適當(dāng)情況選擇。
