java中公平锁与非公平锁测试

[faith.huan]

按照公平锁/非公平锁解释, 公平锁是按照线程加锁的顺序获得锁,非公平锁在锁可用时,所有等待锁的线程随机获得锁.
为何采用非公平锁,效果依然是按照线程启动顺序获得锁呢,代码如下:

package chapter4;

import java.util.concurrent.locks.ReentrantLock;

/**
 * 测试公平锁与非公平锁
 *
 * @author faith.huan 2019-05-07 9:57
 */
public class FairLock {

    static class MyService{

        private ReentrantLock lock;

        public MyService(ReentrantLock lock) {
            this.lock = lock;
        }

        public void serviceMethod(){
            try {
                lock.lock();
                System.out.println("ThreadName " + Thread.currentThread().getName() + " 获得锁");
                Thread.sleep(1000);
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }

        public void lockOneSecond(){
            lock.lock();
            try {
                System.out.println("lock begin ");
                Thread.sleep(1000);
                System.out.println("lock end ");
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                lock.unlock();
                System.out.println("release lock");
            }
        }

    }

    static class MyThread extends Thread{

        private MyService myService;

        public MyThread(String name, MyService myService) {
            super(name);
            this.myService = myService;
        }

        @Override
        public void run() {
            System.out.println(currentThread().getName() + "开始运行.");
            myService.serviceMethod();
        }
    }


    public static void main(String[] args) throws InterruptedException {
        MyService myService = new MyService(new ReentrantLock(false));

        // 起一个线程先抢占锁1秒钟
        new Thread(()->{
            myService.lockOneSecond();
        }).start();

        // 创建10个线程
        int num =10;
        Thread[] threads = new Thread[num];
        for (int i = 0; i < num; i++) {
            threads[i]=new MyThread("T"+i,myService);
        }
        Thread.sleep(10);

        // 依次启动线程,启动一个后休眠50ms,保证线程按照顺序启动(数字小的线程优先抢占锁)
        for (int i = 0; i < num; i++) {
            threads[i].start();
            Thread.sleep(50);
        }

    }
}

[zhouixi]

两者最大的区别在于，比如生少中随机抢号，顺序排队取号一样的意思。