锁 LOCK

在java多线程中，我们知道可以使用synchronized关键字来实现线程间的同步互斥工作，那么其实还有一个更优秀的机制去完成这个“同步互斥”工作, 他就是Lock对象，我们主要学习两种锁，重入锁和读写锁。他们具有比synchronized更为强大的功能，并且有嗅探锁定、多路分支等功能。

自旋锁

偏向锁

 ReentrantLock (重入锁)

重入锁（与同步锁synchronized类似），在需要进行同步的代码部分加上锁定，但不要忘记最后一定要释放

锁定，不然会造成锁永远无法释放，其他线程永远进不来的结果。

使用lock都使用try  catch finally 在finally中进行释放

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 (InterruptedException e) {

e.printStackTrace();

} 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 (InterruptedException e) {

e.printStackTrace();

} 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();

try {

Thread.sleep(10);

} catch (InterruptedException e) {

e.printStackTrace();

}

//System.out.println(ur.lock.getQueueLength());

}

}

还记得我们在使用synchronized的时候，如果需要多线程间进行协作工作则

在JDK1.8之前ReentrantLock 比synchronized强大，JDK1.8 synchronized做了优化，

ReentrantLock 比synchronized更灵活

需要Object的wait()和notify()、notifyAll()方 法进行配合工作。那么同样，我们在使用Lock的时候，可以使用一个新的等待/通知的类，它就是Condition（条件）。这个Condition 一定是针对具体某一把锁的。 也就是在只有锁的基础之上才会产生Condition.

package com.bjsxt.height.lock020;

import java.util.concurrent.CopyOnWriteArrayList;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

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(); // Object wait

System.out.println("当前线程：" + Thread.currentThread().getName() +"继续执行...");

} catch (Exception 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(); //Object notify

} catch (Exception e) {

e.printStackTrace();

} finally {

lock.unlock();

}

}

public static void main(String[] args) {

final UseCondition uc = new UseCondition();

Thread t1 = new Thread(new Runnable() {

@Override

public void run() {

uc.method1();

}

}, "t1");

Thread t2 = new Thread(new Runnable() {

@Override

public void run() {

uc.method2();

}

}, "t2");

t1.start();

t2.start();

}

}

package com.bjsxt.height.lock020;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

public class UseManyCondition {

private ReentrantLock 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 (Exception 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 (Exception 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 (Exception e) {

e.printStackTrace();

} finally {

lock.unlock();

}

}

public void m4(){

try {

lock.lock();

System.out.println("当前线程：" +Thread.currentThread().getName() + "唤醒..");

c1.signalAll();

} catch (Exception e) {

e.printStackTrace();

} finally {

lock.unlock();

}

}

public void m5(){

try {

lock.lock();

System.out.println("当前线程：" +Thread.currentThread().getName() + "唤醒..");

c2.signal();

} catch (Exception e) {

e.printStackTrace();

} 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(); // c1

t2.start(); // c1

t3.start(); // c2

try {

Thread.sleep(2000);

} catch (InterruptedException e) {

e.printStackTrace();

}

t4.start(); // c1

try {

Thread.sleep(2000);

} catch (InterruptedException e) {

e.printStackTrace();

}

t5.start(); // c2

}

}

Conditon中的await()对应Object的wait()；

Condition中的signal()对应Object的notify()；

Condition中的signalAll()对应Object的notifyAll()。

9.5 Lock/Condition其他方法和用法。

公平锁和非公平锁:

Lock lock = new ReentrantLock(boolean isFair); 默认true公平，false非公平

lock用法:

tryLock():尝试获得锁，获得结果用true/false返回。占用返回false，获取到了返回true

tryLock():在给定的时间内尝试获得锁，获得结果用truelfalse返回。

isFair():是否是公平锁.

isLocked():是否锁定-

getHoldCount():查询当前线程保持此锁的个数，也就是调用lock()次数。

locklnterruptibly():优先响应中断的锁。

getQueueLength():返回正在等待获取此锁定的线程数。

getWaitQueueLength():返回等待与锁定相关的给定条件Condition的线程数.

hasQueuedThread(Thread thread):查询指定的线程是否正在等待此锁。

hasQueuedThreads():查询是否有线程正在等待此锁。

hasWaiters():查询是否有线程正在等待与此锁定有关的condition条件。

 ReentrantReadWriteLock（读写锁）

读写锁ReentrantReadWriteLock，其核心就是实现读写分离的锁。在高并

发访问下，尤其是读多写少的情况下，性能要远高于重入锁。

之前学synchronized、ReentrantLock时，我们知道，同一时间内，只能有

一个线程进行访问被锁定的代码，那么读写锁则不同，其本质是分成两个锁，

即读锁、写锁。在读锁下，多个线程可以并发的进行访问，但是在写锁的时

候，只能一个一个的顺序访问。

口诀:读读共享，写写互斥，读写互斥。

package com.bjsxt.height.lock021;

import java.util.concurrent.locks.ReentrantReadWriteLock;

import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;

import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;

public class UseReentrantReadWriteLock {

private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();

private ReadLock readLock = rwLock.readLock();

private WriteLock writeLock = rwLock.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 urrw = new UseReentrantReadWriteLock();

Thread t1 = new Thread(new Runnable() {

@Override

public void run() {

urrw.read();

}

}, "t1");

Thread t2 = new Thread(new Runnable() {

@Override

public void run() {

urrw.read();

}

}, "t2");

Thread t3 = new Thread(new Runnable() {

@Override

public void run() {

urrw.write();

}

}, "t3");

Thread t4 = new Thread(new Runnable() {

@Override

public void run() {

urrw.write();

}

}, "t4");

// t1.start();

// t2.start();

// t1.start(); // R

// t3.start(); // W

t3.start();

t4.start();

}

}

9.7锁优化总结

1避免死锁

2减小锁的持有时间

3减小锁的粒度

4锁的分闻

5尽量使用无锁的操作，如原子操作Atomic系列类），volatile关键字

分布式锁

一般依赖于框架（zookeeper框架）