Java 并发编程相关面试题

最新推荐文章于 2024-11-03 11:01:20 发布
最新推荐文章于 2024-11-03 11:01:20 发布
阅读量123 收藏
点赞数 1
分类专栏： # JUC 文章标签： 多线程 java 并发编程 arcgis server 列表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xf616510229/article/details/115957289
版权

T1：写两个线程，针对一个List容器，线程1 添加10个元素到容器中，线程2 实现监控元素个数，当到达5个时，线程2给出提示并结束

错误的示范：使用volatile

import java.util.ArrayList;
import java.util.List;

/**
 * 使用volatile.
 * 这是一个错误的解法，volatile只能保证基本类型和对象的引用的可见性，对象内部属性发生变化时，无法保证可见性
 * 所以线程二的退出不能依据 size == 5 来执行，所以此题是一个线程通讯问题
 * 
 * @author yangsx
 * @version 1.0
 * @date 2019/11/15
 */
public class ANS1_Volatile {

    private static volatile List<Object> myList = new ArrayList<>();

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                myList.add(i);
                System.out.println("线程1添加了一个元素： " + i);
            }
        });
        Thread t2 = new Thread(() -> {
            while (true) {
                if (myList.size() == 5) {
                    System.out.println("线程2准备退出: " + myList.size());
                    break;
                }
            }
        });
        t1.start();
        t2.start();
    }

}

使用wait和notify

import java.util.ArrayList;
import java.util.List;

/**
 * 使用wait和notify
 * 注意：wait会释放锁，notify不会释放锁，线程结束会自定释放锁
 *
 * @author yangsx
 * @version 1.0
 * @date 2019/11/15
 */
public class ANS2_WaitNotify {

    private static List<Object> myList = new ArrayList<>();

    private static final Object lock = new Object();

    public static void main(String[] args) {

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                synchronized (lock) {
                    myList.add(i);
                    System.out.println("线程1添加了一个元素： " + i);
                    if (i == 4) {
                        lock.notify(); // 通知t2元素已经5个
                        lockWait(); // 不释放锁t2无法执行
                    }
                }
            }
        });
        Thread t2 = new Thread(() -> {
            while (true) {
                synchronized (lock) {
                    if (myList.size() < 5) { // 如果元素不足5个，等待并释放锁，让t1继续增加
                        lockWait();
                    } else if (myList.size() == 5) { // 如果已经五个，显示退出消息，并通知t1继续执行，然后退出线程(自动释放锁)
                        System.out.println("线程2准备退出: " + myList.size());
                        lock.notify();
                        break;
                    }
                }
            }
        });
        t1.start();
        t2.start();

    }

    private static void lockWait() {
        try {
            lock.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

使用LockSupport.park()

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.LockSupport;

/**
 * 使用LockSupport， 最简单的方式
 *
 * @author yangsx
 * @version 1.0
 * @date 2019/11/15
 */
public class ANS3_LockSupportPark {

    private static List<Object> myList = new ArrayList<>();

    private static Thread t1, t2 = null;

    public static void main(String[] args) {

        t1 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                myList.add(i);
                System.out.println("线程1添加了一个元素： " + i);
                if (myList.size() == 5) {
                    LockSupport.unpark(t2); // 通知t2已经5个了
                    LockSupport.park(); // t1暂停执行，等待t2打印输出完毕后再次执行
                }
            }
        });
        t2 = new Thread(() -> {
            LockSupport.park(); // 一开始就park住，等待t1 unpark
            System.out.println("线程2准备退出: " + myList.size());
            LockSupport.unpark(t1);
        });
        t2.start(); // 保证t2优先执行
        t1.start();
    }

}

使用CountDownLatch

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;

/**
 * 使用门闩： 保证不了打印的顺序
 *
 * @author yangsx
 * @version 1.0
 * @date 2019/11/15
 */
public class ANS4_CountDownLatch {

    private static List<Object> myList = new ArrayList<>();
    private static volatile int size = myList.size(); // 用来获取准确的list size

    public static void main(String[] args) {
        CountDownLatch cdl = new CountDownLatch(5);

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                myList.add(i);
                System.out.println("线程1添加了一个元素： " + i);
                size = myList.size();
                cdl.countDown();
            }
        });
        Thread t2 = new Thread(() -> {
            try {
                cdl.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程2准备退出: " + size);
        });
        t1.start();
        t2.start();
    }

}

使用CountDownLatch作为通讯标记

package com.yangsx95.notes.mst.t1;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;

