Java多线程--Lock的使用

（转自：https://blog.csdn.net/jihaitaowangyi/article/details/52852693 侵删）

ReentrantLock也能够让代码块原子执行，但是比synchronized更加强大，ReentrantLock具有嗅探锁定、多路分支通知等功能。 
嗅探锁定：是指获取锁时如果锁已经被其他线程获取到ReentrantLock可以进行指定等待时间获取锁或者 
多路分支通知：是指线程发生await时，线程可以选择注册在不同的监视器Condition对象上，在适当的时候可以选择指定的监视器Condition对象上的线程进行signal通知、执行

1、多线程执行同一代码块互斥

import java.util.concurrent.locks.ReentrantLock;

class MyService {

    private ReentrantLock lock = new ReentrantLock();

    public void method() {
        try {
            lock.lock();
            for (int i = 1; i <= 3; i++) {
                Thread.sleep(1000);
                System.out.println("ThreadName=" + Thread.currentThread().getName() + " " + i);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

class MyThread extends Thread {

    private MyService service;

    MyThread(MyService service) {
        this.service = service;
    }

    @Override
    public void run() {
        service.method();
    }
}

public class Test {

    public static void main(String[] args) {
        MyService service = new MyService();
        MyThread myThread1 = new MyThread(service);
        MyThread myThread2 = new MyThread(service);

        myThread1.start();
        myThread2.start();
    }
}

结果 
ThreadName=Thread-0 1 
ThreadName=Thread-0 2 
ThreadName=Thread-0 3 
ThreadName=Thread-1 1 
ThreadName=Thread-1 2 
ThreadName=Thread-1 3

2、多线程执行不同代码块互斥

import java.util.concurrent.locks.ReentrantLock;

class MyService {
    private ReentrantLock lock = new ReentrantLock();

    public void methodA() {
        lock.lock();
        try {
            System.out.println("MethodA begin ThreadName=" + Thread.currentThread().getName());
            for (int i = 1; i <= 3; i++) {
                System.out.println("ThreadName=" + Thread.currentThread().getName() + " " + i);
                Thread.sleep(1000);
            }
            System.out.println("MethodA end ThreadName=" + Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void methodB() {
        lock.lock();
        try {
            System.out.println("MethodB begin ThreadName=" + Thread.currentThread().getName());
            for (int i = 1; i <= 3; i++) {
                System.out.println("ThreadName=" + Thread.currentThread().getName() + " " + i);
                Thread.sleep(1000);
            }
            System.out.println("MethodB end ThreadName=" + Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

class ThreadA extends Thread {

    private MyService service;

    ThreadA(MyService service) {
        this.service = service;
    }

    @Override
    public void run() {
        service.methodA();
    }
}

class ThreadB extends Thread {

    private MyService service;

    ThreadB(MyService service) {
        this.service = service;
    }

    @Override
    public void run() {
        service.methodB();
    }
}

public class Test {

    public static void main(String[] args) {
        MyService service = new MyService();
        ThreadA threadA = new ThreadA(service);
        threadA.setName("A");

        ThreadB threadB = new ThreadB(service);
        threadB.setName("B");
        threadA.start();
        threadB.start();
    }
}

结果： 
MethodA begin ThreadName=A 
ThreadName=A 1 
ThreadName=A 2 
ThreadName=A 3 
MethodA end ThreadName=A 
MethodB begin ThreadName=B 
ThreadName=B 1 
ThreadName=B 2 
ThreadName=B 3 
MethodB end ThreadName=B

3、多路通知

当多线程进入await状态时，利用Condition监视器对不同类型线程通知

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

class MyService {
    private ReentrantLock lock = new ReentrantLock();
    private Condition conditionA = lock.newCondition();
    private Condition conditionB = lock.newCondition();

    public void methodA() {
        lock.lock();
        try {
            System.out.println("MethodA begin ThreadName=" + Thread.currentThread().getName() + " " + System.currentTimeMillis());
            conditionA.await();
            System.out.println("MethodA end ThreadName=" + Thread.currentThread().getName() + " " + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void methodB() {
        lock.lock();
        try {
            System.out.println("MethodB begin ThreadName=" + Thread.currentThread().getName() + " " + System.currentTimeMillis());
            conditionB.await();
            System.out.println("MethodB end ThreadName=" + Thread.currentThread().getName() + " " + System.currentTimeMillis());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void signalA() {
        lock.lock();
        conditionA.signal();
        lock.unlock();
    }
    public void signalA_All() {
        lock.lock();
        conditionA.signalAll();
        lock.unlock();
    }


    public void signalB() {
        lock.lock();
        conditionB.signal();
        lock.unlock();
    }
    public void signalB_All() {
        lock.lock();
        conditionB.signalAll();
        lock.unlock();
    }
}

class ThreadA extends Thread {

    private MyService service;

    ThreadA(MyService service) {
        this.service = service;
    }

    @Override
    public void run() {
        service.methodA();
    }
}

class ThreadB extends Thread {

    private MyService service;

    ThreadB(MyService service) {
        this.service = service;
    }

    @Override
    public void run() {
        service.methodB();
    }
}

public class Test {

    public static void main(String[] args) throws InterruptedException {
        MyService service = new MyService();
        ThreadA threadA = new ThreadA(service);
        threadA.setName("A");

        ThreadB threadB = new ThreadB(service);
        threadB.setName("B");
        threadA.start();
        threadB.start();

        Thread.sleep(1000);
        service.signalA();
        Thread.sleep(1000);
        service.signalB();

// ThreadA[] threadAs = new ThreadA[10];
// for (int i=0;i<5;i++){
// threadAs[i] = new ThreadA(service);
// }
// ThreadB[] threadBs = new ThreadB[10];
// for (int i=0;i<5;i++){
// threadBs[i] = new ThreadB(service);
// }
//
// for (int i=0;i<5;i++){
// threadAs[i].start();
// threadBs[i].start();
// }
//
// Thread.sleep(1000);
// service.signalA_All();
// Thread.sleep(1000);
// service.signalB_All();
    }
}

测试结果1： 
MethodA begin ThreadName=A 1476800025028 
MethodB begin ThreadName=B 1476800025029 
MethodA end ThreadName=A 1476800026028 
MethodB end ThreadName=B 1476800027028

修改代码为：

 public static void main(String[] args) throws InterruptedException {
        MyService service = new MyService();
// ThreadA threadA = new ThreadA(service);
// threadA.setName("A");
//
// ThreadB threadB = new ThreadB(service);
// threadB.setName("B");
// threadA.start();
// threadB.start();
//
// Thread.sleep(1000);
// service.signalA();
// Thread.sleep(1000);
// service.signalB();

        ThreadA[] threadAs = new ThreadA[10];
        for (int i=0;i<5;i++){
            threadAs[i] = new ThreadA(service);
        }
        ThreadB[] threadBs = new ThreadB[10];
        for (int i=0;i<5;i++){
            threadBs[i] = new ThreadB(service);
        }

        for (int i=0;i<5;i++){
            threadAs[i].start();
            threadBs[i].start();
        }

        Thread.sleep(1000);
        service.signalA_All();
        Thread.sleep(1000);
        service.signalB_All();
    }

结果为： 
MethodA begin ThreadName=Thread-0 1476800227416 
MethodB begin ThreadName=Thread-7 1476800227417 
MethodB begin ThreadName=Thread-5 1476800227417 
MethodA begin ThreadName=Thread-3 1476800227418 
MethodA begin ThreadName=Thread-1 1476800227418 
MethodA begin ThreadName=Thread-4 1476800227418 
MethodB begin ThreadName=Thread-6 1476800227418 
MethodA begin ThreadName=Thread-2 1476800227418 
MethodB begin ThreadName=Thread-8 1476800227418 
MethodB begin ThreadName=Thread-9 1476800227418 
MethodA end ThreadName=Thread-0 1476800228419 
MethodA end ThreadName=Thread-3 1476800228419 
MethodA end ThreadName=Thread-1 1476800228419 
MethodA end ThreadName=Thread-4 1476800228420 
MethodA end ThreadName=Thread-2 1476800228420 
MethodB end ThreadName=Thread-7 1476800229419 
MethodB end ThreadName=Thread-5 1476800229419 
MethodB end ThreadName=Thread-6 1476800229419 
MethodB end ThreadName=Thread-8 1476800229419 
MethodB end ThreadName=Thread-9 1476800229419

4、公平所与非公平锁 
公平锁是指线程获（getting）取锁的顺序和线程锁定（got）的顺序相同，

Lock的一些方法说明 
A） getHoldCount() 
获取当前锁定（got）的个数 
B）getQueueLength() 
获取当前正在等待获取（getting）锁的线程数（Threads） 
C）getWaitQueueLength(Condition) 
返回等待（await）与此锁定（got）的Condition相关的个数