Java多线程问题--方法isFair()、isHeldByCurrentThread()和isLocked()的用法和区别

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

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

方法isFair()、isHeldByCurrentThread()和isLocked()的用法和区别

1、lock.isFair()方法用来判断lock锁是公平锁还是非公平锁。公平锁是指，线程获得锁的顺序是按其等待锁的先后顺序来的，先来先获得FIFO。反之，非公平锁则是线程随机获得锁的，lock默认是非公平锁。

2、lock.isHeldByCurrentThread()的作用是查询当前线程是否保持此锁定，和lock.hasQueueThread()不同的地方是：lock.hasQueueThread(Thread thread)的作用是判断当前线程是否处于等待lock的状态。

3、lock.isLocked()的作用是查询此锁定是否由任意线程保持。

方法isFair()、isHeldByCurrentThread()和isLocked()的用法示例

ServiceIsFair.java

/**
 * lock.isFair()方法用来判断lock锁是公平锁还是非公平锁
 * @author: xianzhixianzhixian
 * @date: 2019-01-21 20:43
 */
public class ServiceIsFair {
    public ReentrantLock lock;

    public ServiceIsFair(Boolean isFair) {
        this.lock = new ReentrantLock(isFair);
    }

    public void serviceMethod(){
        try {
            lock.lock();
            System.out.println("公平锁情况："+lock.isFair());
        } finally {
            lock.unlock();
        }
    }
}

ServiceIsHeldByCurrentThread.java

/**
 * lock.isHeldByCurrentThread()的作用是查询当前线程是否保持此锁定
 * 和lock.hasQueueThread()不同的地方是：lock.hasQueueThread(Thread thread)的作用是判断当前线程是否处于等待lock的状态
 * @author: xianzhixianzhixian
 * @date: 2019-01-21 20:50
 */
public class ServiceIsHeldByCurrentThread {
    private ReentrantLock lock;

    public ServiceIsHeldByCurrentThread(Boolean isFair) {
        this.lock = new ReentrantLock(isFair);
    }

    public void serviceMethod(){
        try {
            System.out.println("lock.isHeldByCurrentThread() "+lock.isHeldByCurrentThread());
            lock.lock();
            System.out.println("lock.isHeldByCurrentThread() "+lock.isHeldByCurrentThread());
        } finally {
            lock.unlock();
        }
    }
}

ServiceIsLocked.java

/**
 * lock.isLocked()的作用是查询此锁定是否由任意线程保持
 * @author: xianzhixianzhixian
 * @date: 2019-01-21 20:54
 */
public class ServiceIsLocked {
    private ReentrantLock lock;

    public ServiceIsLocked(Boolean isFair) {
        this.lock = new ReentrantLock(isFair);
    }

    public void serviceMethod(){
        try {
            System.out.println("lock.isLocked() "+lock.isLocked());
            lock.lock();
            System.out.println("lock.isLocked() "+lock.isLocked());
        } finally {
            lock.unlock();
        }
    }
}

Run.java

/**
 * @author: xianzhixianzhixian
 * @date: 2019-01-21 20:59
 */
public class Run {
    public static void main(String[] args) throws Exception {
        final ServiceIsFair serviceIsFair0 = new ServiceIsFair(true);
        final ServiceIsFair serviceIsFair1 = new ServiceIsFair(false);
        Runnable runnable0 = new Runnable() {
            @Override
            public void run() {
                serviceIsFair0.serviceMethod();
            }
        };
        Runnable runnable1 = new Runnable() {
            @Override
            public void run() {
                serviceIsFair1.serviceMethod();
            }
        };
        Thread thread0 = new Thread(runnable0);
        thread0.start();
        Thread thread1 = new Thread(runnable1);
        thread1.start();



        final ServiceIsHeldByCurrentThread serviceIsHeldByCurrentThread = new ServiceIsHeldByCurrentThread(true);
        Runnable runnable2 = new Runnable() {
            @Override
            public void run() {
                serviceIsHeldByCurrentThread.serviceMethod();
            }
        };
        Thread thread2 = new Thread(runnable2);
        thread2.start();



        final ServiceIsLocked serviceIsLocked = new ServiceIsLocked(true);
        Runnable runnable3 = new Runnable() {
            @Override
            public void run() {
                serviceIsLocked.serviceMethod();
            }
        };
        Thread thread3 = new Thread(runnable3);
        thread3.start();
    }
}

运行结果：创建了两个锁，公平锁和非公平锁，所以lock.isFair()一个为true一个为false。在lock.lock()执行之前线程未获得锁，所以lock.isHeldByCurrentThread()结果为false，执行lock.lock()之后结果为true。在lock.lock()执行之前没有线程获得锁，所以lock.lock()为false；在执行lcok.lock()之后，当前有线程已经获得了锁，所以lock.lsLocked()为true。