一种公平锁的java实现

利用队列来实现公平锁

public class Lock {
    private Queue<String> intrestedQueue = new ArrayDeque<String>();//感兴趣的线程队列
    private volatile String turn;//轮到哪个线程执行

    public void lock() {
        Thread currentThread = Thread.currentThread();
        intrestedQueue.offer(currentThread.getName());//将线程号加入感兴趣的线程队列
        turn = intrestedQueue.peek();//公平锁的实现，严格按照队列顺序来执行
        while (!turn.equals(currentThread.getName())) ;//一直循环，直到轮到自己执行。没有线程挂起的概念，就是不断的轮询
    }

    public void unlock() {
        intrestedQueue.poll();
        turn = intrestedQueue.peek();
    }

    public static void main(String[] args) {
        Food food = new Food();
        new Thread(new Eat(food)).start();
        new Thread(new Eat(food)).start();
        new Thread(new Eat(food)).start();
    }

    static class Food {
        Lock lock = new Lock();

        public void eat() {
            lock.lock();
            System.out.println("我被 ：" + Thread.currentThread().getName() + " 线程开始吃");
            try {
                Thread.sleep(new Random().nextInt(1000));
            } catch (InterruptedException e) {
            }
            System.out.println("我被 ：" + Thread.currentThread().getName() + " 线程开始吃完了");
            System.out.println("=======================================");
            lock.unlock();
        }
    }

    static class Eat implements Runnable {
        private Food food;

        public Eat(Food food) {
            this.food = food;
        }

        public void run() {
            for (int i = 0; i < 5; i++)
                food.eat();
        }
    }
}