Java面经学习2_普通索引、(a b c)联合索引,如果只通过b等值查询能走索引吗,如果用a和c呢-优快云博客

来源

https://www.nowcoder.com/discuss/619573767051800576

1.一面内容

RocketMQ延时消息（项目用到了）底层怎么实现的（不会）
消息量太大导致读消息延迟时间很长怎么办
redis为什么快（说了内存、数据结构优化、单线程不用考虑线程安全、io多路复用）
单线程模型有什么缺点，有什么不太适用的场景
redis的大key问题，为什么会产生大key
redis怎么设置过期时间，底层是怎么实现的，有哪些过期删除策略
普通索引、(a b c)联合索引，如果只通过b等值查询能走索引吗，如果用a和c呢
线程池主要解决什么问题，有什么优点
线程池的原理、来了一个任务后的处理流程
keepAliveTime对核心线程是否生效，是否能杀死核心线程
那如果我想杀死核心线程应该怎么做（不太会，说了动态地修改核心线程数，下来查资料才知道有核心线程的过期时间参数）
线程安全问题怎么解决
除了加锁还有什么方法，有没有无锁化方法
读写锁听过吗，大概说说
ThreadLocal说说
线程池和ThreadLocal一起用会有什么问题吗（说了内存泄漏，面试官补充了个可能有脏数据）
lc53 最大子数组和
反问

RocketMQ延迟消息: 定时扫描延迟队列,到达延迟的时间就执行发送
消息量太大导致的延迟时间长,这里应该说的是消费端的延迟:增加消费端性能,过滤消息,修改为拉取消息的形式
redis为什么快:存在于内存中.数据结构简单.单线程不用考虑线程安全.io多路复用,非阻塞io,一个线程处理事件. 使用了简单编码的网络协议,网络通信更快
单线程模型有什么缺点，有什么不太适用的场景:高并发场景,单线程无法使用多核优势.一个线程阻塞,整个系统都会阻塞.高io场景,系统延迟可能会增高.长时间计算任务可能会阻塞.
redis的大key问题是什么,为什么会产生大key:存储的key信息过大,导致网络传输慢,涉及到大key的操作有较大延迟.大key的产生主要是不合理的数据结构,对象的序列化生成的.
redis怎么设置过期时间，底层是怎么实现的，有哪些过期删除策略:

Expire myKey expire_time;
set myKey value EX expire_time;

底层维护一个过期字典数据结构,存放key:过期时间的键值对.
删除策略: 1. 定时删除. 2. 惰性删除:访问到这个key的时候,如果key过期了就删除. 3. 定时+惰性 4. 惰性+内存回收:当内存到达一定阈值进行一次回收

联合索引中遵循最左原则:从左向右,如果不包含最左边的则不能使用该索引
解决的问题:减少开启和销毁线程的开销(次数),控制线程的个数. 优点:降低资源消耗,提升性能,调度线程
流程:如果线程池中线程总数小于设置的核心线程数(不论是否有空闲的线程),则新增线程执行,如果达到了核心线程数量,那么吧任务加到等待队列,如果等待队列已满,那么线程池会创建新线程来处理任务,直到线程数量达到了最大线程数量.如果线程达到最大线程数量,而且任务队列已满,那么这个任务会fallback,以设置的策略执行.当非核心线程空闲一段时间后会自行销毁.
keepAliveTime不对核心线程生效
想要关闭核心线程:ThreadPoolExecutor的 allowCoreThreadTimeOut参数可以让核心线程也过期关闭
线程安全问题怎么解决:加锁,使用线程安全的类和数据结构
有没有无锁化方法:原子操作,读写锁
读写锁:读可以并发,读写互斥,写写互斥
ThreadLocal:可以生成线程,每一个线程内部有自己独立的变量副本,存储在TreadLocalMap中,key为线程id,value为其副本数据
线程池和ThreadLocal一起用会有什么问题吗:threadLocal的线程回到线程池中,其关联的对象仍然存活,造成内存泄漏.也会有脏数据
算法题:最大子数组和:昨天的面经1里也有这道题,dp[i] = Math.max(dp[i-1],0) + nums[i];

2.二面内容

