阿里面试-2019

 @Override
    @RhinoBreaker
    @ApiResult
    public CityResponse execRequest(CityRequest cityRequest) {
        GenericObjectPool<WSClient> wsClientPool = null;
        WSClient wsClient = null;
        URI uri;
        Transaction transaction = Cat.newTransaction(CatConstant.TRANSACTION_WEBSOCKET_REQUEST.getKey(), CatConstant.TRANSACTION_WEBSOCKET_REQUEST.getValue());

        try {
            uri = getURI(cityRequest);
            wsClientPool = wsClientPoolCache.get(uri.toString());
            wsClient = wsClientPool.borrowObject();
            CityResponse cityResponse = send(wsClient, Collections.singletonList(cityRequest));
            if (cityResponse.isOk()) {
                transaction.setSuccessStatus();
            } else {
                transaction.setStatus("上报失败");
            }
            return cityResponse;
        } catch (Exception e) {
            transaction.setStatus(e);
            /*网络IO 异常 & 可重试异常 & 连接池获取异常*/
            return new FailureResponse(e);
        } finally {
            if (wsClientPool != null && wsClient != null) {
                ((WebSocketImpl) wsClient.getConnection()).updateLastPong();
                wsClientPool.returnObject(wsClient);
            }
            transaction.complete();
        }
    }

举例说一下连接池丢弃的参数写法。关键字

连接池丢弃的写法：

  .removalListener((RemovalListener<String, GenericObjectPool<WSClient>>) removalNotification -> {
                    /* 连接池销毁 */
                    if (removalNotification.getValue() != null) {
                        removalNotification.getValue().close();
                        LOGGER.warn("url:{} 的WebSocket连接池已销毁,池数目:{}", removalNotification.getKey(), wsClientPoolCache.size());
                    }
                })

线程池丢弃最开始的数据的写法

这是定义：

    public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {
        if (corePoolSize < 0 ||
            maximumPoolSize <= 0 ||
            maximumPoolSize < corePoolSize ||
            keepAliveTime < 0)
            throw new IllegalArgumentException();
        if (workQueue == null || threadFactory == null || handler == null)
            throw new NullPointerException();
        this.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

下面是重写：

   }, (r, executor) -> {
        if (!executor.isShutdown()) {
            /* 丢弃队列最老的数据 */
            if (executor.getQueue().poll() != null) {
                Cat.logMetricForCount(CatConstant.METRIC_DISCARD_FILE_TASK_COUNT);
            }
            executor.execute(r);
        }
    });

4、网络中断报错如何处理

5、HTTP协议的架构，http1.0,http1.1,http2.0协议的区别和联系。

参考:HTTP/1.0和HTTP/1.1 http2.0的区别，HTTP怎么处理长连接（阿里）

五、MQ

1、kafka 如何处理高并发的，比如一条数据进入partition之后，如何找到这条数据的。怎么消费的，消费数据的，

参考：kafka如何实现高并发存储-如何找到一条需要消费的数据(阿里)

六、数据结构：

1、hashmap的时间复杂度O（1），数组的是 O(n),链表也是 O(n)

参考：HashMap, HashTable，HashSet,TreeMap 的时间复杂度注意数组链表增删改查的时间复杂度都不相同(阿里)

2、Hashtable继承自Dictionary类，而HashMap继承自AbstractMap类。但二者都实现了Map接口。hashtable的初始大小

hashmap的初始大小，为什么扩容因子是0.75；以及resize的操作原理 entry 扩容完了之后，顺序会颠倒吗?

3、冒泡排序的时间复杂度是多少，空间复杂度又是多少？

答：空间复杂度O(1)

参考：各种排序算法的时间复杂度和空间复杂度(阿里)

4、blockQueue的长度是多少。

5、hashMap的初始大小 16 扩容因子0.75，原因？

参考：HashMap默认加载因子为什么选择0.75？(阿里)

(a) ArrayList初始化n=10个空间扩容(n3)/2 + 1,如果不够设置传入的值
(b) HashMap初始化n=16空间扩容2n,在并发环境下，可能会形成环状链表（扩容时可能造成）
(c) Hashtable初始化n=11空间扩容2n+1
jdk1.6ConcurrentHashMap初始化segments=16个空间每个segments是初始化一个HashEntry 扩容segments=n2
jdk1.7ConcurrentHashMap初始化segments=16个空间每个segments是初始化两个HashEntry 扩容segments=n*2

6、 concurrentHashMap 是否是线程安全的，如何实现的？

我做了总结：使用了分段锁的技术