/**
 * 使用 cdl 作为通讯标记
 *
 * @author yangsx
 * @version 1.0
 * @date 2019/11/17
 */
public class ANS5_CountDownLatch2 {

    private static List<Object> myList = new ArrayList<>();
    private static CountDownLatch cdl1 = new CountDownLatch(1);
    private static CountDownLatch cdl2 = new CountDownLatch(1);
    private static volatile int size = myList.size(); // 用来获取准确的list size

    public static void main(String[] args) {

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                myList.add(i);
                size = myList.size();
                System.out.println("线程1添加了一个元素： " + i);
                if (myList.size() == 5) {
                    cdl1.countDown();
                    cdl2Await();
                }
            }
        });
        Thread t2 = new Thread(() -> {
            cdl1Await();
            System.out.println("线程2准备退出: " + size);
            cdl2.countDown();
        });
        t1.start();
        t2.start();

    }

    private static void cdl1Await() {
        try {
            cdl1.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private static void cdl2Await() {
        try {
            cdl2.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

T2：用两个线程顺序打印 A1B2…Z26， T1打印 A\~Z ， T2 打印 1\~26

使用wait和notify

/**
 * 同样是一个线程通讯问题，第一道题是通知一次，而此题是通知多次，并且存在线程先后执行的问题
 * @author yangsx
 * @version 1.0
 * @date 2019/11/17
 */
public class ANS1_WaitNotify {

    private static char[] abc = PrepareData.abc();
    private static int[] num = PrepareData.num();
    private static final Object lock = new Object();

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            for (char a : abc) {
                synchronized (lock) {
                    System.out.print(a);
                    lock.notify();
                    lockWait();
                }
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i : num) {
                synchronized (lock) {
                    System.out.print(i);
                    lock.notify();
                    if (i != 26) { // 如果i不是26则释放锁等待下一次执行，否则直接退出
                        lockWait();
                    }
                }
            }
        });
        t1.start(); // 保证t1线程先执行
        t2.start();

    }

    private static void lockWait() {
        try {
            lock.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

使用LockSupport

import java.util.concurrent.locks.LockSupport;

/**
 * 使用LockSupport实现
 *
 * @author yangsx
 * @version 1.0
 * @date 2019/11/17
 */
public class ANS2_LockSupportPark {

    private static char[] abc = PrepareData.abc();
    private static int[] num = PrepareData.num();
    private static Thread t1, t2 = null;

    public static void main(String[] args) {

        t1 = new Thread(() -> {
            for (char a : abc) {
                System.out.print(a);
                LockSupport.unpark(t2);
                if (a != 'z') {
                    LockSupport.park();
                }
            }
        });
        t2 = new Thread(() -> {
            for (int i : num) {
                System.out.print(i);
                LockSupport.unpark(t1);
                if (i != 26) {
                    LockSupport.park();
                }
            }
        });
        t1.start(); // 保证t1线程先执行
        t2.start();
    }

}

经典的生产者消费者问题：写一个固定容量的同步容器，拥有put、get方法，以及getCount方法，可以支持两个生产者线程以及10个消费者线程的阻塞调用

生产者消费者问题，为了方便测试，我写了个测试类：

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author yangsx
 * @version 1.0
 * @date 2019/11/17
 */
public class MyContainerTestUtil {

    public static void test(MyContainer myContainer) {

        AtomicInteger producerCounter = new AtomicInteger();

        Runnable prodRunnable = () -> {
            for (int i = 0; i < 50; i++) {
                String ele = "ELE" + producerCounter.incrementAndGet();
                myContainer.put(ele);
                System.out.println(Thread.currentThread().getName() + "放入了一个元素： \"" + ele + "\"");
            }
        };
        Runnable consumerRunnable = () -> {
            for (int i = 0; i < 10; i++) {
                String ele = myContainer.get();
                System.out.println(Thread.currentThread().getName() + "取得了一个元素： \"" + ele + "\"");
            }
        };

        // 两个生产者线程
        for (int i = 0; i < 2; i++) {
            new Thread(prodRunnable, "producer" + i).start();
        }

        // 十个消费者线程
        for (int i = 0; i < 10; i++) {
            new Thread(consumerRunnable, "consumer" + i).start();
        }

    }
}
public interface MyContainer {
    void put(String ele);
    String get();
    int getCount();
}

使用wait和notify

import java.util.LinkedList;

/**
 * 使用wait和notify，
 * 如果容器中没有足够的元素可以消费，消费者线程将会阻塞
 * 如果容器中的元素已经满了，那么生产者线程也会阻塞
 *
 * @author yangsx
 * @version 1.0
 * @date 2019/11/17
 */
public class ANS1_WaitNotify implements MyContainer{

    private LinkedList<String> list = new LinkedList<>();
    private final int MAX_SIZE = 10; // 最多添加十个元素
    private int count = 0;

    public synchronized void put(String ele) {
        while (count >= MAX_SIZE) { // 注意，需要使用while循环，if走完后count不见得小于0
            containerWait();
        }
        list.add(ele);
        count++;
        containerNotifyAll(); // 注意，使用notifyAll，唤醒单个线程的话可能唤醒生产者，没有唤醒消费者
    }

    public synchronized String get() {
        while (count == 0) {
            containerWait();
            containerNotifyAll();
        }
        count--;
        return list.remove();
    }

    public int getCount() {
        return count;
    }

    private void containerWait() {
        try {
            this.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void containerNotifyAll() {
        this.notifyAll();
    }

    public static void main(String[] args) {
        ANS1_WaitNotify container = new ANS1_WaitNotify();
        MyContainerTestUtil.test(container);
    }
}

使用ReentrantLock和Condition

ReentrantLock 和 Condition.await()、Condition.signal()的关系，类似synchronized和wait、notify之间的关系。

import java.util.LinkedList;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 使用ReentrantLock和Condition对象
 * 使用wait和notify有个缺陷，就是在生产者生产完后，调用notifyAll方法唤醒时，有可能会唤醒其他生产者线程，此时又会wait一次，
 * 这个问题可以使用Condition对象来解决
 *
 * @author yangsx
 * @version 1.0
 * @date 2019/11/17
 */
public class ANS2_ReentrantLockCondition implements MyContainer {

    private LinkedList<String> list = new LinkedList<>();
    private final int MAX_SIZE = 10; // 最多添加十个元素
    private int count = 0;
    private ReentrantLock lock = new ReentrantLock();
    private Condition producer = lock.newCondition();
    private Condition consumer = lock.newCondition();

    @Override
    public void put(String ele) {
        try {
            lock.lock();
            while (count >= MAX_SIZE) {
                producer.await(); // 满了就等待
            }
            count++;
            list.add(ele);
            consumer.signalAll(); // 然后唤醒消费者线程消费
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    @Override
    public String get() {
        String ele = null;
        try {
            lock.lock();
            while (count <= 0) {
                consumer.await(); // 没有元素了让消费者等着
            }
            count--;
            ele = list.remove();
            producer.signalAll(); // 唤醒生产者线程生产
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
        return ele;
    }

    @Override
    public int getCount() {
        return count;
    }

    public static void main(String[] args) {
        ANS2_ReentrantLockCondition container = new ANS2_ReentrantLockCondition();
        MyContainerTestUtil.test(container);
    }
}
Feathers .
关注
专栏目录
Java并发编程面试题——JUC专题
二蛋的博客
02-20 7515
1.1AQS是什么？1.2唤醒线程时，AQS为什么从后往前遍历？1.3AQS为什么用双向链表，（为啥不用单向链表）？1.4AQS为什么要有一个虚拟的head节点1.5ReentrantLock的底层实现原理1.6ReentrantLock的公平锁和非公平锁的区别1.7ReentrantReadWriteLock如何实现的读写锁2.1说下你熟悉的阻塞队列？2.2虚假唤醒是什么？3.1线程池的7个参数3.2线程池的状态有什么，如何记录的？3.3线程池常见的拒绝策略3.4线程池执行流程3.5线程池为什么添加空任务
Java并发编程面试题（2022最新版）
weixin_45985053的博客
07-25 1504
多线程多线程是指程序中包含多个执行流，即在一个程序中可以同时运行多个不同的线程来执行不同的任务。多线程编程中一般线程的个数都大于CPU核心的个数，而一个CPU核心在任意时刻只能被一个线程使用，为了让这些线程都能得到有效执行，CPU采取的策略是为每个线程分配时间片并轮转的形式。当一个线程的时间片用完的时候就会重新处于就绪状态让给其他线程使用，这个过程就属于一次上下文切换。概括来说就是任务从保存到再加载的过程就是一次上下文切换。上下文切换通常是计算密集型的。互斥条件AtomicLong。......
Java多线程之线程安全问题
未见花闻的博客
04-02 8732
本篇文章介绍的内容为Java多线程中的线程安全问题，此处的安全问题并不是指的像黑客入侵造成的安全问题，线程安全问题是指因多线程抢占式执行而导致程序出现bug的问题。
多线程核心（1）：Thread和Object类中的重要方法
底层码农
01-11 6511
Thread和Object类中的重要方法详解
javaEE基础 —— 线程的状态和安全
lingxu6的博客
04-07 542
目录 一、线程的状态 1.new 2.terminated 3.runnable 4.timed_waiting 5.blocked 6.waiting 二、线程安全 1.线程安全的概念 2.线程不安全的原因 一、线程的状态 先前，我们大概介绍了一下线程的两个状态：阻塞和就绪。严格来说线程并不只有这两种状态，上述的两种状态是在系统层面上的线程状态，在Java中，尤其是Thread类之中一共将线程的状态表分成了六种。 1.new 当Thread对象创建...
Java并发编程常见面试题
故不积跬步无以至千里
09-22 1506
普通方法对应于对象锁，是作用于对象实例；静态方法对应于类锁，是作用于一个类的class对象；类的对象实例可以有多个，但类的class对象只有一个；不同对象实例的对象锁是互不干扰的，但是每个类只有一个类锁；类锁只是一个概念的东西，真实并不存在，类锁其实锁的是每个类的class对象；可见性是值：当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。根据java内存模型可知，多线程操作中存在可见性问题，可以通过volatile关键字或者加锁解决。
面试必备：Java并发编程10道面试题及答案
good7ob的博客
12-31 672
在多线程环境下，线程安全是指多个线程访问共享数据时，不会出现数据错误或不一致的情况。要保证线程安全，可以采用同步机制，比如使用synchronized关键字或Lock接口来保护共享数据的访问，或者使用线程安全的数据结构，比如ConcurrentHashMap。volatile关键字用于声明变量，保证了变量的可见性和禁止指令重排序。它可以用于多线程之间的通信，确保一个线程对变量的修改对其他线程是可见的。线程池是一种管理和复用线程的机制，可以提高线程的利用率和系统的性能。
Java 并发编程面试题——Future 模式
代码星辰的博客
04-15 1501
本文记录了 Java 并发编程中与 Future 有关的面试题。
并发编程面试题（2020最新版）
热门推荐
ThinkWon的博客
03-14 36万+
文章目录基础知识并发编程的优缺点为什么要使用并发编程（并发编程的优点）并发编程有什么缺点并发编程三要素是什么？在 Java 程序中怎么保证多线程的运行安全？并行和并发有什么区别？什么是多线程，多线程的优劣？线程和进程区别什么是线程和进程?进程与线程的区别什么是上下文切换?守护线程和用户线程有什么区别呢？如何在 Windows 和 Linux 上查找哪个线程cpu利用率最高？什么是线程死锁形成死锁的...
java并发面试题
x2624252655的博客
01-23 664
java并发编程常见面试题
Java并发编程面试题八股文
01-30
Java并发编程面试题八股文，包括并发编程基本概念、锁、并发工具类、线程池等基本概念和高级用法。同时也介绍了上述知识点在面试过程中常见的问题及答案。 本材料适用于接下来要参加Java开发工程师岗位的面试同学，...
2024年java面试题-并发编程相关面试题
04-20
### 2024年Java面试题 - 并发编程相关面试题解析 #### 一、并发编程的重要性 - **目的**：并发编程的核心目的是为了提高计算机系统的整体性能，特别是针对现代多核处理器架构。 - **提升多核CPU利用率**：通过创建...
Java并发编程面试题
09-30
Java并发编程面试题 Java并发编程是指在Java程序中同时执行多个线程以提高程序的执行效率和响应速度的技术。并发编程可以带来许多优点，如提高程序的执行效率、改善用户体验等。但同时，Java并发编程也存在一些缺点...
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 132
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 810
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 865
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
SpringSession源码分析
lkr_lkr的博客
11-01 250
默认对常规Session的理解和使用，如何使用Set-Cookie。
函数式接口与回调函数实践
m0_37635053的博客
10-29 408
函数式接口与回调函数
Android 13 解决 Settings 首页矢量图修改颜色不生效
人生只是一种体验，不必用来演绎完美。
10-30 285
从Android 12 开始, 推出了Material You 设计，并在 Android 13 中得到了改进。导致了修改svg颜色不生效的问题。
Java并发编程面试题精选与解析
资源摘要信息:"Java并发编程面试题合集.zip" 知识点一：Java并发编程基础 Java并发编程是Java开发中非常重要的一部分，主要研究如何让程序并行执行，提高程序的效率。Java并发编程主要涉及到线程的创建和管理，线程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值