多线程核心技术-Lock

（一）ReentrantLock

多线程中可以使用synchronized来进行线程同步互斥，在jdk1.5之后引入了ReentrantLock类，不仅可以实现synchronized的功能，还进行了拓展，下面简单写个Demo

MyService

public class MyService {
 
    private Lock lock = new ReentrantLock();
    // private Lock lock = new ReentrantLock(true);可设置公平锁，默认为非公平锁
    public void testMethod(){
        try {
            lock.lock();
            for (int i = 0; i < 5; i++) {
                System.out.println("ThreadName :" + Thread.currentThread().getName() + " " + (i + 1));
            }
        }finally {
            lock.unlock();
        }
    }
}

MyThread

public class MyThread extends Thread{
 
    private MyService service;
 
    public MyThread(MyService service) {
        this.service = service;
    }
 
    @Override
    public void run() {
        service.testMethod();
    }
}

Run

public class Run {
 
    public static void main(String[] args) {
        MyService service = new MyService();
        MyThread myThread1 = new MyThread(service);
        MyThread myThread2 = new MyThread(service);
        MyThread myThread3 = new MyThread(service);
        MyThread myThread4 = new MyThread(service);
        MyThread myThread5 = new MyThread(service);
        myThread1.start();
        myThread2.start();
        myThread3.start();
        myThread4.start();
        myThread5.start();
    }
 
}

打印结果是同步执行的

（二）使用Condition实现等待/通知

synchronized可以通过对象的wait()和notify()以及notifyAll()组合实现等待/通知模式，ReentrantLock同样可以实现，需要借助Condition对象，并且notify的对象是随机的，由JVM选择，但是Condition可以指定“唤醒”某线程

public class MyService {
 
    private Lock lock = new ReentrantLock();
 
    public Condition condition = lock.newCondition();
 
    public void await(){
        try {
            lock.lock();
            System.out.println(" await的时间为 :" + System.currentTimeMillis());
            condition.await();
            System.out.println("通知我要继续干活了");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
 
    public void signal(){
        try {
            lock.lock();
            System.out.println("signal的时间为 :" + System.currentTimeMillis());
            condition.signal();
        }finally {
            lock.unlock();
        }
    }
 
}

ThreadA

public class ThreadA extends Thread {
 
    private MyService service;
 
    public ThreadA(MyService service) {
        this.service = service;
    }
 
    @Override
    public void run() {
        service.await();
    }
}

Run类

public class Run {
 
    public static void main(String[] args)throws InterruptedException {
        MyService service = new MyService();
        ThreadA a = new ThreadA(service);
        a.start();
        Thread.sleep(3000);
        service.signal();
    }
 
}

运行结果打印为：

使用Condition需要注意，要在监视器对象中使用，如果不适用lock则会报无监视器对象的异常，lock最好放在finally代码块中确保释放，与wait对比

Object	Condition
wait(long timeout)	await(long time,TimeUnit unit)
wait()	await()
notifyAll()	signalAll()
notify()	signal()

不同的Condition对象可以指定唤醒

ReentrantLock的相关api

方法	入参类型	返回值类型	作用
getHoldCount()	/	int	查询当前线程保持此锁的个数，也是调用lock方法的次数
getQueueLength()	/	int	返回整等待获取此锁定的线程估计数
getWaitQueueLength()	Condition	int	查询等待次锁定相关的给定条件Condition的线程估计数
hasQueuedThread()	Thread	boolean	查询指定线程是否正在等待获取此锁
hasQueuedThreads()	/	boolean	查询是否有线程正在等待获取此锁
hasWaiters()	Condition	boolean	是否有线程正在等待与此锁定有关的condition条件
isFair()	/	boolean	判断是否是公平锁
isHeldByCurrentThread()	/	boolean	查询当前线程是否保持此锁
isLocked()	/	boolean	查询此锁定是否有人以线程保持
lockInterruptibly()	/	/	如果当前线程未被中断则获取锁，已经被中断则抛异常
tryLock()	/	boolean	仅在调用时锁定未被另一个线程保持的情况下，才获取该锁定
tryLock()	long,TimeUnit	boolean	如果锁定在给定时间内没有被另一个线程保持，且当前线程未被中断，则获取该锁定

三）ReentrantReadWriteLock-读写锁

读写锁几个特性：读读共享，写写互斥，读写互斥，写读互斥，可参考下面代码

MyService

public class MyService {
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
 
    public void read(){
        try{
            try {
                lock.readLock().lock();
                System.out.println("我获取读锁" + Thread.currentThread().getName() + System.currentTimeMillis());
                Thread.sleep(10000);
            }finally {
                lock.readLock().unlock();
            }
        }catch(InterruptedException e){
            e.printStackTrace();
        }
    }
 
    public void write(){
        try{
            try {
                lock.writeLock().lock();
                System.out.println("我获取写锁" + Thread.currentThread().getName() + System.currentTimeMillis());
                Thread.sleep(10000);
            }finally {
                lock.writeLock().unlock();
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

ThreadA和ThreadB

public class ThreadA extends Thread {
 
    private MyService service;
 
    public ThreadA(MyService service) {
        this.service = service;
    }
 
    @Override
    public void run() {
        service.read();
    }
}
  
public class ThreadB extends Thread {
    private MyService service;
 
    public ThreadB(MyService service) {
        this.service = service;
    }
 
    @Override
    public void run() {
        service.write();
    }
}

Run

public class Run {
 
    public static void main(String[] args) {
        MyService service = new MyService();
        ThreadA threadA  = new ThreadA(service);
        ThreadA threadAA = new ThreadA(service);
        ThreadB threadB = new ThreadB(service);
//        threadB.start();
        threadA.start();
        threadAA.start();
    }
}

可以通过修改Run类的方法，进行验证四个特性