这个问题比较复杂，可以参考：

hashmap,hashTable concurrentHashMap 是否为线程安全，区别，如何实现的

而且Java1.7与Java1.8实现方式并不相同，阿里的面试官3个都问道这个问题，他们好这口，

我整理了一下：ConcurrentHashMap原理分析（1.7与1.8）

7、hashmap 如果多线程操作的话，线程不安全，为什么会不安全：

答案：多线程put的时候，会引起死循环，好好看看这个例子，有图有解释，很管用

具体原因参考：HashMap多线程并发问题分析-正常和异常的rehash1(阿里)

7、红黑树的插入和删除操作，红黑树的树高，左旋右旋，用红黑树实现currentHashMap,红黑树与B+树的区别

红黑树的树高度<=2log(n+1) 时间复杂度：O(lgn)

红黑树： R-B Tree，全称是Red-Black Tree，又称为“红黑树”，它一种特殊的二叉查找树。红黑树的每个节点上都有存储位表示节点的颜色，可以是红(Red)或黑(Black)。

(4)红黑树的特性:
（1）每个节点或者是黑色，或者是红色。
（2）根节点是黑色。
（3）每个叶子节点（NIL）是黑色。 [注意：这里叶子节点，是指为空(NIL或NULL)的叶子节点！]
（4）如果一个节点是红色的，则它的子节点必须是黑色的。
（5）从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。

红黑树特征，以及新增删除参考：红黑树之原理和算法详细介绍(阿里面试-treemap使用了红黑树) 红黑树的时间复杂度是O(lgn) 高度<=2log(n+1)1、X节点左旋-将X右边的子节点变成父节点 2、X节点右旋-将X左边的子节点变成父节点

8、如果一个数据结构，需要进行深度优先的遍历，或者进行广度优先的遍历，应该首先考虑什么数据结构来处理

答案：

深度优先-栈

广度优先-队列

因为深度优先需要无路可走时按照来路往回退，正好是后进先出就是栈
广度优先则需要保证先访问顶点的未访问邻接点先访问，恰好就是先进先出那就是队列

六、Lock 锁问题；

1、synchronized 如何实现线程安全的

参考：啃碎并发（七）：深入分析Synchronized原理

2、膨胀锁的原理。

参考：JAVA锁的膨胀过程和优化(阿里)

参考：JAVA锁的优化和膨胀过程

七、JVM内存问题：

1、强引用和软引用，弱引用(比如threadlocal),虚引用，区别，可达性算法的定义；

 在JDK 1.2之后，Java对引用的概念进行了扩充，将引用分为强引用（Strong Reference）、软引用 依次逐渐减弱。

强引用
  在程序代码中普遍存在的，类似 Object obj = new Object() 这类引用，只要强引用还存在，垃圾收集器永远不会回收掉被引用的对象。

软引用
  用来描述一些还有用但并非必须的对象。对于软引用关联着的对象，在系统将要发生内存溢出异常之前，将会把这些对象列进回收范围之中进行第二次回收。如果这次回收后还没有足够的内存，才会抛出内存溢出异常。

弱引用
  也是用来描述非必需对象的，但是它的强度比软引用更弱一些，被弱引用关联的对象只能生存到下一次垃圾收集发生之前。当垃圾收集器工作时，无论当前内存是否足够，都会回收掉只被弱引用关联的对象。在JDK 1.2之后，提供了WeakReference类来实现弱引用。比如 threadlocal

虚引用
  也叫幽灵引用或幻影引用（名字真会取，很魔幻的样子），是最弱的一种引用 关系。一个对象是否有虚引用的存在，完全不会对其生存时间构成影响，也无法通过虚引用来取得一个对象实例。它的作用是能在这个对象被收集器回收时收到一个系统通知。。在JDK 1.2之后，提供了PhantomReference类来实现虚引用。

2、垃圾回收算法：

首先问一下目前你们用的垃圾回收机制是什么样的：

回答：使用命令：

java -XX:+PrintFlagsFinal -version | grep :

就能看到：

  uintx InitialHeapSize                          := 128981632       {product}           
    uintx MaxHeapSize                              := 2065694720      {product}           
     bool PrintFlagsFinal                          := true            {product}           
     bool UseCompressedOops                        := true            {lp64_product}      
     bool UseParallelGC                            := true            {product}           
java version "1.7.0_76"
Java(TM) SE Runtime Environment (build 1.7.0_76-b13)
Java HotSpot(TM) 64-Bit Server VM (build 24.76-b04, mixed mode)

