多把锁

多把锁

一间大屋子有两个功能：睡觉、学习，互不相干。

如果只用一把锁，那么并发度很低，解决办法是准备多个房间（多个对象锁）

class BigRoom {

	public void sleep() throws InterruptedException {
		synchronized (this) {
			System.out.println("sleeping 2 hour");
			Thread.sleep(2000);
		}
	}
	
	public void study() throws InterruptedException {
		synchronized (this) {
			System.out.println("sleeping 1 hour");
			Thread.sleep(1000);
		}
	}
}

改进

private final Object studyRoom = new Object();

    private final Object bedRoom = new Object();

    public void sleep() throws InterruptedException {
        synchronized (bedRoom) {
            System.out.println("sleeping 2 hour");
            Thread.sleep(2000);
        }
    }

    public void study() throws InterruptedException {
        synchronized (studyRoom) {
            System.out.println("sleeping 1 hour");
            Thread.sleep(1000);
        }
    }

将锁的粒度细分

• 好处，是可以增强并发度
• 坏处，如果一个线程需要同时获得多把锁，就容易发生死锁

哲学家就餐问题

有五位哲学家，围坐在圆桌旁。

• 他们只做两件事，思考和吃饭，思考一会吃口饭，吃完饭后接着思考。
• 吃饭时要用两根筷子吃，桌上共有 5 根筷子，每位哲学家左右手边各有一根筷子。
• 如果筷子被身边的人拿着，自己就得等待

筷子类

class Chopstick {

    private String name;

    public Chopstick(String name) {
        this.name = name;
    }
}

哲学家类

class Philosopher extends Thread {
    private final Chopstick left;
    private final Chopstick right;
    private String name = "";
    public Philosopher(String name, Chopstick left, Chopstick right) {
        super(name);
        this.left = left;
        this.right = right;
        this.name = name;
    }

    @Override
    public void run() {
        while (true) {
            // 尝试获得左手筷子
            synchronized (left) {
                // 尝试获得右手筷子
                synchronized (right) {
                    try {
                        eat(name);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                // 释放右手筷子
            }
            // 释放左手筷子
        }
    }

    private void eat(String name) throws InterruptedException {
        System.out.println(name + " eating...");
        TimeUnit.SECONDS.sleep(1);
    }

就餐

public static void main(String[] args) {
        Chopstick c1 = new Chopstick("c1");
        Chopstick c2 = new Chopstick("c2");
        Chopstick c3 = new Chopstick("c3");
        Chopstick c4 = new Chopstick("c4");
        Chopstick c5 = new Chopstick("c5");

        new Philosopher("苏格拉底", c1, c2).start();
        new Philosopher("柏拉图", c2, c3).start();
        new Philosopher("亚力士多德", c3, c4).start();
        new Philosopher("赫拉克里特", c4, c5).start();
        new Philosopher("阿基米德", c5, c1).start();

    }

结果：

// 卡在这里
苏格拉底 eating...
亚力士多德 eating...
苏格拉底 eating...
亚力士多德 eating...

这种线程没有按预期结束，执行不下去的情况，归类为【活锁】问题，除了死锁外，还有活锁和饥饿两种情况

活锁

活锁出现在两个线程互相改变对方的结束条件，最后谁也无法结束

static  volatile int count = 10;
    static final Object lock = new Object();

    public static void main(String[] args) {
        new Thread(() -> {
            while (count < 20) {
                try {
                    TimeUnit.SECONDS.sleep(1);
                    count++;
                    System.out.println("count " + count);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }, "t2").start();

        new Thread(() -> {
            while (count > 0) {
                try {
                    TimeUnit.SECONDS.sleep(1);
                    count--;
                    System.out.println("count: " + count);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "t3").start();
    }

饥饿

一个线程由于优先级太低，始终得不到 CPU 调度执行，也不能够结束