在java多线程中，我们真的可以使用synchronized关键字来实现线程间的同步互斥工作，那么其实还有一个更优秀的机制去完成这个“同步互斥”工作，他就是Lock对象，重入锁和读写锁。他们具有比synchronized更为强大的功能，并且有嗅探锁定、多路分支等功能。
一、重入锁
在需要进行同步的代码部分加上锁定，但不要忘记最后一定要释放锁定，不然会造成锁永远无法释放，其他线程永远进不来的结果。
ReentrantLock (重入锁)示例：
/**
* 重入锁
* @author yanghz
* @createDate 2018年11月19日
*/
public class UseReentrantLock {
private Lock lock=new ReentrantLock();
public void method1(){
try{
lock.lock();
System.out.println("当前线程："+Thread.currentThread().getName()+"进入method1");
Thread.sleep(1000);
System.out.println("当前线程："+Thread.currentThread().getName()+"退出method1");
Thread.sleep(1000);
}catch(Exception e){
}finally{
//释放锁
lock.unlock();
}
}
public void method2(){
try{
lock.lock();
System.out.println("当前线程："+Thread.currentThread().getName()+"进入method2");
Thread.sleep(2000);
System.out.println("当前线程："+Thread.currentThread().getName()+"退出method2");
Thread.sleep(1000);
}catch(Exception e){
}finally{
//释放锁
lock.unlock();
}
}
public static void main(String[] args) {
final UseReentrantLock ur=new UseReentrantLock();
Thread t1=new Thread(new Runnable() {
@Override
public void run() {
ur.method1();
ur.method2();
}
},"t1");
t1.start();
}
}
运行结果：
当前线程：t1进入method1
当前线程：t1退出method1
当前线程：t1进入method2
当前线程：t1退出method2
Condition类的使用：
/**
* Lock的通知和等待用法
* @author yanghz
* @createDate 2018年11月19日
*/
public class UseCondition {
private Lock lock=new ReentrantLock();
private Condition condition=lock.newCondition();
public void method1(){
try {
lock.lock();
System.out.println("当前线程："+Thread.currentThread().getName()+"进入等待状态。。。。");
Thread.sleep(3000);
System.out.println("当前线程："+Thread.currentThread().getName()+"释放锁。。。。");
condition.await();
System.out.println("当前线程："+Thread.currentThread().getName()+"继续执行。。。。");
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
lock.unlock();
}
}
public void method2(){
try {
lock.lock();
System.out.println("当前线程："+Thread.currentThread().getName()+"进入等待状态。。。。");
Thread.sleep(3000);
System.out.println("当前线程："+Thread.currentThread().getName()+"发起唤醒锁。。。。");
condition.signal();
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
lock.unlock();
}
}
public static void main(String[] args) {
final UseCondition uc=new UseCondition();
Thread t1=new Thread(new Runnable() {
public void run() {
uc.method1();
}
},"t1");
Thread t2=new Thread(new Runnable() {
public void run() {
uc.method2();
}
},"t2");
t1.start();
t2.start();
}
}
输出结果：
当前线程：t1进入等待状态。。。。
当前线程：t1释放锁。。。。
当前线程：t2进入等待状态。。。。
当前线程：t2发起唤醒锁。。。。
当前线程：t1继续执行。。。。
多Condition
/**
* 多Condition
* @author yanghz
* @createDate 2018年11月19日
*/
public class UseManyCondition {
private Lock lock = new ReentrantLock();
private Condition c1=lock.newCondition();
private Condition c2=lock.newCondition();
public void m1(){
try{
lock.lock();
System.out.println("当前线程："+Thread.currentThread().getName()+"进入方法m1等待...");
c1.await();
System.out.println("当前线程："+Thread.currentThread().getName()+"方法m1继续执行...");
}catch (InterruptedException e) {
e.printStackTrace();
}finally{
lock.unlock();
}
}
public void m2(){
try{
lock.lock();
System.out.println("当前线程："+Thread.currentThread().getName()+"进入方法m2等待...");
c1.await();
System.out.println("当前线程："+Thread.currentThread().getName()+"方法m2继续执行...");
}catch (InterruptedException e) {
e.printStackTrace();
}finally{
lock.unlock();
}
}
public void m3(){
try{
lock.lock();
System.out.println("当前线程："+Thread.currentThread().getName()+"进入方法m3等待...");
c2.await();
System.out.println("当前线程："+Thread.currentThread().getName()+"方法m3继续执行...");
}catch (InterruptedException e) {
e.printStackTrace();
}finally{
lock.unlock();
}
}
public void m4(){
try{
lock.lock();
System.out.println("当前线程："+Thread.currentThread().getName()+"唤醒...");
c1.signalAll();
}finally{
lock.unlock();
}
}
public void m5(){
try{
lock.lock();
System.out.println("当前线程："+Thread.currentThread().getName()+"唤醒...");
c2.signal();
}finally{
lock.unlock();
}
}
public static void main(String[] args) {
final UseManyCondition umc=new UseManyCondition();
Thread t1=new Thread(new Runnable() {
@Override
public void run() {
umc.m1();
}
},"t1");
Thread t2=new Thread(new Runnable() {
@Override
public void run() {
umc.m2();
}
},"t2");
Thread t3=new Thread(new Runnable() {
@Override
public void run() {
umc.m3();
}
},"t3");
Thread t4=new Thread(new Runnable() {
@Override
public void run() {
umc.m4();
}
},"t4");
Thread t5=new Thread(new Runnable() {
@Override
public void run() {
umc.m5();
}
},"t5");
t1.start();
t2.start();
t3.start();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
t4.start();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
t5.start();
}
}
输出结果：
当前线程：t2进入方法m2等待…
当前线程：t1进入方法m1等待…
当前线程：t3进入方法m3等待…
当前线程：t4唤醒…
当前线程：t2方法m2继续执行…
当前线程：t1方法m1继续执行…
当前线程：t5唤醒…
当前线程：t3方法m3继续执行…
总结：当m1，m2，m3同时等待的时候，m4唤醒的只有m1,m2。m5唤醒m3
await()相当于synchronized里面使用的wait();
signal()相当于synchronized里面使用的notify();
Lock/Condition其他方法和用法：
公平锁和非公平锁：公平锁浪费资源，非公平锁不需要维护是否公平所以性能高于公平锁。
Lock lock=new ReentrantLock(boolean isFair);
Lock用法：
tryLock():尝试获得锁，获得结果用true/false返回。true表示获得，false表示锁被占用。
tryLock():在给定的世界内尝试获得锁，获得结果用true/false返回
isFair():是否是公平锁。
isLocked():是否锁定。
getHoldCount():查询当前线程保持此锁的个数，也就是调用lock()次数。
lockInterruptibly():有限响应中断的锁。
getQueueLength():返回正在等待获取此锁的线程数。
getWaitQueueLength():返回等待与锁定相关的给定条件Condition的线程数。
hasQueuedThread(Thread thread):查询指定的线程是否正在等待此锁。
hasQueuedThreads():查询是否有线程正在等待此锁。
hasWaiters():查询是否有线程正在等待与此锁定有关的Condition条件。
二、ReentrantReadWriteLock读写锁
读写锁ReentrantReadWriteLock，其核心就是实现读写分离的锁，在高并发访问下，尤其是读多写少的情况下，性能要远高于重入锁。
synchronized、ReentrantLock，同一时间内，只能有一个线程进行访问被锁定的代码，那么读写锁则不同，其本质是分成两个锁，即读锁、写锁。在读锁下，多个线程可以并发的进行访问，但是在写锁的时候，只能一个一个的顺序访问。
口诀：读读共享，写写互斥，读写互斥。
示例：
/**
* 读写锁
* @author yanghz
* @createDate 2018年11月19日
*/
public class UseReentrantReadWriteLock {
private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
private ReadLock readLock = readWriteLock.readLock();
private WriteLock writeLock = readWriteLock.writeLock();
public void read() {
try {
readLock.lock();
System.out.println("当前线程：" + Thread.currentThread().getName() + "进入。。。");
Thread.sleep(3000);
System.out.println("当前线程：" + Thread.currentThread().getName() + "退出。。。");
} catch (Exception e) {
e.printStackTrace();
} finally {
readLock.unlock();
}
}
public void write() {
try {
writeLock.lock();
System.out.println("当前线程：" + Thread.currentThread().getName() + "进入。。。");
Thread.sleep(3000);
System.out.println("当前线程：" + Thread.currentThread().getName() + "退出。。。");
} catch (Exception e) {
e.printStackTrace();
} finally {
writeLock.unlock();
}
}
public static void main(String[] args) {
final UseReentrantReadWriteLock urr = new UseReentrantReadWriteLock();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
urr.read();
}
}, "t1");
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
urr.read();
}
}, "t2");
Thread t3 = new Thread(new Runnable() {
@Override
public void run() {
urr.write();
}
}, "t3");
Thread t4 = new Thread(new Runnable() {
@Override
public void run() {
urr.write();
}
}, "t4");
// t1.start();//R
// t2.start();//R
t3.start();//w
t4.start();//w
//RR
// 当前线程：t1进入。。。
// 当前线程：t2进入。。。
// 当前线程：t1退出。。。
// 当前线程：t2退出。。。
//RW
// 当前线程：t3进入。。。
// 当前线程：t3退出。。。
// 当前线程：t2进入。。。
// 当前线程：t2退出。。。
//WW
// 当前线程：t4进入。。。
// 当前线程：t4退出。。。
// 当前线程：t3进入。。。
// 当前线程：t3退出。。。
}
}
总结：分别对应RR、RW、WW执行输出的结果可以对应上口诀