里面能看到我的来及回收机制是 ParallelGC的垃圾回收机制；具体参考：JVM的垃圾回收机制总结(垃圾收集、回收算法、垃圾回收器)

能否说几个G1的配置参数：参考：

回答：比如用户期望的最大停顿时间

-XX:MaxGCPauseMillis=200

或者使用 G1的命令：-XX:+UseG1GC

具体参考：G1相关参数

(1)CMS与G1的区别和联系

主要的区别：G1只有的并发标记的时候才不会stop-the-world 其他步骤都会stop-the-world；

不要以为掌握到这个程度就行了，看看阿里下面的问题：

(2)G1垃圾回收算法的架构，跟分代收集很不一样，架构是怎样的，还有就是G1如何做到时间可控的

　　(a) G1虽然也把内存分成了这三大类，Eden(E), Suvivor(S)和Old(O), 但是在G1里面这三大类不是泾渭分明的三大块内存，G1把内存划分成很多小块, 每个小块会被标记为E/S/O中的一个，可以前面一个是Eden后面一个就变成Survivor了。

　　(b) G1其实是Garbage First的意思，垃圾优先? 不是，是优先处理那些垃圾多的内存块的意思。

　　(c)G1的另一个显著特点他能够让用户设置应用的暂停时间，为什么G1能做到这一点呢？也许你已经注意到了，G1回收的第4步，它是“选择一些内存块”，而不是整代内存来回收，这是G1跟其它GC非常不同的一点，其它GC每次回收都会回收整个Generation的内存(Eden, Old), 而回收内存所需的时间就取决于内存的大小，以及实际垃圾的多少，所以垃圾回收时间是不可控的；而G1每次并不会回收整代内存，到底回收多少内存就看用户配置的暂停时间，配置的时间短就少回收点，配置的时间长就多回收点，伸缩自如。

更具体的参考：G1 垃圾收集器架构和如何做到可预测的停顿(阿里)

G1与CMS的区别参考：CMS收集器和G1收集器他们的优缺点对比 G1只有并发标记才不会stop-the-world 其他都会停下来(阿里多次问到)

3、当new 一个对象的时候，JVM做了那些事情。还有我们在堆分配了空间，那么会不会线程不安全，因为堆是共享的？(阿里面试的高频问题，问了至少3次了)
回答：首先一定是安全的，至于原因：为了保证Java对象的内存分配的安全性，同时提升效率，一般有两种解决方案：

1、对分配内存空间的动作做同步处理，采用CAS机制，配合失败重试的方式保证更新操作的线程安全性。
2、每个线程在Java堆中预先分配一小块内存，然后再给对象分配内存的时候，直接在自己这块"私有"内存中分配，当这部分区域用完之后，再分配新的"私有"内存。
方案1在每次分配时都需要进行同步控制，这种是比较低效的。

方案2是HotSpot虚拟机中采用的，这种方案被称之为TLAB分配，即Thread Local Allocation Buffer。这部分Buffer是从堆中划分出来的，但是是本地线程独享的。

这里值得注意的是，我们说TLAB时线程独享的，但是只是在“分配”这个动作上是线程独占的，至于在读取、垃圾回收等动作上都是线程共享的。而且在使用上也没有什么区别
不知道大家有没有想过，我们使用了TLAB之后，在TLAB上给对象分配内存时线程独享的了，这就没有冲突了，但是，TLAB这块内存自身从堆中划分出来的过程也可能存在内存安全问题啊。所以，在对于TLAB的分配过程，还是需要进行同步控制的。但是这种开销相比于每次为单个对象划分内存时候对进行同步控制的要低的多。

参考：灵魂拷问：Java对象的内存分配过程是如何保证线程安全的？(阿里面试)

4、如果遇到了Full GC如何处理，

首先搞明白什么事Full GC ,JVM回收主要是堆的回收，而堆分为新生代和老年代，新生代如果满了就会执行Minor GC，回收一次新生代的内存，

新生代执行垃圾回收很频繁，因此使用了复制法(Coping)

存活的对象会放在老年代，如果老年代满了，会执行Full GC，回收老年代的垃圾不是很频繁，因此使用了标记整理法(Mark-Compact)

由此看来：Full GC的生成条件：

（a）调用System.gc时，系统建议执行Full GC，但是不必然执行

（b）老年代空间不足

（c）方法区空间不足

（d）通过Minor GC后进入老年代的平均大小大于老年代的可用内存

（e）由Eden区、From Space区向To Space区复制时，对象大小大于To Space可用内存，则把该对象转存到老年代，且老年代的可用内存小于该对象大小

