Java大厂高频面试题

最新推荐文章于 2024-05-20 20:11:03 发布

yyangqqian

最新推荐文章于 2024-05-20 20:11:03 发布

阅读量508

点赞数

分类专栏：面试

本文链接：https://blog.csdn.net/const_/article/details/109787259

版权

面试专栏收录该内容

12 篇文章 2 订阅

订阅专栏

文章目录

谈谈对volatile的理解
- volatile 是Java虚拟机提供的轻量级的同步机制
阻塞队列知道吗?
死锁编码及定位分析
JVM 内存结构
JVM垃圾回收的时候如何确定垃圾？是否知道什么是 GC Roots

周阳高并发面试题笔记记录

谈谈对volatile的理解

Java并发编程：volatile关键字解析

volatile 是Java虚拟机提供的轻量级的同步机制

保证可见性
不保证原子性
禁止指令重排

阻塞队列知道吗?

阻塞队列

首先它是一个队列，而一个阻塞队列在数据结构中所起的作用大致如图所示：
在这里插入图片描述
线程1往阻塞队列中添加元素，线程2从阻塞队列中移除元素。
当阻塞队列是空时，从队列中获取元素的操作将会被阻塞。
当阻塞队列是满时，往队列中添加元素的操作将会被阻塞。

试图从空的阻塞队列中获取元素的线程将会被阻塞，直到其他的线程往空的队列插入新的元素。
同样
试图往已满的阻塞队列中添加新元素的线程同样也会被阻塞，直到其他线程从队列中移除一个或者多个元素或者完全清空队列后使队列重新变得空闲起来并后续新增。

阻塞队列好处

在多线程领域：所谓阻塞，在某些情况下会挂起线程（即阻塞），一旦条件满足，被挂起的线程又会被自动唤醒。

为什么需要BlockingQueue：
好处是我们不需要关心什么时候需要阻塞线程，什么时候需要唤醒线程，因为BlockingQueue都一手给你包办好了。
在concurrent包发布以前，在多线程环境下，我们每个程序员都必须自己去控制这些细节，尤其还要兼顾效率和线程安全，而这会给我们的程序带来不小的复杂度。

BlockingQueue的核心方法

在这里插入图片描述

抛出异常
当阻塞队列满时，再往队列里面add插入元素会抛 IllegalStateException: Queue full
当阻塞队列空时，再往队列Remove元素时候回抛出 NoSuchElementException
特殊值
插入方法，成功返回true，失败返回false
移除方法，成功返回元素，队列里面没有就返回null
一直阻塞
当阻塞队列满时，生产者继续往队列里面put元素，队列会一直阻塞直到put数据or响应中断退出
当阻塞队列空时，消费者试图从队列take元素，队列会一直阻塞消费者线程直到队列可用
超时退出
当阻塞队列满时，队列会阻塞生产者线程一定时间，超过后限时后生产者线程就会退出

阻塞队列分类

ArrayBlockingQueue：由数组结构组成的有界阻塞队列
LinkedBlockingQueue: 由链表结构组成的有界(但大小默认值Integer>MAX_VALUE)阻塞队列
PriorityBlockingQueue:支持优先级排序的无界阻塞队列
DelayQueue: 使用优先级队列实现的延迟无界阻塞队列
SynchronousQueue:不存储元素的阻塞队列,也即是单个元素的队列
LinkedTransferQueue:由链表结构组成的无界阻塞队列
LinkedBlockingDeque:由链表结构组成的双向阻塞队列

SynchronousQueue

与其他BlcokingQueue不同，SynchronousQueue是一个不存储元素的BlcokingQueue。
每个put操作必须要等待一个take操作，否则不能继续添加元素，反之亦然.。

