JAVA併發之多線程基礎（2）

除了咱們常常用的synchronized關鍵字（結合Object的wait()和notify()使用）以外，還有對應的上篇文章講到的方法JAVA併發之多線程基礎（1）以外，咱們平常中使用到最多的也就是JUC下面對應的類與方法。

ReentrantLock

ReentrantLock在JDK1.5以前比Synchronized性能好許多，在以後Synchronized也進行了修改，使得當下兩個在對於線程方面性能相差無幾。可是ReentrantLock的功能更加豐富，它的特色有：可重入、可中斷、可限時、公平鎖。

package com.montos.lock;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockDemo implements Runnable {
	public static ReentrantLock lock = new ReentrantLock();
	public static int k = 0;
	@Override
	public void run() {
		for (int i = 0; i < 1000; i++) {
			lock.lock();
				k++;
		}
		for (int i = 0; i < 1000; i++) {
			lock.unlock();
		}
	}

	public static void main(String[] args) throws InterruptedException {
		ReentrantLockDemo demo = new ReentrantLockDemo();
		Thread t1 = new Thread(demo);
		Thread t2 = new Thread(demo);
		t1.start();
		t2.start();
		t1.join();
		t2.join();
		System.out.println(k);
	}

}
複製代碼

1. 經過這個小的demo能夠看到控制檯中不管如何執行，輸出的值都是2000。這裏面就體現了可重入（對於同一把鎖進行加鎖和釋放鎖）的特色。

2. 可中斷則在lockInterruptibly()這個方法上進行體現。

public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }
複製代碼

使用這個方法就能夠在加鎖的過程當中進行中斷，用來保證程序的正常進行下去，避免死鎖一直阻塞程序運行。經過上面的方法進行查看底層調用的：

//以獨佔模式獲取，若是中斷將停止。
 public final void acquireInterruptibly(int arg) throws InterruptedException {
        if (Thread.interrupted()) //測試當前線程是否已中斷
            throw new InterruptedException();
        if (!tryAcquire(arg)) //嘗試獲取arg次鎖操做
            doAcquireInterruptibly(arg);//以獨佔中斷模式獲取鎖操做
    }
複製代碼

3. 可限時操做在tryLock(long timeout, TimeUnit unit)方法中體現，目的主要是防止死鎖的發生。

public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException {
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }
複製代碼

在使用這個的時候，也要注意在finally中也要釋放鎖，固然在釋放以前先判斷當前當前線程是否持有鎖操做lock.isHeldByCurrentThread()。

4. 公平鎖則在ReentrantLock的構造函數中體現出來。所謂公平鎖與非公平鎖就是線程先來先到和先來不必定拿到鎖的狀況的。

public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }
複製代碼

固然非公平鎖的性能要比公平鎖的性能好不少，公平鎖裏面還要維護一個隊列（AQS）來進行操控公平性。因此說通常沒有特殊要求的狀況下，默認使用非公平的鎖就能夠。

Condition

上面講完重入鎖以後，這裏在講解一個與重入鎖密切相關的類。他與重入鎖之間的關係猶如synchronized與Object的wait()和notify()同樣。也就是說在使用它的狀況也要得到當前的鎖，才能夠進行下面的操做。

package com.montos.lock;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockCondition implements Runnable {
	public static ReentrantLock lock = new ReentrantLock();
	public static Condition condition = lock.newCondition();

	@Override
	public void run() {
		try {
			lock.lock();//拿到對應鎖
			condition.await();
			System.out.println("wait is end,going down");
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			if (lock.isHeldByCurrentThread()) {
				lock.unlock();
			}
		}
	}

	public static void main(String[] args) throws InterruptedException {
		ReentrantLockCondition conditions = new ReentrantLockCondition();
		Thread thread = new Thread(conditions);
		thread.start();
		Thread.sleep(2000);
		lock.lock();
		condition.signal();//只有拿到對應鎖上面的監視器才能夠執行
		lock.unlock();
	}
}
複製代碼

這上面的Condition的用法至關於Object裏面的兩個方法同樣。整體來講使用重入鎖也是看業務場景狀況下使用，若是想要上面特色的鎖方法，那麼使用重入鎖就是很好的。否則的話使用synchronized關鍵字就能夠完成大多數的業務場景了。