并发编程学习之三：公平锁

深碍√TFBOYSˉ_ 2023-01-23 01:59 123阅读 0赞

学习一下公平锁，先看代码：

public class FairLock implements Runnable {
    
        public static ReentrantLock fairLock = new ReentrantLock(true);
    
        @Override
        public void run() {
            while (true) {
                try {
                    fairLock.lock();
                    System.out.println(Thread.currentThread().getName() + ":获得锁");
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    fairLock.unlock();
                }
            }
        }
    
        public static void main(String[] args) {
            FairLock r1 = new FairLock();
            Thread t1 = new Thread(r1, "Thread_t1");
            Thread t2 = new Thread(r1, "Thread_t2");
            t1.start();
            t2.start();
        }
    }

public static ReentrantLock fairLock = new ReentrantLock(true);

这里可以看出 这里出入 true ，说明是一个公平锁。

公平锁看起来很优美，但是要实现公平锁必然要求要维护一个有序队列，因此公平锁的实现成本比较高，性能却非常低下，因此在默认情况下，锁是非公平的。如果没有特别的要求，则不需要使用公平锁。

以上代码就是一个公平锁，我们来看一下他的输出结果：

Thread\_t1:获得锁  
Thread\_t2:获得锁  
Thread\_t1:获得锁  
Thread\_t2:获得锁  
Thread\_t1:获得锁  
Thread\_t2:获得锁  
Thread\_t1:获得锁  
Thread\_t2:获得锁  
Thread\_t1:获得锁  
Thread\_t2:获得锁  
Thread\_t1:获得锁  
Thread\_t2:获得锁  
Thread\_t1:获得锁  
Thread\_t2:获得锁  
Thread\_t1:获得锁  
Thread\_t2:获得锁  
Thread\_t1:获得锁  
Thread\_t2:获得锁  
Thread\_t1:获得锁  
Thread\_t2:获得锁  
Thread\_t1:获得锁  
Thread\_t2:获得锁

因为这里睡while (true) 所以有很多，这里我们直接去了一部分结果，从这里就可以看出，这个锁是非常公平的， t1和t2交替出现，几率都是50%

而如果换成了非公平锁呢，看下面的代码：

public class FairLock implements Runnable {
    
        public static ReentrantLock fairLock = new ReentrantLock(false);// 只有这里变成了false
    
        @Override
        public void run() {
            while (true) {
                try {
                    fairLock.lock();
                    System.out.println(Thread.currentThread().getName() + ":获得锁");
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    fairLock.unlock();
                }
            }
        }
    
        public static void main(String[] args) {
            FairLock r1 = new FairLock();
            Thread t1 = new Thread(r1, "Thread_t1");
            Thread t2 = new Thread(r1, "Thread_t2");
            t1.start();
            t2.start();
        }
    }

看一下输出结果：

Thread\_t2:获得锁

.....(这里省略了很多的 Thread\_t2:获得锁 )

Thread\_t2:获得锁

Thread\_t1:获得锁 （这里终于出现了 Thread\_t1:获得锁）

Thread\_t1:获得锁

。。。。。这里又是特别多的 Thread\_t1:获得锁

这里为什么会这样呢？因为根据系统的调度，一个线程会倾向于再次获取已经持有的锁，这种分配方式睡高效的，但是无公平而言。

对于ReentrantLock的几个重要的方法整理如下：

*  lock()：获得锁，如果锁已经被占用，则等待
 *  lockInterruptibly() : 获得锁，但优先相应中断
 *  tryLock() : 尝试获得锁，如果成功，则返回true， 失败则返回false. 该方法不等待，立即返回。
 *  tryLock(long time, TimeUnit unit) : 在给定的时间内尝试获得锁。
 *  unLock() : 释放锁

以上的示例都来自于《java高并发程序设计（第二版）》，我是看了书照着书中的例子手敲了一下代码，加深一下印象，有兴趣的同学可以去看一下这本书，作者是葛一鸣，非常不错的书。