Java公平锁和非公平锁

先上两段代码大家先看一下，经典的卖票问题，我们创建了三个子线程同时去操作一个变量

非公平锁

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

public class Demo3 {
    //隐式锁Lock
    public static void main(String[] args) {
        Runnable run = new Tickted();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();

    }
    static class Tickted implements Runnable{
        //总票数
        private int count = 10;
        //创建一把隐式锁
        //传入参数true表示公平锁
        private Lock l = new ReentrantLock();
        @Override
        public void run() {
            while (true){
                //锁住
                l.lock();
                if (count > 0){
                    System.out.println("开始卖票");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    count --;
                    System.out.println(Thread.currentThread().getName() + "卖票成功 余票为:" + count);
                }else {
                    break;
                }
                //开锁
                l.unlock();
            }
        }
    }
}

结果：

公平锁

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

public class Demo3 {
    //隐式锁Lock
    public static void main(String[] args) {
        Runnable run = new Tickted();
        new Thread(run).start();
        new Thread(run).start();
        new Thread(run).start();

    }
    static class Tickted implements Runnable{
        //总票数
        private int count = 10;
        //创建一把隐式锁
        //传入参数true表示公平锁
        private Lock l = new ReentrantLock(true);
        @Override
        public void run() {
            while (true){
                //锁住
                l.lock();
                if (count > 0){
                    System.out.println("开始卖票");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    count --;
                    System.out.println(Thread.currentThread().getName() + "卖票成功 余票为:" + count);
                }else {
                    break;
                }
                //开锁
                l.unlock();
            }
        }
    }
}

结果：

首先ReentrantLock()是一个可重入的锁，Lock l = new ReentrantLock()如果什么都不传，底层是不公平的，Lock l = new ReentrantLock(true)这是公平的。我们常用的同步方法或者同步代码块所用的Synchronized，就是一个非公平锁。上面代码中我们有3个线程，非公平的情况下，第一个可能是2号线程抢到，2号线程释放锁之后，第二次这三个线程继续抢，有可能还是2号线程抢到，所以是非公平。
公平锁：获取不到锁的线程，会自动加入队列，等待线程释放，队列的第一个获取锁，排队获取。
非公平锁：获取不到锁的时候，会自动加入队列，等待线程释放后，就有等待的线程就会同时去竞争，包括上一次释放锁的线程。
可重入

同一个线程反复获取锁多次，然后需要释放多次，指同一线程外层函数获得锁之后，内层函数仍然可以获取该锁。在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。上面stu()方法会自动获取锁。
比如你回家的时候，进大门是一把锁，进入之后，进入你的卧室，会自动获取你卧室的锁。