# interface_for_java

**Repository Path**: zzfengxia/interface_for_java

## Basic Information

- **Project Name**: interface_for_java
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2022-01-11
- **Last Updated**: 2022-01-12

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# 书籍推荐
* Java编程思想（第四版）
* Java核心技术
* Effective Java
* Java并发编程实战-机械工业出版社
* 深入理解Java虚拟机：JVM高级特性与最佳实践（第3版）
* Head First设计模式
* 数据结构与算法分析java语言描述
* Spring源码深度解析（第二版）
* 高性能Mysql（第3版）
* MySQL技术内幕InnoDB存储引擎（第2版）.pdf

# 基础
* **Error和Exception区别，CheckedException和RuntimeException的区别**
* **列举几个RuntimeException**
* **transient关键字**  
实现Serilizable接口的类中不需要序列化的字段使用该修饰符，被transient修饰的变量不会被序列化，静态变量不管是否被transient修饰都不能被序列化，反序列化得到的对象中的静态变量的值是当前jvm中静态变量的值。  
<br/>
* **HashMap的数据结构是什么，如何实现的。key为Null时怎么存储，hash碰撞时怎么处理。HashMap、HashTable、ConcurrentHashMap的区别**  
jdk7：  
数组+链表。Entry数组，Entry为链表实现，取key的hash值计算出数组/桶位置，value存入Entry对象。    
key为null时hash值为0，即总是存于桶的首部，value是链表存储，Entry对象使用next连接，当发生hash碰撞时，会将新的value放入Entry，在使用next链向oldValue。<br/><br/>
jdk8:  
数组+红黑树
<br/>
* **泛型的存在是用来解决什么问题<br/>**
<br/>
* **泛型的实现<br/>**
<br/>

* **自动装箱**  
```java
public static void autoBoxing2() {
    Integer a = 1;
    Integer b = 2;
    Integer c = 3;
    Integer d = 3;
    Integer e = 321;
    Integer f = 321;
    Long g = 3L;
    // 自动装箱操作调用的是Integer.valueOf方法，使用new Integer创建，
    // 在[-128, 127]区间（高区间可以通过参数设置）会使用缓存，超过这个区间每次都是new的新对象
    System.out.println(c == d); // true 
    System.out.println(e == f); // false  操作
    System.out.println(c == (a + b)); // true  先add再装箱
    System.out.println(c.equals(a + b)); // true
    System.out.println(g == (a + b)); // true
    System.out.println(g.equals(a + b)); // false 装箱类型不一致，直接返回false
}
```
* **Java创建对象的几种方式<br/>**

* Java线程的状态
* 进程和线程的区别，进程间如何通讯，线程间如何通讯

* Cookie和Session的区别
* 索引有什么用？如何建索引？
* ArrayList是如何实现的，ArrayList和LinkedList的区别？ArrayList如何实现扩容。
* equals方法实现
* 面向对象(基本设计原则、基本特征)
* 线程状态，BLOCKED和WAITING有什么区别
* 什么情况会出现Full GC，什么情况会出现yong GC。
* JVM内存模型
* Java运行时数据区
* 事务的实现原理
* **注解原理<br/>**
3个修饰符：@Target，@Retention，@Documented  
<br/>