阿里大神面试官回答：

(a)看一下有没有大对象

(b)大的静态对象

八、线上问题排查：

1、如果一台服务器负载很高，如何处理，假如他cpu使用率很低，IO也很低呢?

不要上来就说看一下是CPU高还是IO高，因为有时候，CPU不高，IO也不高，但服务器负载就是高，看下面的博客

参考：服务器负载过高问题分析-不是cpu高负载也不是IO负载如何处理(阿里)

九、算法题目

1、给你1000条数据，每条数据都带有起始结束时间的任务，如何把时间重叠的数据取出来；

2、给你1亿个数据，里面有重复的，如何把前100最小的数取出来

参考：关于“100g文件全是数组，取最大的100个数”解决方法汇总

十、Cache 缓存

1、guava如何删除过期数据,guava的架构，如何实现的删除，都要看源码，别只看博客解说。就是应付也要看点，不然怎么说，Caffeine缓存

参考：Guava cacha 机制及源码分析

2、在GuavaCache中，并不存在任何线程！它实现机制是在写操作时顺带做少量的维护工作（如清除），偶尔在读操作时做（如果写操作实在太少的话），也就是说在使用的是调用线程

参考：GuavaCache简介（一）是轻量级的框架少量数据，并且过期时间相同可以用 GuavaCache

十一、设计模式，生产者消费者设计模式，以及wait,notifiy的运用，阿里问了一个面试、终极目的是用wait和notify实现一个可重入锁来保证顺序；

问题：使用“生产者-消费者模式”编写代码实现：线程A随机间隔（10~200ms）按顺序生成1到100的数字（共100个），
放到某个队列中.3个线程B、C、D即时消费这些数据，线程B打印（向控制台）所有被2整除的数，
线程C打印被3整除的数，线程D打印其它数据，要求数字的打印是有序的（从1到100）
限时40分钟，可以使用IDE及第三方类库

参考：阿里笔试-生产者消费者模式

这个类似的问题美团也问过，不过美团直接说能否用synchronized 实现一个可重入锁，本质上也是使用了wait和notify()函数

参考：使用synchronized 实现ReentrantLock(美团面试题目)

十二、加解密算法每次向对方的服务器发送数据，都需要传递token 这是什么机制？

这是非对称加密参考：聊聊对称/非对称加密在HTTPS中的使用

最后一百、架构设计知识

1、是否了解DDD 架构设计

分为四层，(1)基础设施层(2)领域服务层(3)应用服务层(4)用户接口层

用户界面层：负责向用户展示信息或解释用户指令，如：天网的前端界面，调用天网服务的外卖应用程序等。

应用层：定义软件要完成的任务，指挥领域层的对象或调用其他应用服务来解决问题，不包含业务规则和知识，要求尽量的简单。

领域层：负责表达业务概念，业务状态信息以及业务规则。核心

基础设施层：为上面各层提供通用的技术能力：比如以上各层交互的Thrfit，为领域层提供持久化机制的zebra，公司为UI层提供的通用组件等等。

以天网量化分级导入功能为例：

用户界面层：天网前端界面

应用层：负责参数校验、excel解析、调用mdc接口验证门店是否存在、调用领域层进行检查和存储。

领域层：量化分级模块领域对象（Entity、Value Objext）、以及操作服务（Service）。

基础设施层：Thrift、MCC、zebra等。

1、电面：重点在过往主导技术项目的方案阐述/计算机理论知识/Java基础知识的考核：

（1）方案有思考、有对比选型（2）沟通表达顺畅、能抓住重点；（3）计算机（计算机网络/数据结构/操作系统等），Java（集合类/并发/多线程/JVM等）基础扎实（4）有业务sense加分
2、现场1面：重点考察落地以及编码能力（1）深入履历核心方案深挖（2）给一个陌生场景，考察候选人面对新问题的应变能力（3）实际编码考察

3、数据结构的现场面试题：

链表翻转的图文讲解

参考：https://www.cnblogs.com/aspirant/p/9199608.html

给定一个字符串，请你找出其中不含有重复字符的最长子串的长度。

参考：https://www.jianshu.com/p/f1f74aa59dd4

参考：DDD(Domain Driven Design) 架构设计

参考：阿里P6-P7面试准备

posted @ 2018-04-08 17:43 aspirant 阅读(2707) 评论(0) 编辑收藏举报

刷新页面返回顶部

朝北教室的风筝

用心做每一件事

阿里面试-2019

公告