多线程之Lock显示锁
ThreadLocal的使用
除了控制资源访问外，还可以通过增加资源来保证线程安全，ThreadLocal主要解决为每个线程绑定自己的值，相当于增加了一个副本，在进行数据库访问的时候，多个线程需要自己独立的 static 成员变量吗，那就需要使用ThreadLocal。
什么是Lock显示锁
锁分为内部锁和外部锁，内部锁是通过synchronized实现的，显示锁lock是在JDK5中新增的，最常见的实现类是 ReentrantLock、ReadLock、WriteLock，可以起到 “锁” 的作用，由ReentrantLock实现类，ReentrantLock锁被称为可重入锁，它的功能比synchronized多。
Lock接口有5个方法1个条件，
public void lock() { }
public void lockInterruptibly() throws InterruptedException { }
public boolean tryLock() { }
public boolean tryLock(long timeout, TimeUnit unit){ }
public void unlock() { }
public Condition newCondition() { }
Lock锁的使用
Lock 有 4 种加锁方法，其中 lock 是最基础的。Lock 获取锁和释放锁都是显式的，不像 synchronized 是隐式的。所以 synchronized 会在抛异常时自动释放锁，而 Lock 只能是主动释放，加解锁都必须有显式的代码控制。
lock()、unlock()方法
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Text21 {
public static void main(String[] args) {
Runnable r=new Runnable() {
@Override
public void run() {
sm();
}
};
new Thread(r).start();
new Thread(r).start();
new Thread(r).start();
}
public static Lock lock=new ReentrantLock();
public static void sm()
{
lock.lock();//获得锁
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName()+"-->"+i);
}
lock.unlock();//释放锁
}
}
lock的获得和释放就相当于synchronized代码块
trylock(定时锁)方法
trylock（long time,TimeUnit unit）的作用在给定的等待时长内锁没有被另外的线程持有，并且当前线程也没有被中断，则获得该锁，通过该方法可以实现锁对象的限时等待
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
public class TryLockText {
public static void main(String[] args) {
TimeLock timeLock=new TimeLock();
Thread t1=new Thread(timeLock);
Thread t2=new Thread(timeLock);
t1.start();
t2.start();
}
static class TimeLock implements Runnable
{
static ReentrantLock reentrantLock=new ReentrantLock();
@Override
public void run() {
try {
if(reentrantLock.tryLock(3, TimeUnit.SECONDS))//3秒内获得锁返回true
{
System.out.println(Thread.currentThread().getName()+"获得锁");
Thread.sleep(4000);
}
else
System.out.println(Thread.currentThread().getName()+"没有获得锁");
} catch (InterruptedException e) {
e.printStackTrace();
}
finally {
if(reentrantLock.isHeldByCurrentThread())//如果锁被当前线程持有
{
reentrantLock.unlock();//释放锁
}
}
}
}
}
Thread-0在获得锁之后休眠了4秒，Thread-1尝试等待3秒获得锁，还没有获得就不会继续等待了，释放锁了。
trylock（）
仅在调用的时候锁定未被其他线程持有的锁，如果调用此方法时，被其他方法占用则放弃返回false.
trylock可以用来避免死锁，线程在获取在尝试获取Thread-0，获取不到一直尝试获取，获取到了继续获取Thread-1，如果获取不到Thread-1就会释放Thread-0，这样避免了死锁，两个锁都不会被对方占用而无法释放。
lockInterruptibly方法
lockInterruptibly方法表示当前线程没有被中断就可以获得锁，如果中断就会产生异常
一个线程在等待锁，只有两种结果，要么获得锁继续执行，要么就是在等待锁，可以理解为不限时的trylock，对于可重入锁来说还有一种可能，就是在需要的时候取消对锁的请求。
通过在使用lock的时候，lockInterruptibly方法也可以避免死锁的产生
newCondition方法
关键字synchronized与wait、notify这两个方法一起使用可以实现等待/通知模式，Lock的newCondition方法返回Condition对象，Condition类也可以实现等到/通知模式。
使用notify通知时，JVM会随机唤醒，Condition类可以进行选择性通知，比较常用的两个方法：
await():会使当前线程等待，同时释放锁
signal()：用于唤醒一个线程
注意：在调用Condition的await、signal方法前也需要线程持有相关的锁。例如
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ConditionText {
public static void main(String[] args) throws InterruptedException {
Text24 text24=new Text24();
text24.start();
Thread.sleep(3000);//睡眠三秒唤醒子线程
lock.lock();//指定锁 并锁住
condition.signal();//在唤醒之前需要持有锁
lock.unlock();
}
static Lock lock=new ReentrantLock();
static Condition condition=lock.newCondition();
static class Text24 extends Thread
{
@Override
public void run() {
lock.lock();
System.out.println("begin---》");
try {
condition.await();
System.out.println("wait--》");
} catch (InterruptedException e) {
e.printStackTrace();
}
finally {
lock.unlock();
System.out.println("解锁成功");
}
}
}
}
公平锁与非公平锁
大多数情况下，锁的申请都是非公平的，如果i当线程1线程2都在请求锁A，当锁A可用时，系统只是会从阻塞队列中随机的选择一个线程，并不能保证公平性。
公平的锁会按照时间的先后顺序，保证先到先得，公平锁这一特点不会出现线程饥饿现象。
synchronized内部锁就是非公平的，Reentrantlock（boolean fair），在创建锁的时候可以传递实参为true，就可以实现公平锁。
import java.util.concurrent.locks.ReentrantLock;
public class Text25 {
static ReentrantLock lock=new ReentrantLock();
public static void main(String[] args) {
Runnable runnable=new Runnable() {
@Override
public void run() {
while (true)
{
lock.lock();
System.out.println(Thread.currentThread().getName()+"获得了锁对象");
lock.unlock();
}
}
};
for (int i = 0; i < 5; i++) {
new Thread(runnable).start();
}
}
}
这里一直是同一个线程一直获得锁对象，而不是差不多分配好的。这里明显的是非公平锁，系统倾向于再次获得已经持有的锁，这种分配是高效的但是非公平。
为了实现公平锁，只需要在ReentrantLock方法传入参数true，表示实现公平锁
但是要实现公平锁，必须要求系统维护一个有序对队列，实现成本较高，不是特别的需求，一般不使用公平锁。
Reentrantlock常用方法
int getHoldCount()//可以返回调用lock()方法的次数
int getQueueLength()//可以返回等待获得锁的线程预估数量
int getWaitQueueLength()//返回Condition条件相关的线程预估数量
boolean hasQueuedThread()//查询指定的线程是否还有线程在等待获得该锁
boolean hasWaiters()//查询线程是否有线程正在等待指定以Condition
boolean isHeldByCurrentThread()//判断当前线程是否持有该锁
boolean isLocked()//判断锁是否被线程持有
