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

最新推荐文章于 2024-04-16 10:36:17 发布
最新推荐文章于 2024-04-16 10:36:17 发布
阅读量116 收藏
点赞数
分类专栏： java 文章标签： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chengqiuming/article/details/118254024
版权

一 面试题

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 剩余代码执行完。 

chengqiuming
关注
专栏目录
Java 多线程（致命）面试题：线程锁+线程池+线程同步等
m0_68850571的博客
05-26 1264
1、并发编程三要素？ 1）原子性 原子性指的是一个或者多个操作，要么全部执行并且在执行的过程中不被其他操作打断，要么就全部都不执行。 2）可见性 可见性指多个线程操作一个共享变量时，其中一个线程对变量进行修改后，其他线程可以立即看到修改的结果。 实现可见性的方法： synchronized 或者 Lock：保证同一个时刻只有一个线程获取锁执行代码，锁释放之前把最新的值刷新到主内存，实现可见性。 3）有序性 有序性，即程序的执行顺序按照代码的先后顺序来执行。 2、多线程的价值？ 1...
多线程和锁面试题
m0_59113244的博客
02-02 240
多线程面试题
线程和锁自整理面试题
hung_jun的博客
08-04 523
1.线程的实现方式 常见的有3种： Thread：继承Thread类，start启动线程，重写run方法执行。 Runnable：实现Runnable接口，start启动线程，重写run方法执行。 Callable：实现Callable接口，start启动线程，并实现其call()方法。能返回指定的参数。 接口的start方法都是通过Thread调用。 2.线程的执行流程。 新建：创建了线程。 就绪：执行start()，进入队列，等待JVM的调度。 运行：得到CPU时间片开始执行run方法，可以变为阻
面试汇总 -- 50道线程面试题(附带答案）
IT界的一只菜鸟
07-14 933
什么是线程？ 线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。程序员可以通过它进行多处理器编程，你可以使用多线程对运算密集型任务提速。比如，如果一个线程完成一个任务要100毫秒，那么用十个线程完成改任务只需10毫秒。Java在语言层面对多线程提供了卓越的支持，它也是一个很好的卖点。 线程和进程有什么区别？ 线程是进程的子集，一个进程可以有很多线程，每条线程并行执行不同的任务。不同的进程使用不同的内存空间，而所有的线程共享一片相同的内存空间。别把它和栈内存搞混，每.
并发编程44题（含答案）
weixin_42034166的博客
11-21 2861
1、并发编程三要素？ 1）原子性 原子性指的是一个或者多个操作，要么全部执行并且在执行的过程中不被其他操作打断，要么就全部都不执行。 2）可见性 可见性指多个线程操作一个共享变量时，其中一个线程对变量进行修改后，其他线程可以立即看到修改的结果。 实现可见性的方法： synchronized或者Lock：保证同一个时刻只有一个线程获取锁执行代码，锁释放之前把最新的值刷新到主内存，实现可见...
115个Java面试题和答案——终极（上）_尚硅谷_宋红康.zip ) 您可以上传小于60MB的文件
09-30
在Java编程领域，面试是检验开发者技能和知识深度的重要环节。这份"115个Java面试题和答案——终极（上...通过阅读"115个Java面试题和答案——终极（上）"的PDF，开发者将能更全面地准备Java面试，掌握更多的实战技巧。
各大厂互联网企业面试真题，包含有百度、京东、唯品会、阿里、蚂蚁金服、拼多多、OPPO、腾讯等等 金三银四冲起来
01-17
面试中可能会遇到的问题包括：Java内存模型、垃圾回收机制、多线程编程、集合框架的使用与原理，以及反射和动态代理等。对于这些基础内容，应聘者需要扎实掌握，并能灵活运用到实际问题中。 其次，网络知识是现代...
面试04——整理
HRX98的博客
03-12 708
1.抽象类怎么模拟接口 2.项目负责 3.线程与进程 4.List list =new Arraylist(Array.aslist(“a”,“b”,“c”,“d”)); ​ for(s:list){ ​ s.equls（“a”）{ ​ s.removes() ​ } ​ } 5.io 异常关闭 应该在哪里关闭 6.public class test{ ​ private int value; ​ public void get(int x){ ​ this.value=x } publ
ym——Andorid-15k+的面试题。
热门推荐
陈宇明
08-07 2万+
最近才开的博客，希望大家多多关注，andorid开发也做了3年有余了，也面试很多加企业，借此机会分享一下，我们中遇到过的问题以及解决方案吧，希望能够对正在找工作的andoird程序员有一定的帮助。学完本人博客发表《ym--andorid从零开始教程》+面试题目全理解，年薪18w以上绝对没问题。 特别献上整理过的50道面试题目 1.listView的优化方式 重用conve
100个变态的软件测试面试题及答案！——看完变态面试官对你竖起大拇指！
caixiangting的博客
02-16 1650
在规定的条件下对程序进行操作，以发现程序错误，衡量软件质量，并对其是否能满足设计要求进行评估的过程。测试是程序的执行过程，目的在于发现错误一个成功的测试用例在于发现至今未发现的错误一个成功的测试是发现了至今未发现的错误的测试确保产品完成了它所承诺或公布的功能，并且用户可以访问到的功能都有明确的书面说明。确保产品满足性能和效率的要求确保产品是健壮的和适应用户环境的测试用例中一个必须部分是对预期输出或接过进行定义程序员应避免测试自己编写的程序编写软件的组织不应当测试自己编写的软件。
java并发锁面试知识
03-21
java中的乐观锁与悲观锁，synchronized与ReentrantLock重入锁的说明与比较
线程面试题总结
知性人 -- 的博客
06-11 2037
线程面试题总结 什么是线程？ 线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位，可以使用多线程对进行运算提速。 比如，如果一个线程完成一个任务要100毫秒，那么用十个线程完成改任务只需10毫秒 进程和线程的区别 进程是程序运行和资源分配的基本单位 一个程序至少有一个进程,一个进程至少有一个线程 一个进程下也可以有多个线程来增加程序的执行速度 进程在执行过程中...
Java 多线程 并发 锁 Java线程面试题 Top 50
王鹏亮 的专栏
12-01 8371
多线程 并发 锁 同步 原子
50道线程面试题
小白程序员的博客
02-16 777
Java线程面试题 Top 50
java线程面试题整理
阿璐4r的博客
05-13 1735
线程面试题整理 整理了线程相关的面试题，有什么不对的请指出。 1、多线程中的i++线程安全吗？为什么？ 是不安全的，因为i++可以分为3步，1.线程读取i。2.对i进行加一操作。3.把i放进内存中。线程1,在进行i++操作的第一步的时候，线程2，进入操作完i++。线程1再进行i++剩下未完成的两个操作。这样就是出现数据安全问题。即线程1更新的可能会覆盖线程2更新后的值。 ...
多线程面试题
时光的博客
09-20 2910
1) 什么是线程？ 线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。程序员可以通过它进行多处理器编程，你可以使用多线程对运算密集型任务提速。比如，如果一个线程完成一个任务要100毫秒，那么用十个线程完成改任务只需10毫秒。Java在语言层面对多线程提供了卓越的支持，它也是一个很好的卖点。欲了解更多详细信息请点击这里。 2) 线程和进程有什么区别？ 线程是进程的子
38道多线程核心面试题（附答案）
最新发布
DN金猿的博客
04-16 1212
今天给大家分享的是比较全面的多线程面试题，大家在面试的过程中不免会被问到很多专业性的问题，有的时候回答的并不是那么全面和精细，这仅仅代表个人观点。
java多线程
dhwu43996的博客
01-07 79
详细见，Java并发编程的艺术/P101 在java中，每个对象的监视器都有两个池，锁(monitor)池和等待池 wait() ,notifyAll(),notify() 三个方法都是Object类中的方法. 锁池:假设线程A已经拥有了某个对象(注意:不是类)的锁，而其它的线程想要调用这个对象的某个synchronized方法(或者synchronized块)，由于这些线程在进入...
Java多线程面试题详解：关键知识点与实战示例
在Java面试题解惑系列的第十集中，主要讨论的是多线程的相关概念和技术。多线程是软件开发中处理并发执行任务的关键工具，它允许程序在同一时间内执行多个任务，提高程序的响应速度和效率。面试中，关于线程的考察...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值