布隆过滤器原理（项目用到了）
布隆过滤器有什么问题，为什么不能删除
Object类有哪些方法，都有什么用
hashcode和equal有什么关系
hash冲突有哪些解决方法
wait和notify是用来做什么的
wait和sleep有什么区别
wait带参和不带参有什么区别
如果wait带参，到时间后会做什么
到时之后如果获取不到对象锁不还是得等别的线程notify吗，这和不带参有啥区别
说说垃圾回收
lc32 最长有效括号

布隆过滤器:使用bitmap来标记是否存在某个元素,计算该元素多个hash值,如果这些hash都存在,说明这个元素可能存在.但可能误判. 但是如果说没有,那是一定不存在的
不能删除:删除一个元素对应的hash值,可能会影响其他元素的判别,和误判存在是一样的原理
常见的方法:toString() hashCode() equals() getClass() synchronize关键字下(wait(),notify() notifyAll())
hashcode和equal有什么关系:equals的判断是根据hashcode的,hashcode的计算涉及到属性,能保证对象属性都相同才是同一个属性
wait()使一个线程释放所有拥有的对象锁,并且被阻塞:不消耗cpu,直到被notify(),或notifyAll()
wait()和sleep()的区别:wait()只能对同步块中使用,sleep()对线程在任何地方都可以使用,wait()后线程会释放所有的锁,而sleep不会,wait()不指定时间,sleep()指定时间.wait()的线程不会消耗cpu,sleep的线程仍然会消耗,并且可以被调度
wait带参数超时时间,wait超过这个时间会自动结束,不带参数会永远直到notify
带参数还是需要被唤醒,那么和无参有什么区别呢:可以更好处理超时问题
垃圾回收:堆,新生代,老年代. 新生代满了会触发gc, 老年代满了会fullgc
最长有效括号
核心思想:推导公式

class Solution {
    public int longestValidParentheses(String s) {
        if (s.equals(""))
            return 0;
        int[] dp = new int[s.length()];
        dp[0] = 0;
        int max = 0;
        for (int i = 1; i < s.length(); i++) {
        	// ()形式的,等于前面的有效括号个数+2
            if (s.charAt(i) == ')' && s.charAt(i - 1) == '(') {
                dp[i] = (i >= 2 ? dp[i - 2] : 0) + 2;
            } else if (s.charAt(i) == ')' && s.charAt(i - 1) == ')') {
            	// )) 形式,如果前面使匹配的( ,就是前面(之前的有效和 (到 )之间的有效和 +2 
                if (i - dp[i - 1] - 1 >= 0  && s.charAt(i - dp[i - 1] - 1) == '(') {
                         dp[i] = dp[i-1]+ ((i-dp[i-1])>=2 ? dp[i-dp[i-1] -2]  :0 )+ 2;
                }
            }
            max = Math.max(max, dp[i]);
        }
        return max;
    }
}

3.三面内容

什么场景适合分布式事务
微服务了解吗
说说tcp，它有哪些优点在平时的开发中有借鉴意义
说说http
java的NIO主要是为了减少线程数，为什么线程数多了会有问题
线程安全版lru

什么场景适合分布式事务:跨多个数据源,消息队列,数据库,服务,系统.需要分布式事务
微服务:了解springcloud Netflix一套,eureka服务注册,服务熔断
tcp:传输层控制协议,基于字节流.可靠有序,有拥塞控制,流量控制.借鉴TCP的确认,重传和排序机制来保证数据的完整性和顺序,动态调整发送速率和控制发送窗口来避免拥塞
http:是应用层协议,使用tcp进行传递信息,无状态,可以传输多种信息,本身不安全,可以配合ssl证书.有多种请求方法.
线程多了对内存占用多,上下文切换开销大,线程调度有开销
LRU可以使用LinkedHashMap实现,线程安全可以给操作加上synchronized


public class  ThreadSafeLRUCache<K,V>{
    private final Map<K,V> cache ;
    private final int capacity;
    public ThreadSafeLRUCache(int capacity){
        this.capacity = capacity;
        // true 为访问顺序, false为插入顺序
        this.cache = new LinkedHashMap<K,V>(capacity,0.75f,true){
            @Override
            protected boolean removeEldestEntry(Map.Entry<K, V> eldest) {
                return size() > capacity;
            }
        };
    }
    public synchronized V get(K key){
        return cache.get(key);
    }
    public synchronized void put(K key,V value){
        cache.put(key,value);
    }
    public synchronized void remove(K key){
        cache.remove(key);
    }
    public synchronized int size(){
        return cache.size();
    }

}