# JVM
1. **虚拟机内存结构<br/>**
程序计数器--线程私有，指示指令执行位置    
java虚拟机栈--局部变量表：基本数据类型、引用、returnAddress类型    
本地方法栈  
Java堆--对象实例和数组    
方法区--常量、静态变量、类型信息    
<br/>
2. **类加载过程<br/>**
加载-验证-准备-解析-初始化-使用-卸载
<br/>
3. **GC回收算法<br/>**
标记-清除    
标记-整理  
标记-复制
<br/>
4. **判断对象是否存活<br/>** 
引用计数器  
可达性分析--gc root对象：常量引用的对象、静态属性引用的对象、Native引用的对象、被同步锁持有的对象、Java虚拟机内部的引用， 如基本数据类型对应的Class对象， 一些常驻的异常对象（比如NullPointExcepiton、 OutOfMemoryError）等
<br/>
5. JVM如何加载字节码文件
6. CallerSensitive注解
7. 说说双亲委派模型，怎么打破双亲委派
8. **try catch finally执行顺序<br/>**
<br/>
9. **分代策略<br/>**
<br/>
10. **访问对象的方式<br/>**
使用句柄和直接指针
<br/>
11. **类进行初始化的时机<br/>**
有且只有6种情况需要进行类的初始化：  
1）遇到new、getstatic、putstatic或invokestatic这四条字节码指令时，如果类型没有进行过初始化，则需要先触发其初始化阶段。能够生成这四条指令的典型Java代码场景有：  
* 使用new关键字实例化对象的时候。<br/>
* 读取或设置一个类型的静态字段（被final修饰、已在编译期把结果放入常量池的静态字段除外）的时候。<br/>
* 调用一个类型的静态方法的时候。<br/>
2）使用java.lang.reflect包的方法对类型进行反射调用的时候，如果类型没有进行过初始化，则需要先触发其初始化。<br/>
3）当初始化类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。<br/>
4）当虚拟机启动时，用户需要指定一个要执行的主类（包含main()方法的那个类），虚拟机会先初始化这个主类。<br/>
5）当使用JDK 7新加入的动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果为REF_getStatic、 REF_putStatic、 REF_invokeStatic、 REF_newInvokeSpecial四种类型的方法句柄， 并且这个方法句柄对应的类没有进行过初始化， 则需要先触发其初始化。<br/>
6）当一个接口中定义了JDK 8新加入的默认方法（ 被default关键字修饰的接口方法） 时，如果有这个接口的实现类发生了初始化， 那该接口要在其之前被初始化。<br/>
<br/>

# 深度
* 有没有看过JDK源码，看过的类实现原理是什么。
* HTTP协议
* TCP协议
* JVM如何加载字节码文件
* 类加载器如何卸载字节码
* IO和NIO的区别，NIO优点
* Java线程池的实现原理，keepAliveTime等参数的作用。
* HTTP连接池实现原理
* 数据库连接池实现原理
* 数据库的实现原理
* ES数据存储原理
 

# 框架
1. spring如何解决循环依赖问题  
* 为什么要用Redis，Redis有哪些优缺点？Redis如何实现扩容？
* Netty是如何使用线程池的，为什么这么使用
* 为什么要使用Spring，Spring的优缺点有哪些
* Spring的IOC容器初始化流程
* Spring的IOC容器实现原理，为什么可以通过byName和ByType找到Bean
* Spring AOP实现原理
* 消息中间件是如何实现的，技术难点有哪些
* mybatis与hibernate的区别；分别有几级缓存
 

# 架构
* 如何搭建一个高可用系统
* 哪些设计模式可以增加系统的可扩展性
* 介绍设计模式，如模板模式，命令模式，策略模式，适配器模式、桥接模式、装饰模式，观察者模式，状态模式，访问者模式。
* 抽象能力，怎么提高研发效率。
* 什么是高内聚低耦合，请举例子如何实现
* 什么情况用接口，什么情况用消息
* 如果AB两个系统互相依赖，如何解除依赖
* 如何写一篇设计文档，目录是什么
* 什么场景应该拆分系统，什么场景应该合并系统
* 系统和模块的区别，分别在什么场景下使用
 

# 分布式
1. <b>分布式事务，两阶段提交</b>  
准备资源，预留事务所需资源  
提交/回滚，如果每个资源管理器都预留资源成功就提交，否则回滚
<br/>
2. **TCC**  
TCC（Try-Confirm-Cancel）,需要实现3个服务接口，要使用资源管理器RM参与本地事务。
第一阶段服务由业务代码编排来调用 Try 接口进行资源预留，所有参与者的 Try接口都成功了，事务管理器会提交事务，并调用每个参与者的 Confirm 接口真正提交业务操作，否则调用每个参与者的 Cancel 接口回滚事务
<br/>
3. **如何确保数据一致性**  
* 使用分布式事务：  
两阶段提交，TA模式  
TCC模式  
Saga长事务模式，补偿  
* MQ同步最终一致性，分布式事务拆为多个本地事务，通过消息队列保证数据最终一致  
<br/>
4. **CAP理论**  
 Consistency(一致性), Availability(可用性) 和 Partition Tolerance(分区容错)  
