常用锁对象的方法

Lock:

　　getHoldCount()： 获取当前线程调用lock()方法的次数

import java.util.concurrent.locks.ReentrantLock;

public class Service {
    private ReentrantLock lock = new ReentrantLock();
    
    public void serviceMethod1() {
        try {
            lock.lock();
            
            System.out.println("serviceMethod getHoldCount=" + lock.getHoldCount());
            serviceMethod2();
        } finally {
            lock.unlock();
        }
    }

    private void serviceMethod2() {
        try {
            lock.lock();
            System.out.println("serviceMethod getHoldCount=" + lock.getHoldCount());
        } finally {
            lock.unlock();
        }
    }
}

/**
 *    测试类
 */
public class Run {

    /**
     *    getHoldCount() 查询当前线程保持此锁定的个数，即调用lock()方法的次数
     */
    public static void main(String[] args) {
        Service service = new Service();
        service.serviceMethod1();
    }
}

运行结果如下：

　　

　　getQueueLength()：获取等待获取锁的线程估计数

import java.util.concurrent.locks.ReentrantLock;

public class Service {
    
    public ReentrantLock lock = new ReentrantLock();
    
    public void serviceMethod() {
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName() + "进入方法");
            Thread.sleep(Integer.MAX_VALUE);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

/**
 * getQueueLength()测试类
 */
public class Run {
    
    public static void main(String[] args) {
        final Service service = new Service();
        
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                service.serviceMethod();
            }
        };
        
        Thread[] threads = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threads[i] = new Thread(runnable);
        }
        for (int i = 0; i < 10; i++) {
            threads[i].start();
        }
        
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.err.println("有" + service.lock.getQueueLength() + "在等待获取锁" );
    }
}

运行结果如下：

　　

 　　getWaitQueueLength()：获取等待与此锁定相关的给定条件的condition的线程估计数(也就是获取同一个锁的线程中于condition相关的线程数)

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

public class Service {
    
    private ReentrantLock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    
    public void waitMethod() {
        try {
            lock.lock();
            condition.await();
            System.out.println("被唤醒的线程是：" + Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    
    public void notityMethod() {
        try {
            lock.lock();
            System.out.println("有" + lock.getWaitQueueLength(condition) + "个线程正在等待condition");
            condition.signal();
        }finally {
            lock.unlock();
        }
    }
}

/**
 *    getWaitQueueLength(condition)测试类
 */
public class Run {
    
    public static void main(String[] args) {
        final Service service = new Service();
        
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                service.waitMethod();
            }
        };
        
        Thread[] threads = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threads[i] = new Thread(runnable);
        }
        for (int i = 0; i < 10; i++) {
            threads[i].start();
        }
        
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        service.notityMethod();
    }
}

运行结果如下：

　　

其他方法介绍：

hasQueueThread()                         查询指定的线程是否正在等待获取锁
hasQueueThreads()  　　　　　　　　　　　　  查询是否有线程正在等待获取锁
hasWaiters()            　　　　　　　　　　查询是否有线程正在等待锁有关的condition(也就是当前通过condition进行等待的线程数)
isFair()        　　　　　　　　　　　　　　　判断是不是公平锁
isHeldByCurrentThread() 　　　　　　　　　　查询当前线程是否获取到锁
isLocked()        　　　　　　　　　　　　　 查询此锁是否可以由任意线程获取,也就是当前是否被某个线程获取了锁

lockInterruptibly()　　　　　　　　　　　　　如果当前线程未被中断，则获取锁，如果已中断则抛异常
tryLock()            　　　　　　　　　　　　仅在调用的时候锁未被另一个线程获取的情况下，才能获取该锁
tryLock(Long timeout, TimeUnit unit)     如果在指定时间内，没有被另一个线程获取，且当前线程未被中断，则获取锁


awaitUninterruptibly()    当使用该方法等待时，此时使用interrupt()中断该线程，程序不会抛异常
awaitUnit()               设置线程等待的时间,当等待时间到达后继续执行，此方法等待达到之前，可以被其他线程唤醒