JAVA面试题45

    本文首发于 cartoon 的博客
     转载请注明出处:https://cartoonyu.github.io/c…

java

1. sleep 与 wait 的区别

   1. 作用对象

      1. sleep 是 Thread 类的静态方法，作用于当前线程
      2. wait 是 Object 类的成员方法，作用于对象本身

   2. 作用

      1. 调用 sleep 方法，线程进入休眠状态
      2. 调用 wait 方法，线程进入阻塞状态

   3. 锁的释放

      1. sleep 不会释放持有的锁
      2. wait 会释放锁

   4. 唤醒

      1. 自然唤醒或者显式调用 interrupt 方法
      2. 调用 notify 或者 notifyAll 方法

   5. 调用

      1. sleep 不需要在同步代码中调用
      2. wait 需要在同步代码中调用，否则抛出 IllegalMonitorStateException

   6. 使用场景

      1. sleep 作用于周期性任务的执行
      2. wait 作用于互斥资源的使用

2. hashMap 的扩容机制

   1. 相关成员属性

      1. HashMap 是 JAVA 集合框架的一个存储 key-value 对的实现类，有关于扩容机制的成员属性主要有三个

         1. 默认值为 16 的 capicity
         2. 默认值为 0.75 的 loadFactory
         3. 默认值为 0 的 size

   2. 触发时机

      1. 插入元素时

   3. 实现

      1. JDK 1.7

         1. 传入 newCapicity 参数
         2. 新建 newCapicity 长度的 Entry 数组
         3. 将原数组元素重新 hash 放入新数组
         4. 将原有数组引用指向新数组

      2. JDK 1.8 之后

         1. 如果节点的链表元素个数大于 8 时，原有的数组链表会转换成数组红黑树的逻辑结构进行使用

         2. 如果当前 size 大于 loadFactory*capicity 的阈值，触发扩容机制

            1. 新建一个 newCap 的 int 变量，大小为 2 *oldCapicity
            2. 新建一个大小为 newCap 的数组
            3. 原数组元素索引进行 2 次幂的计算放入新数组
            4. 将 newCap 赋值给原有的 capicity
            5. 返回新数组

3. ReentantLock 的了解

   1. 存在位置

      1. ReentantLock 是 JDK 的一个显式锁的 API，具体通过 AQS 队列实现功能

   2. 锁的种类

      1. ReentantLock 是可重入的锁，内部通过判断 state 当前占有线程进行重入的判断
      2. ReentantLock 可以实现公平锁以及非公平锁，在构造对象时显式传入 fair

   3. 同步机制

      1. ReentantLock 是同步非阻塞式的，采用乐观并发策略
      2. ReentantLock 需要显式控制锁的获取与释放，而且可以响应中断

4. List 实现类的比较

   1. 底层实现

      1. Arraylist 为数组
      2. LinkedList 为链表

   2. 线程安全

      1. ArrayList，LinkedList 为线程不安全
      2. Vector 为线程安全

   3. 实现时间

      1. ArrayList，LinkedList 为 JDK1.2 开始实现
      2. Vector 为 JDK1.1 开始实现

5. NIO 的了解

   1. NIO 是 java 中用于实现数据的输入 / 输出的 API，是同步非阻塞式的

   2. 核心对象

      1. selector，选择器，用于对 channel 的选择
      2. channel，通道，用于连接 java 程序与对象的通道
      3. buffer，缓冲区，用于数据的暂时存放

   3. 工作步骤

      1. java 程序与操作对象建立 channel
      2. 数据放入 buffer 中
      3. selector 轮询 channel，监控 IO 状况，控制输入输出

6. ConcurrentHashMap 同步的实现(JDK1.7 1.8)

   1. JDK1.7 实现

      1. ConcurrentHashMap 中数据存放在 Segment(默认为 16 个)中
      2. ConcurrentHashMap 为区域锁，锁定对象是 Segment
      3. 在写数据时，会经过计算得出使用的 Segment，并检查是否持有 Segment 的锁

   2. JDK1.8 实现

      1. ConcurrentHashMap 中数据存放在数组链表 / 红黑树中
      2. ConcurrentHashMap 是行级锁，锁定对象是链表的头结点或者红黑树的根结点
      3. 在写数据，计算访问的数据索引，检查锁，访问链表或者红黑树

JVM

1. G1 的工作流程

   1. 初始标记
   2. 并发标记
   3. 最终标记
   4. 筛选回收

2. CMS 的工作流程

   1. 初始标记(stw 现象)
   2. 并发标记
   3. 重新标记(stw 现象)
   4. 并发清理
   5. 重置线程

Spring

1. spring bean 的生命周期

   1. 对象被实例化
   2. Spring 进行 IOC 的注入

   3. 可选

      1. 传入对象

         1. 实现 BeanNameAware 接口，传入 bean 的 ID
         2. 实现 ApplicationFactoryAware 接口，传入 Spring 工厂
         3. 实现 ApplicationContextAware 接口，传入 Spring 上下文

      2. 初始化

         1. 实现 BeanPostProcessor 接口，对 bean 内容进行修改
   4. 使用
   5. 清理

网络

1. 输入域名到返回页面的过程

   1. 浏览器部分

      1. 利用 DNS 进行域名解析
      2. 检查本地 host 文件
      3. 组装 http 报文
      4. http 报文经过 OSI 底层包装发送请求
      5. http 请求在第三次 tcp 握手上发送

   2. 传输

      1. 路由器根据 IP 进行选择转发到目标主机
   3. 目标主机
   4. 后端进行报文的拆解获取真实请求
   5. 根据请求返回相应页面
   6. 传输
   7. 路由器根据 IP 进行选择转发到目标主机
   8. 源主机
   9. 拆解报文，获取实部数据
   10. 交给浏览器渲染页面

算法

1. 两数之和(leetcode 1)