C和A总是不能同时满足
<br/>
5. **BASE理论**  
Basically Available（基本可用）<br/>
分布式系统在出现不可预知故障的时候，允许损失部分可用性<br/>
Soft state（软状态）<br/>
软状态也称为弱状态，和硬状态相对，是指允许系统中的数据存在中间状态，并认为该中间状态的存在不会影响系统的整体可用性，即允许系统在不同节点的数据副本之间进行数据听不的过程存在延时。<br/>
Eventually consistent（最终一致性）<br/>
最终一致性强调的是系统中所有的数据副本，在经过一段时间的同步后，最终能够达到一个一致的状态。因此，最终一致性的本质是需要系统保证最终数据能够达到一致，而不需要实时保证系统数据的强一致性
<br/>
6. **一致性hash算法原理与应用<br/>**
原理：hash在一个圆环上，顺时针方向找到最近的节点，添加虚拟节点实现平衡      
应用：分布式缓存，负载均衡  <br/>
> https://my.oschina.net/90888/blog/1645123  <br/>
* 如何实现分布式锁
* 如何实现分布式Session

* 负载均衡
* 正向代理（客户端代理）和反向代理（服务器端代理）
* CDN实现原理
* 怎么提升系统的QPS和吞吐量
* mysql分库、分表   
* 保证分布式系统数据一致性的方案 

# 数据结构与算法
1. 二分查找算法、快速排序、字符串处理、链表反转、对称二叉树实现、二叉树遍历
2. hash、红黑树、跳表、B+数据结构原理，以及之间的区别
3. 快速排序，归并排序，堆排序

# Mysql
* 如果要存ip地址，用什么数据类型比较好

当存储IPv4地址时，应该使用32位的无符号整数（UNSIGNED INT）来存储IP地址，而不是使用字符串。可以节省空间。Mysql提供了IP字符串与整数的转换方法：
```
select inet_aton('192.168.0.1');
select inet_ntoa(3232235521);
```



# Redis

# Kafka

# Rabbit MQ


# 实战
* 有没有处理过线上问题？出现内存泄露，CPU利用率标高，应用无响应时如何处理的。
* 开发中有没有遇到什么技术问题？如何解决的
* 如果有几十亿的白名单，每天白天需要高并发查询，晚上需要更新一次，如何设计这个功能。
* 新浪微博是如何实现把微博推给订阅者
* Google是如何在一秒内把搜索结果返回给用户的。
* 12306网站的订票系统如何实现，如何保证不会票不被超卖。
* 如何实现一个秒杀系统，保证只有几位用户能买到某件商品。
 

# 软能力
* 如何学习一项新技术，比如如何学习Java的，重点学习什么
* 有关注哪些新的技术
* 工作任务非常多非常杂时如何处理
* 项目出现延迟如何处理
* 和同事的设计思路不一样怎么处理
* 如何保证开发质量
* 职业规划是什么？短期，长期目标是什么
* 团队的规划是什么
* 能介绍下从工作到现在自己的成长在那里

# 并发编程
1. **并发编程三大特性**  
原子性，有序性，可见性。
2. **volatile关键字**  
volatile保证可见性，使用该关键字声明的变量对其它线程立即可见，但基于该变量的操作不一定是原子性的。  
volatile禁止指令重排，保证有序性。 

3. **3个线程A，B，C存在依赖关系，B依赖A执行结束，C依赖B执行结束，请设计实现**    


Java内存模型要求lock、 unlock、 read、 load、 assign、 use、 store、 write这八种操作都具有原子性，
但是对于64位的数据类型（long和double） ， 在模型中特别定义了一条宽松的规定： 允许虚拟机将没有
被volatile修饰的64位数据的读写操作划分为两次32位的操作来进行， 即允许虚拟机实现自行选择是否
要保证64位数据类型的load、 store、 read和write这四个操作的原子性， 这就是所谓的“long和double的非
原子性协定”（Non-Atomic Treatment of double and long Variables） 。

<br/>
* 死锁
* 对象锁和类锁(synchronized)

* servlet是否是线程安全的，怎么设计使其线程安全；session是否线程安全
* 线程的基本状态以及状态之间的关系
* 守护进程
* ConcurrentHashMap的实现原理

# 参考资料
> http://www.importnew.com/22083.html  
> http://www.importnew.com/22087.html