多线程之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()//判断锁是否被线程持有