public class SynchronousQueueDemo {
    public static void main(String[] args) {
        BlockingQueue<Integer> synchronousQueue = new SynchronousQueue();
        new Thread(() -> {
            try {
                System.out.println(Thread.currentThread().getName() + "\t put 1");
                synchronousQueue.put(1);
                System.out.println(Thread.currentThread().getName() + "\t put 2");
                synchronousQueue.put(2);
                System.out.println(Thread.currentThread().getName() + "\t put 3");
                synchronousQueue.put(3);
            } catch (Exception e) {

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

        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName() + "\t take" + synchronousQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName() + "\t take" + synchronousQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName() + "\t take" + synchronousQueue.take());
            } catch (Exception e) {

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

在这里插入图片描述

阻塞队列的好处

前提：低耦合、高内聚
上联：线程、操作、资源类
下联：判断、干活、唤醒通知
横幅：严防多线程并发状态下的虚假唤醒

生产者消费者模式

传统版：

// 共享资源类
class ShareData {
    private int num = 0;
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void increment() throws Exception {
        lock.lock();
        try {
            // 判断是否要干活，判断要用循环，不能用if，使用if可能会导致虚假唤醒
            while (num != 0) {
                // 等待，不干活
                condition.await();
            }
            // 干活
            num++;
            System.out.println(Thread.currentThread().getName() + "\t" + num);
            // 通知唤醒
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }

    public void decrement() throws Exception {
        lock.lock();
        try {
            // 判断是否要干活
            while (num == 0) {
                // 等待，不干活
                condition.await();
            }
            // 干活
            num--;
            System.out.println(Thread.currentThread().getName() + "\t" + num);
            // 通知唤醒
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }
}

public class ProdConsumerTraditionDemo {

    // 一个初始值为0的变量 两个线程交替操作 一个加1 一个减1来5轮
    public static void main(String[] args) {
        ShareData shareData = new ShareData();
        new Thread(() -> {
            for (int i = 0; i <= 5; i++) {
                try {
                    shareData.increment();
                } catch (Exception e) {
                }
            }
        }, "AA").start();
        new Thread(() -> {
            for (int i = 0; i <= 5; i++) {
                try {
                    shareData.decrement();
                } catch (Exception e) {
                }
            }
        }, "BB").start();
    }
}

在这里插入图片描述

阻塞队列版：

class MyResource {
    // 默认开启，进行生产消费的交互
    private volatile boolean FLAG = true;
    // 默认值是0
    private AtomicInteger atomicInteger = new AtomicInteger();

    private BlockingQueue<String> blockingQueue = null;

    MyResource(BlockingQueue blockingQueue) {
        this.blockingQueue = blockingQueue;
        System.out.println(blockingQueue.getClass().getName());
    }

    public void myProd() throws Exception {
        String data = "";
        boolean returnValue;
        while (FLAG) {
            data = atomicInteger.incrementAndGet() + "";
            returnValue = blockingQueue.offer(data, 2, TimeUnit.SECONDS);
            if (returnValue) {
                System.out.println(Thread.currentThread().getName() + "\t 插入队列数据" + data + "成功");
            } else {
                System.out.println(Thread.currentThread().getName() + "\t 插入队列数据" + data + "失败");
            }
            TimeUnit.SECONDS.sleep(1);

        }
        System.out.println(Thread.currentThread().getName() + "\t 停止 生产 flag：" + FLAG);
    }

    public void myConsumer() throws Exception {
        String result = "";
        while (FLAG) {
            result = blockingQueue.poll(2, TimeUnit.SECONDS);
            if (result == null || "".equalsIgnoreCase(result)) {
                FLAG = false;
                System.out.println(Thread.currentThread().getName() + "\t" + "超过2m没有取到 消费退出");
                return;
            }
            System.out.println(Thread.currentThread().getName() + "消费队列" + result + "成功");
        }
    }

    public void stop() throws Exception {
        FLAG = false;
    }
}

public class ProdConsumerDemo {

    public static void main(String[] args) throws Exception {
        MyResource myResource = new MyResource(new ArrayBlockingQueue(5));

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t生产线程启动");
            try {
                TimeUnit.SECONDS.sleep(1);
                myResource.myProd();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "Thread-Prod").start();

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName() + "\t消费线程启动\n\n");
            try {
                myResource.myConsumer();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }, "Thread-Consumer").start();

        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println();
        System.out.println();
        System.out.println("时间到,停止活动");
        myResource.stop();
    }
}

在这里插入图片描述

死锁编码及定位分析

什么是死锁

死锁是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力干涉那它们都将无法推进下去，如果系统资源充足，进程的资源请求都能够得到满足，死锁出现的可能性就很低，否则就会因争夺有限的资源而陷入死锁。
在这里插入图片描述

产生死锁的原因

一句话总结： 两个小孩正在玩各自的玩具，然后都想玩对方的玩具，并且双方都不肯放弃自己的玩具，僵持住了。

产生死锁的原因： 系统资源不足、进程运行推进的顺序不合适、资源分配不当。

死锁案例：
线程1持有锁A，线程2持有锁B，然后线程1想要获取锁B，线程2想要获取锁A，双方都需要等对方释放锁后才能进行下去，这时就产生了死锁。

class HoldLockTread implements Runnable {

    private String lockA;
    private String lockB;

    HoldLockTread(String lockA, String lockB) {
        this.lockA = lockA;
        this.lockB = lockB;
    }

    @Override
    public void run() {
        synchronized (lockA) {
            System.out.println(Thread.currentThread().getName() + "\t 自己持有锁" + lockA + "尝试获得" + lockB);
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lockB) {
                System.out.println(Thread.currentThread().getName() + "\t 自己持有锁" + lockB + "尝试获得" + lockA);
            }
        }
    }
}

public class DeadLockDemo {

    public static void main(String[] args) {
        String lockA = "lockA";
        String lockB = "lockB";
        new Thread(new HoldLockTread(lockA, lockB), "Thread - 1").start();
        new Thread(new HoldLockTread(lockB, lockA), "Thread - 2").start();
    }
}

在这里插入图片描述

怎么排查死锁

1、jps命令定位进程编号
在这里插入图片描述
2、jstack找到死锁查看

JVM 内存结构

JVM 体系结构：
在这里插入图片描述
GC 作用域：

常见的垃圾回收算法：

引用计数法
复制
标记清除
标记整理

JVM垃圾回收的时候如何确定垃圾？是否知道什么是 GC Roots

什么是垃圾： 简单的说就是内存中已经不再被使用到的空间就是垃圾。

要进行垃圾回收，如何判断一个对象是否可以被回收：

引用计数法：
Java中，引用和对象是有关联的。如果要操作对象则必须用引用进行。
因此，很显然一个简单的办法是通过引用计数来判断一个对象是否可以回收。
简单说，给对象中添加一个引用计数器，每当有一个地方引用它，计数器值加1，每当有一个引用失效时，计数器值减1。
任何时刻计数器值为零的对象就是不可能再被使用的，那么这个对象就是可回收对象。
那为什么主流的Java虚拟机里面都没有选用这种算法呢？其中最主要的原因是它很难解决对象之间相互循环引用的问题。
枚举根节点做可达性分析（根搜索路径）：

Java 可以做GCRoots的对象
虚拟机栈（栈帧中的局部变量区，也叫做局部变量表）中引用的对象。
方法区中的类静态属性引用的对象。
方法区中常量引用的对象。
本地方法栈中JNI( Native方法）引用的对象。

yyangqqian

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java大厂高频面试题

文章目录阻塞队列知道吗?阻塞队列阻塞队列好处BlockingQueue的核心方法阻塞队列分类SynchronousQueue周阳高并发面试题笔记记录阻塞队列知道吗?阻塞队列首先它是一个队列，而一个阻塞队列在数据结构中所起的作用大致如图所示：线程1往阻塞队列中添加元素，线程2从阻塞队列中移除元素。当阻塞队列是空时，从队列中获取元素的操作将会被阻塞。当阻塞队列是满时，往队列中添加元素的操作将会被阻塞。试图从空的阻塞队列中获取元素的线程将会被阻塞，直到其他的线程往空的队列插入新的元素。同样试
复制链接

扫一扫