线程面试题实战与分析——各种锁的灵活运用

叁歲伎倆 2021-07-25 01:02 128阅读 0赞

# 一 面试题 #

1 实现一个容器，提供两个方法，add，size。

2 写两个线程，线程1添加10个元素到容器中，线程2实现监控元素的个数，当个数到5个时，线程2给出提示并结束。

## 二 不使用 Volatile 实现版本 ##

## 1 代码 ##

import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.TimeUnit;
    
    public class T01_WithoutVolatile {
        List lists = new ArrayList();
    
        public void add(Object o) {
            lists.add(o);
        }
    
        public int size() {
            return lists.size();
        }
    
        public static void main(String[] args) {
            T01_WithoutVolatile c = new T01_WithoutVolatile();
            // 写线程
            new Thread(() -> {
                for (int i = 0; i < 10; i++) {
                    c.add(new Object());
                    System.out.println("add " + i);
                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }, "t1").start();
            // 监测线程
            new Thread(() -> {
                while (true) {
                    if (c.size() == 5) {
                        break;
                    }
                }
                System.out.println("t2 结束");
            }, "t2").start();
        }
    }

## 2 测试 ##

> add 0
> 
> add 1
> 
> add 2
> 
> add 3
> 
> add 4
> 
> add 5
> 
> add 6
> 
> add 7
> 
> add 8
> 
> add 9

## 3 分析 ##

无法实现功能，两个问题。

a 没加同步。

b 线程间 lists 不可见。

# 三 是否等待1秒是关键 #

## 1 代码 ##

/**
    * 给 lists 添加 volatile 之后，t2 能够接到通知
    * 问题1：t2 线程的死循环很浪费 cpu
    * 问题2：如果不用死循环，而且，如果在if 和 break之间被别的线程打断，得到的结果也不精确。
    */
    import java.util.Collections;
    import java.util.LinkedList;
    import java.util.List;
    import java.util.concurrent.TimeUnit;
    
    public class T02_WithVolatile {
        // 添加 volatile，使 t2 能够得到通知
        // volatile List lists = new LinkedList();
        // 位置一
        // 使用同步容器，并加 volatile
        /*volatile*/ List lists = Collections.synchronizedList(new LinkedList<>());
    
        public void add(Object o) {
            lists.add(o);
        }
    
        public int size() {
            return lists.size();
        }
    
        public static void main(String[] args) {
            T02_WithVolatile c = new T02_WithVolatile();
            new Thread(() -> {
                for (int i = 0; i < 10; i++) {
                    c.add(new Object());
                    System.out.println("add " + i);
                    // 位置二
                    // 等待 1 秒
    /*                try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }*/
                }
            }, "t1").start();
    
            new Thread(() -> {
                while (true) {
                    if (c.size() == 5) {
                        break;
                    }
                }
                System.out.println("t2 结束");
            }, "t2").start();
        }
    }

## 2 位置二处等待1秒 ##

> add 0
> 
> add 1
> 
> add 2
> 
> add 3
> 
> add 4
> 
> t2 结束
> 
> add 5
> 
> add 6
> 
> add 7
> 
> add 8
> 
> add 9

## 3 位置二处不等待1秒 ##

> add 0
> 
> add 1
> 
> add 2
> 
> add 3
> 
> add 4
> 
> add 5
> 
> add 6
> 
> add 7
> 
> add 8
> 
> add 9

## 4 分析 ##

a 使用了 synchronizedList 后，是否使用 volatile 不影响结果。

b 这里是否等待1秒才是关键，如果不等待1秒，线程 t2 还来不及执行 c.size() == 5 这个判断，线程1就已经把 c.size() 这个值变成 6了。

# 四 使用 wait 和 notify 机制 #

## 1 代码 ##

/**
    * 这里使用 wait 和 notify 机制。
    * 注意：wait 会释放锁，但 notify 不会释放锁
    * 运用这种方法，必须要保证 t2 先执行，也就是首先让 t2 监听才可以
    */
    import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.TimeUnit;
    
    public class T03_NotifyHoldingLock { // wait notify
        // 添加 volatile，使 t2 能够得到通知
        volatile List lists = new ArrayList();
        public void add(Object o) {
            lists.add(o);
        }
        public int size() {
            return lists.size();
        }
        public static void main(String[] args) {
            T03_NotifyHoldingLock c = new T03_NotifyHoldingLock();
    
            final Object lock = new Object();
            // 先启动 t2
            new Thread(() -> {
                synchronized (lock) {
                    System.out.println("t2启动");
                    if (c.size() != 5) {
                        try {
                            lock.wait(); // 等待，被唤醒后，还必须得到锁。被唤醒和得到锁两个条件必须同时满足。
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println("t2 结束");
                }
            }, "t2").start();
    
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            }
            // 再启动 t1
            new Thread(() -> {
                System.out.println("t1启动");
                synchronized (lock) {
                    for (int i = 0; i < 10; i++) {
                        c.add(new Object());
                        System.out.println("add " + i);
                        if (c.size() == 5) {
                            lock.notify(); // 唤醒 t2，但不释放锁
                        }
                        try {
                            TimeUnit.SECONDS.sleep(1);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }, "t1").start();
        }
    }

## 2 测试 ##

> t2启动
> 
> t1启动
> 
> add 0
> 
> add 1
> 
> add 2
> 
> add 3
> 
> add 4
> 
> add 5
> 
> add 6
> 
> add 7
> 
> add 8
> 
> add 9
> 
> t2 结束

3 分析

输出结果并不是 siz e= 5 时 t2 退出，而是 t1 结束时 t2 才接收到通知而退出。

结果非预期，产生这个结果的原因是，lock.notify() 唤醒 t2，但不释放锁。t1 虽然被唤醒，但因为得不到锁，所以还得继续等待。直到得到了锁才结束。

# 五 改进版的 wait 和 notify #

## 1 代码 ##

/**
    * notify 之后，t1 必须释放锁，t2 退出后，也必须 notify，通知 t1 继续执行
    * 整个通信过程比较繁琐
    */
    package com.mashibing.juc.c_020_01_Interview;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.TimeUnit;
    
    public class T04_NotifyFreeLock {
        // 添加 volatile，使 t2 能够得到通知
        volatile List lists = new ArrayList();
    
        public void add(Object o) {
            lists.add(o);
        }
    
        public int size() {
            return lists.size();
        }
    
        public static void main(String[] args) {
            T04_NotifyFreeLock c = new T04_NotifyFreeLock();
            final Object lock = new Object();
            new Thread(() -> {
                synchronized (lock) {
                    System.out.println("t2启动");
                    if (c.size() != 5) {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println("t2 结束");
                    // 通知 t1 继续执行
                    lock.notify();
                }
            }, "t2").start();
    
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            }
    
            new Thread(() -> {
                System.out.println("t1启动");
                synchronized (lock) {
                    for (int i = 0; i < 10; i++) {
                        c.add(new Object());
                        System.out.println("add " + i);
                        if (c.size() == 5) {
                            lock.notify();
                            // 释放锁，让 t2 得以执行
                            try {
                                lock.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }, "t1").start();
        }
    }

## 2 测试 ##

> t2启动
> 
> t1启动
> 
> add 0
> 
> add 1
> 
> add 2
> 
> add 3
> 
> add 4
> 
> t2 结束
> 
> add 5
> 
> add 6
> 
> add 7
> 
> add 8
> 
> add 9

## 3 分析 ##

改进后的 wait 和 notify，使得问题完美解决。

# 六 使用 Latch（门闩）替代 wait notify #

## 1 代码 ##

/**
    * 使用 Latch（门闩）替代 wait notify 来进行通知
    * 好处是通信方式简单，同时也可以指定等待时间
    * 使用 await和 countdown方法替代 wait 和 notify
    * CountDownLatch 不涉及锁定，当 count 的值为零时当前线程继续运行
    * 当不涉及同步，只是涉及线程通信的时候，用 synchronized + wait/notify 就显得太重了
    * 这时应该考虑 countdownlatch/cyclicbarrier/semaphore
    */
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.CountDownLatch;
    import java.util.concurrent.TimeUnit;
    
    
    public class T05_CountDownLatch {
        // 添加volatile，使 t2 能够得到通知
        volatile List lists = new ArrayList();
    
    
        public void add(Object o) {
            lists.add(o);
        }
    
    
        public int size() {
            return lists.size();
        }
    
    
        public static void main(String[] args) {
            T05_CountDownLatch c = new T05_CountDownLatch();
            CountDownLatch latch = new CountDownLatch(1);
            new Thread(() -> {
                System.out.println("t2启动");
                if (c.size() != 5) {
                    try {
                        latch.await();
                        // 也可以指定等待时间
                        // latch.await(5000, TimeUnit.MILLISECONDS);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("t2 结束");
            }, "t2").start();
    
    
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            }
    
    
            new Thread(() -> {
                System.out.println("t1启动");
                for (int i = 0; i < 10; i++) {
                    c.add(new Object());
                    System.out.println("add " + i);
    
    
                    if (c.size() == 5) {
                        // 打开门闩，让 t2 得以执行
                        latch.countDown();
                    }
                    // 这里必须等待1秒，否则 t2 线程虽然被唤醒，但可能因为抢不过 t1 线程，产生不正确的结果
    /*          try {
                   TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                   e.printStackTrace();
                }*/
                }
    
    
            }, "t1").start();
        }
    }

## 2 t1 等待1秒测试 ##

> t2启动
> 
> t1启动
> 
> add 0
> 
> add 1
> 
> add 2
> 
> add 3
> 
> add 4
> 
> t2 结束
> 
> add 5
> 
> add 6
> 
> add 7
> 
> add 8
> 
> add 9

## 3 t1 不等待1秒测试——结果不正确 ##

> t2启动
> 
> t1启动
> 
> add 0
> 
> add 1
> 
> add 2
> 
> add 3
> 
> add 4
> 
> add 5
> 
> t2 结束 
> 
> add 6
> 
> add 7
> 
> add 8
> 
> add 9

## 4 说明 ##

使用 Latch（门闩）替代 wait notify 来进行通知，使得程序变得更轻。

t1 线程必须等待 1 秒。因为线程 t1 和线程 t2 间没有锁，t2 虽然被 t1 唤醒，但下一步到底是执行 t1 线程还是执行 t2 线程，并不确定。

# 七 使用 LockSuppor t的 park 和 unpark #

## 1 代码 ##

import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.CountDownLatch;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.LockSupport;
    
    // 使用 park 和 unpark 机制解决，它的使用和门闩类似
    public class T06_LockSupport {
        // 添加 volatile，使 t2 能够得到通知
        volatile List lists = new ArrayList();
    
        public void add(Object o) {
            lists.add(o);
        }
    
        public int size() {
            return lists.size();
        }
    
        public static void main(String[] args) {
            T06_LockSupport c = new T06_LockSupport();
            CountDownLatch latch = new CountDownLatch(1);
            Thread t2 = new Thread(() -> {
                System.out.println("t2启动");
                if (c.size() != 5) {
                    LockSupport.park();
                }
                System.out.println("t2 结束");
            }, "t2");
            t2.start();
    
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            }
    
            new Thread(() -> {
                System.out.println("t1启动");
                for (int i = 0; i < 10; i++) {
                    c.add(new Object());
                    System.out.println("add " + i);
                    if (c.size() == 5) {
                        LockSupport.unpark(t2);
                    }
                // 这里必须等待1秒，否则 t2 线程虽然被唤醒，但可能因为抢不过 t1 线程，产生不正确的结果
                /*try {
                   TimeUnit.SECONDS.sleep(1);
                } catch (InterruptedException e) {
                   e.printStackTrace();
                }*/
                }
            }, "t1").start();
        }
    }

## 2  t1 等待1秒测试 ##

> t2启动
> 
> t1启动
> 
> add 0
> 
> add 1
> 
> add 2
> 
> add 3
> 
> add 4
> 
> t2 结束
> 
> add 5
> 
> add 6
> 
> add 7
> 
> add 8
> 
> add 9

## 3  t1 不等待1秒测试——结果不正确 ##

> t2启动
> 
> t1启动
> 
> add 0
> 
> add 1
> 
> add 2
> 
> add 3
> 
> add 4
> 
> add 5
> 
> t2 结束
> 
> add 6
> 
> add 7
> 
> add 8
> 
> add 9

## 4 说明 ##

该用法和门闩类似，存在的问题也类似。

t1 线程必须等待 1 秒。因为线程 t1 和线程 t2 间没有锁，t2 虽然被 t1 唤醒，但下一步到底是执行 t1 线程还是执行 t2 线程，并不确定。

# 八 双重 LockSuppor 解决 1 秒等待问题 #

## 1 代码 ##

import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.CountDownLatch;
    import java.util.concurrent.TimeUnit;
    import java.util.concurrent.locks.LockSupport;
    
    public class T07_LockSupport_WithoutSleep {
        // 添加volatile，使 t2 能够得到通知
        volatile List lists = new ArrayList();
    
        public void add(Object o) {
            lists.add(o);
        }
    
        public int size() {
            return lists.size();
        }
    
        static Thread t1 = null, t2 = null;
    
        public static void main(String[] args) {
            T07_LockSupport_WithoutSleep c = new T07_LockSupport_WithoutSleep();
            t1 = new Thread(() -> {
                System.out.println("t1启动");
                for (int i = 0; i < 10; i++) {
                    c.add(new Object());
                    System.out.println("add " + i);
                    if (c.size() == 5) {
                        LockSupport.unpark(t2);
                        LockSupport.park();
                    }
                }
            }, "t1");
    
            t2 = new Thread(() -> {
                //System.out.println("t2启动");
                //if (c.size() != 5) {
                LockSupport.park();
                //}
                System.out.println("t2 结束");
                LockSupport.unpark(t1);
            }, "t2");
    
            t2.start();
            t1.start();
        }
    }

## 2 测试 ##

> t1启动
> 
> add 0
> 
> add 1
> 
> add 2
> 
> add 3
> 
> add 4
> 
> t2 结束
> 
> add 5
> 
> add 6
> 
> add 7
> 
> add 8
> 
> add 9

## 3 分析 ##

t1 和 t2 交替使用 LockSuppor，使得等待1秒问题完美解决。

# 九 使用信号量解决 #

## 1 代码 ##

import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.Semaphore;
    import java.util.concurrent.locks.LockSupport;
    
    public class T08_Semaphore {
        // 添加 volatile，使 t2 能够得到通知
        volatile List lists = new ArrayList();
        public void add(Object o) {
            lists.add(o);
        }
        public int size() {
            return lists.size();
        }
        static Thread t1 = null, t2 = null;
        public static void main(String[] args) {
            T08_Semaphore c = new T08_Semaphore();
            Semaphore s = new Semaphore(1);
            // 一个线程插入另外一个线程代码
            t1 = new Thread(() -> {
                // 让 t1 先执行一部分代码
                try {
                    s.acquire();
                    for (int i = 0; i < 5; i++) {
                        c.add(new Object());
                        System.out.println("add " + i);
                    }
                    s.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 让 t2 执行完
                try {
                    t2.start();
                    t2.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 让 t1 把 剩下的代码执行完
                try {
                    s.acquire();
                    for (int i = 5; i < 10; i++) {
                        System.out.println(i);
                    }
                    s.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }, "t1");
    
            t2 = new Thread(() -> {
                try {
                    s.acquire();
                    System.out.println("t2 结束");
                    s.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }, "t2");
            t1.start();
        }
    }

## 2 测试 ##

> add 0
> 
> add 1
> 
> add 2
> 
> add 3
> 
> add 4
> 
> t2 结束
> 
> 5
> 
> 6
> 
> 7
> 
> 8
> 
> 9

## 3 说明 ##

t1 线程插入了 t2 线程代码执行。

先执行 t1 线程部分代码，再执行完 t2 线程代码，最后将 t1 剩余代码执行完。