Java多线程问题--方法hasQueueThread(Thread thread)、hasQueueThreads()和hasWaiters(Condition condition)的用法和区别

本文内容部分引自《Java多线程编程核心技术》，感谢作者！！！

代码地址：https://github.com/xianzhixianzhixian/thread.git

方法hasQueueThread(Thread thread)、hasQueueThreads()和hasWaiters(Condition condition)的用法和区别

1、方法lock.hasQueueThread(Thread thread)的作用是查询指定的线程是否在等待获取此锁，就是当前该线程是否处于等待获取该锁的状态

2、方法lock.hasQueueThreads()的作用是检测当前是否有线程在等待获取该锁

3、方法lock.hasWaiters(Condition condition)的作用是检测当前是否有线程已调用condition.await()并且处于await状态

方法hasQueueThread(Thread thread)、hasQueueThreads()用法示例

Service.java

/**
 * 方法lock.hasQueueThread(Thread thread)的作用是查询指定的线程是否在等待获取此锁定，就是当前该线程是否处于未获取锁的状态
 * 方法lock.hasQueueThreads()的作用是检测当前是否有线程在等待获取该锁定
 * @author: xianzhixianzhixian
 * @date: 2019-01-16 20:15
 */
public class Service {
    public ReentrantLock lock = new ReentrantLock();
    public Condition condition = lock.newCondition();
    public void lockMethod(){
        try {
            lock.lock();
            Thread.sleep(Integer.MAX_VALUE);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

Run.java

/**
 * @author: xianzhixianzhixian
 * @date: 2019-01-16 20:37
 */
public class Run {
    public static void main(String[] args) throws Exception {
        final Service service = new Service();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                service.lockMethod();
            }
        };
        Thread threadA = new Thread(runnable);
        threadA.start();
        Thread.sleep(500);
        Thread threadB = new Thread(runnable);
        threadB.start();
        Thread.sleep(500);
        System.out.println(service.lock.hasQueuedThread(threadA));
        System.out.println(service.lock.hasQueuedThread(threadB));
        System.out.println(service.lock.hasQueuedThreads());
    }
}

运行结果：线程A先启动占用了锁，线程B则一直处于等待锁的状态。所以第一行是false，第二行是true。当前有线程在等待锁，第三行为true。

方法hasWaiters(Condition condition)用法示例

ServiceHasWaiters.java

/**
 * 方法lock.hasWaiters(Condition condition)的作用是检测当前是否有线程已调用condition.await()并且处于await状态
 * @author: xianzhixianzhixian
 * @date: 2019-01-16 21:19
 */
public class ServiceHasWaiters {
    private ReentrantLock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    public void waitMethod(){
        try {
            lock.lock();
            condition.await();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void notifyMethod(){
        try {
            lock.lock();
            System.out.println("有没有线程正在等待condition？"
                        +lock.hasWaiters(condition)+"线程数是多少？"
                        +lock.getWaitQueueLength(condition));
            condition.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

Run.java

/**
 * @author: xianzhixianzhixian
 * @date: 2019-01-16 20:37
 */
public class Run {
    public static void main(String[] args) throws Exception {
        final ServiceHasWaiters serviceHasWaiters = new ServiceHasWaiters();
        Runnable runnableHasWaiters = new Runnable() {
            @Override
            public void run() {
                serviceHasWaiters.waitMethod();
            }
        };
        Thread[] threadArray = new Thread[10];
        for (int i = 0; i < 10; i++) {
            threadArray[i] = new Thread(runnableHasWaiters);
        }
        for (int i = 0; i < 10; i++) {
            threadArray[i].start();
            serviceHasWaiters.notifyMethod();
        }
        Thread.sleep(2000);
        serviceHasWaiters.notifyMethod();
    }
}

运行结果：因为线程在start之后有可能会被立即唤醒，所以结果中出现了为0为1的情况，这也证实了lock.hasWaiters(Condition condition)统计的是是否有处于wait状态的线程。