七、多把不相关锁

一、不相干锁

1. 锁粒度细化

• 一间屋子两个功能：睡觉，学习，互不影响
• 如果用一个屋子(一个对象锁)的话，并发度很低
• 问题：如果一个方法需要多把锁
• 可能引发死锁

package com.dreamer.multithread.day04;

import java.util.concurrent.TimeUnit;

public class Demo02 {
    public static void main(String[] args) {
        BigRoom bigRoom = new BigRoom();
        // 耗费的时间应该是5秒多，而不是10秒多
        new Thread(() -> bigRoom.learn()).start();
        new Thread(() -> bigRoom.rest()).start();
    }
}

class BigRoom {
    private Object studyLock = new Object();

    private Object sleepLock = new Object();

    public void rest() {
        synchronized (sleepLock) {
            heavyWork();
            System.out.println("我要睡觉了");
        }
    }

    public void learn() {
        synchronized (studyLock) {
            heavyWork();
            System.out.println("我要学习了");
        }
    }

    private void heavyWork() {
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

2. 死锁

• 线程一：持有a锁，等待b锁
• 线程二：持有b锁，等待a锁
• 互相等待引发的死锁问题
• 哲学家就餐问题
• 解决方法： 都按照顺序加锁就可以，但可能引发饥饿问题

package com.dreamer.multithread.day04;

import java.util.concurrent.TimeUnit;

public class Demo03 {
    public static void main(String[] args) {
        Business business = new Business();

        new Thread(() -> business.playFirst()).start();

        new Thread(() -> business.workFirst()).start();

    }
}

class Business {
    private Object homework = new Object();

    private Object play = new Object();

    public void workFirst() {
        synchronized (homework) {
            System.out.println("开始做作业啦");
            consumeTime();

            synchronized (play) {
                System.out.println("开始玩耍啦");
                consumeTime();
            }
        }
    }

    public void playFirst() {
        synchronized (play) {
            System.out.println("开始玩耍啦");
            consumeTime();

            synchronized (homework) {
                System.out.println("开始做作业啦");
                consumeTime();
            }
        }
    }

    private void consumeTime() {
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

• 定位死锁: 可以借助jconsole来定位死锁

3. 饥饿

• 某个线程因为优先级太低，一直得不到cpu的执行

package com.nike.multi;

import java.util.concurrent.TimeUnit;

public class Demo05 {
    public static void main(String[] args) {
        DoubleLock doubleLock = new DoubleLock();

        for (int i = 0; i < 10; i++) {
            int threadNumber = i;
            Thread thread = new Thread() {
                @Override
                public void run() {
                    doubleLock.work();
                }
            };
            thread.setName("high: [" + threadNumber + "]");
            thread.setPriority(10);
            thread.start();
        }

        Thread thread = new Thread() {
            @Override
            public void run() {
                doubleLock.work();
            }
        };
        thread.setName("low:");
        thread.setPriority(2);
        thread.start();
    }
}


class DoubleLock {
    private Object first = new Object();

    private Object second = new Object();


    public void work() {
        while (true) {
            synchronized (first) {
                System.out.println(Thread.currentThread().getName() + "获取了 first 锁");
                try {
                    TimeUnit.MILLISECONDS.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (second) {
                    System.out.println(Thread.currentThread().getName() + "获取了 second 锁");
                }
            }
        }
    }
}

4. 活锁

• 两个线程中互相改变对方结束的条件，导致两个线程一直运行下去
• 可能会结束，但是二者会交替进行

package com.dreamer.multithread.day04;

public class Demo04 {
    private static int counter = 10;

    public static void main(String[] args) {
        new Thread(() -> {
            while (counter < 20) {
                counter++;
                System.out.println(" ++ 操作:" + counter);
            }

        }).start();

        new Thread(() -> {
            while (counter > 0) {
                counter--;
                System.out.println(" -- 操作:" + counter);
            }
        }).start();
    }
}