知识提纲

知识提纲

---

一、Java基础

1. String类为什么是final的。

1. 安全
   当String支持非可变性的时候，它们的值很好确定，不管调用哪个方法，都互不影响。
2. 不可变性支持线程安全
   还有一个大家都知道，就是在并发场景下，多个线程同时读一个资源，是不会引发竟态条件的。只有对资源做写操作才有危险。不可变对象不能被写，所以线程安全
3. 不可变性支持字符串常量池
   String另外一个字符串常量池的属性。one = “aaa” two = “aaa”,它们其实都指向同一个内存地址;在大量使用字符串的情况下，可以节省内存空间，提高效率。但之所以能实现这个特性，String的不可变性是最基本的一个必要条件。

2. HashMap的源码，实现原理，底层结构。

1. 实现原理
   put操作：key–>hashCode–>进行hash计算–>与容量进行位运算获取在数组存储的下标位置，进行插入，hash冲突，则插入到冲突链上。
2. 底层结构
   数组 + 链表 ； 主链是数组，链表作为冲突链

2. TreeMap，红黑树的特性、B+树。

// TODO

3. 说说你知道的几个Java集合类：list、set、queue、map实现类咯

list --> ArrayList、LinkedList
set --> HashSet
queue --> LinkedList、LinkedBlockingQueue；
map --> HashMap、HashTable、TreeMap、ConcurrentHashMap

4. 描述一下ArrayList和LinkedList各自实现和区别

1.ArrayList是一个数组队列，相当于动态数组。它由数组实现，随机访问效率高，随机插入、随机删除效率低（读取快，增删慢）。
2.LinkedList 是一个双向链表。它也可以被当作堆栈、队列或双端队列进行操作。LinkedList随机访问效率低，但随机插入、随机删除效率低（读取慢，增删快）。

5. Java中的队列都有哪些，有什么区别。

// TODO

6. 反射中，Class.forName和classloader的区别

初始化：执行静态代码块，赋值静态变量。
也就是说：
Class.forName会执行静态代码块、会执行静态变量赋值的静态方法；Classloader不会。

7. Java8的新特性

Lambda 表达式、Stream 接口、Date API

8. Java数组和链表两种结构的操作效率，在哪些情况下(从开头开始，从结尾开始，从中间开始)，哪些操作(插入，查找，删除)的效率高

讲一下数组、链表的底层逻辑，用ArrayList、LinkedList举例分析

9. Java内存泄露的问题调查定位：jmap，jstack的使用等等

// TODO

10. string、stringbuilder、stringbuffer区别

1.速度快慢 stringbuilder>stringbuffer>string
String是final类型的，两个String相加是，是创建一个新对象，这是一个不断新建新对象，回收旧对象的过程；
stringbuilder、stringbuffer是一个变量，可以直接进行修改，所以快。
2.线程安全
StringBuilder是线程不安全的;
String，StringBuffer是线程安全的。
3.总结
String：适用于少量的字符串操作的情况；
StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况；
StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况。

11. hashtable和hashmap的区别

集合类	Key	Value	Super	说明
Hashtable	不允许为 null	不允许为null	Dictionary	线程安全
ConcurrentHashMap	不允许为null	不允许为null	AbstractMap	锁分段技术（JDK8:CAS）
TreeMap	不允许为 null	允许为 null	AbstractMap	线程不安全
HashMap	允许为 null	允许为 null	AbstractMap	线程不安全

12 .异常的结构，运行时异常和非运行时异常，各举个例子

1.异常的结构：一般是指java虚拟机相关的问题，如系统崩溃、虚拟机出错误；
2.运行时异常：空指针一样、数组越界异常、类型转换异常；（系统可以处理）
3.非运行时异常：IOException、SQLException。（要代码捕获，保证健壮性）

14. String a= “abc” ，String b = “abc”， String c = new String(“abc”) ，String d = “ab” + “c” 。他们之间用 == 比较的结果

结果：a == b == d !== c
原因：JVM 的常量池 ；
会加入常量池的： “abc”；“ab”+“c”；
不会加入常量池的： new String(“abc”)；new String(“ab”)+new String(“c”)；new String(“ab”)+“c”；null+“abc” 。

15. String 类的常用方法

contains() ；equals()；split()；trim()；subString()；startWith()等

16. Java 的引用类型有哪几种

1.强应用：只要强引用存在，垃圾回收器将永远不会回收被引用的对象；
2.软应用：在内存足够的时候，软引用对象不会被回收，只有在内存不足时，系统则会回收软引用对象；
3.弱引用：无论内存是否足够，只要 JVM 开始进行垃圾回收，那些被弱引用关联的对象都会被回收；
4.虚应用：又称“幽灵引用”，无法通过引用获取对象，当虚应用被回收时，通知引用方。

17. 抽象类和接口的区别

参数	抽象类	接口
默认的方法实现	允许有	不允许有（java8允许有）
实现	继承extends	实现implements
与正常Java类的区别	除了你不能实例化抽象类之外，它和普通Java类没有任何区别	接口是完全不同的类型
构造器	抽象类可以有构造器	接口不能有构造器
访问修饰符	抽象方法可以有public、protected和default这些修饰符	接口方法默认修饰符是public。你不可以使用其它修饰符。
main方法	抽象方法可以有main方法并且我们可以运行它	接口没有main方法，因此我们不能运行它。

18. java的基础类型和字节大小。

基本类型	说明	字节数	位数	值的范围
boolean	布尔型	1	8	0,1
byte	字节	1	8	-2^7 ~ 2^7
char	字符型	2	16	\u0000 ~ u\ffff
short	短整型	2	16	-2^15 ~ 2^15
int	整型	4	32	-2^31 ~ 2^ 31
float	浮点型	4	32	-3.40292347E+38 ~ 3.40292347E+38
long	长整型	8	64	-2^63 ~ 2^63
double	双精度	8	64	-1.79769313486231570E+308 ~ 1.79769313486231570E+308

19. Hashtable,HashMap,ConcurrentHashMap 底层实现原理与线程安全问题（建议熟悉 jdk 源码，才能从容应答）

HashMap 是线程不安全的，主链是数组，冲突链是链表（java8中冲突链是链表或红黑树）
Hashtable 和 HashMap 类似 ，但是是线程安全的 。
ConcurrentHashMap 是线程安全的，采用了锁分段技术，主链是一个数组，每个节点有一个分段（HashMap），新增、修改的时候只锁一个分段，提高并发性能。

20. 如果不让你用Java Jdk提供的工具，你自己实现一个Map，你怎么做。

说了HashMap源代码，如果我做，就会借鉴HashMap的原理，说了一通HashMap实现。

21. Hash冲突怎么办？哪些解决散列冲突的方法？

1.参照hashMap，冲突就加到冲突链上（拉链法）；
2.设计一个好的hash算好，让散列均匀点，没有再往深度研究了。

22. HashMap冲突很厉害，最差性能，你会怎么解决?从O（n）提升到log（n）咯，用二叉排序树的思路说了一通

hash冲突时候HashMap使用拉链法，在java7中冲突链是一个链表，他的时间复杂度是O（n），如果hash冲突的很厉害，我会参照java8的做法，冲突链使用红黑树，提升他的时间复杂度到log（n）。

23. rehash

1.新分配一个2倍于原hashMap的数组内存–>循环迭代旧数据，重新进行hash计算，放入新地址中。
2.所以在HashMap初始化时指定集合初始值大小：initialCapacity = (需要存储的元素个数 / 负载因子) + 1，rehash的成本太高。

24. hashCode() 与 equals() 生成算法、方法怎么重写

// TODO

二、Java IO

1. 讲讲IO里面的常见类，字节流、字符流、接口、实现类、方法阻塞。

分类	接口	常见实现类	方法阻塞
字节流	InputStream、OutputStream	FileInputStream、FileOutputStream；BufferedInputStream、BufferedOutputStream
字符流	Reader 、Writer	FileReader 、FileWriter；BufferedReader 、BufferedWriter
基于磁盘操作	File
基于磁盘操作	Socket

同步：就是在发出一个功能调用时，在没有得到结果之前，该调用就不返回。
阻塞：阻塞调用是指调用结果返回之前，当前线程会被挂起。函数只有在得到结果之后才会返回。

2. 讲讲NIO。

NIO是一种基于通道和缓冲区的 I/O 方式，它可以使用 Native 函数库直接分配堆外内存，然后通过一个存储在 Java 堆的 DirectByteBuffer 对象作为这块内存的引用进行操作，避免了在 Java 堆和 Native 堆中来回复制数据
NIO 是一种同步非阻塞的 IO 模型。同步是指线程不断轮询 IO 事件是否就绪，非阻塞是指线程在等待 IO 的时候，可以同时做其他任务。
同步的核心就是 Selector，Selector 代替了线程本身轮询 IO 事件，避免了阻塞同时减少了不必要的线程消耗；
非阻塞的核心就是Channel和Buffer，当 IO 事件就绪时，可以通过写道缓冲区，保证 IO 的成功，而无需线程阻塞式地等待。
在网络长连接同时传输数据也不是很多的情况下，提升性能非常有效，但是会增加CPU消耗

3.IO调优

// TODO

4. String 编码UTF-8 和GBK的区别?

GBK	UTF-8
包含所有中文	包含全世界所有国家需要用到的字符
双字节	英文使用8位（即一个字节），中文使用24位（三个字节）来编码
国家编码	国际编码，通用率高

5. 什么时候使用字节流、什么时候使用字符流?

字符流的应用场景： 如果是读写字符数据的时候则使用字符流，如Excel、txt。
字节流的应用场景： 如果读写的数据都不需要转换成字符的时候，则使用字节流，如音频、图片。

6. 递归读取文件夹下的文件，代码怎么实现

private static void loopOutAllFileName(String fileDir) {  
        if (fileDir == null) {  
            return;  
        }  
        File[] fileList = new File(fileDir).listFiles();  
        if (fileList == null) {  
            return;  
        }  
        for (File file : fileList ) {  
            if (file.isFile()) {  
                System.out.println(file.getName());  
            } else if (file.isDirectory()) {  
                System.out.println(file.getAbsolutePath() +"  是一个目录, 目录中的文件为:");  
                loopOutAllFileName(file.getPath());  
            } else {  
                System.out.println("文件读入有误！");  
            }  
        }  
    } 

三、Java Web

1. session和cookie的区别和联系，session的生命周期，多个服务部署时session管理。

联系：session和cookie都是为了确认用户身份信息，保持用户的连续状态的；
区别：session保存在服务端，cookie保存在客户端。
生命周期：第一次请求服务器（访问非静态资源）时创建，超时是销毁。
多个服务部署时session管理：使用分布式缓存框架，把Session存在缓存中，实现Session共享。

2. servlet的一些相关问题

生命周期：初始化init() --> 处理请求service() (也就是继承HttpServlet，重写doGet、doPost方法)–> 销毁destroy() 。
工作模式：单实例多线程。

3. webservice相关问题

// TODO

4. jdbc连接，Class.forName方式的步骤，怎么声明使用一个事务。举例并具体代码

static {
		try {
			Class.forName("com.mysql.jdbc.Driver");
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
}

// 声明使用一个事务
Connection conn = DriverManager.getConnection(url , user , password); 
conn.setAutoCommit(false);
Statement stat = conn.createStatement();	
stat.executeQuery("sql语句");
conn.commit(); / conn.rollback();

5. 无框架下配置web.xml的主要配置内容

<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath:application.xml</param-value>
</context-param>
	
<listener>
		<description>spring监听器</description>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

<filter>
		<filter-name>CharacterEncodingFilter</filter-name>
		<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
		<init-param>
			<param-name>encoding</param-name>
			<param-value>UTF-8</param-value>
		</init-param>
		<init-param>
			<param-name>forceEncoding</param-name>
			<param-value>true</param-value>
		</init-param> 
</filter>
<filter-mapping>
		<filter-name>CharacterEncodingFilter</filter-name>
		<url-pattern>/**</url-pattern>
</filter-mapping>

<servlet>
		<servlet-name>SpringMVC</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>classpath:application-mvc.xml</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
		<async-supported>true</async-supported>
</servlet>
<servlet-mapping>
		<servlet-name>SpringMVC</servlet-name>
		<url-pattern>*.do</url-pattern>
</servlet-mapping>

<welcome-file-list>
		<welcome-file>index.jsp</welcome-file>
</welcome-file-list>

6. jsp和servlet的区别

联系：JSP的本质就是Servlet，JSP经过编译后就是就变成了Servlet ；
区别：JSP擅长页面表现，Servlet擅长逻辑处理。

四、JVM

###1. Java的内存模型以及GC算法

###2. jvm性能调优都做了什么

###3. 介绍JVM中7个区域，然后把每个区域可能造成内存的溢出的情况说明

###4. 介绍GC 和GC Root不正常引用。

###5. 自己从classload 加载方式，加载机制说开去，从程序运行时数据区，讲到内存分配，讲到String常量池，讲到JVM垃圾回收机制，算法，hotspot。反正就是各种扩展

###6. jvm 如何分配直接内存， new 对象如何不分配在堆而是栈上，常量池解析

###7. 数组多大放在 JVM 老年代（不只是设置 PretenureSizeThreshold ，问通常多大，没做过一问便知）

###8. 老年代中数组的访问方式

###9. GC 算法，永久代对象如何 GC ， GC 有环怎么处理

###10. 谁会被 GC ，什么时候 GC

###11. 如果想不被 GC 怎么办

###12. 如果想在 GC 中生存 1 次怎么办

五、开源框架

1. hibernate和ibatis的区别

1.ibatis简单易学，hibernate相对较复杂，门槛较高；
2.ibatis需要手写sql语句，也可以生成一部分，hibernate则基本上可以自动生成，偶尔会写一些hql。同样的需求,ibatis的工作量比hibernate要大很多，同时，hibernate自动生成sql在更换数据库时移植性更好。
3.当系统属于二次开发,无需对数据库结构进行控制和修改,那ibatis的灵活性将比hibernate更适合（hibernate可以自动生成数据库表）；
4.系统数据处理量巨大，性能要求极为苛刻，这往往意味着我们必须通过经过高度优化的sql语句（或存储过程）才能达到系统性能设计指标，在这种情况下ibatis会有更好的可控性和表现；
5.ibatis这种po是扁平化的，hibernate映射的po是可以表达立体的对象继承，聚合等等关系的(mybatis得到了优化) 。

2. 讲讲mybatis的连接池。

MyBatis的数据源有3种：

类型	描述
UNPOOLED	不使用连接池的数据源
POOLED	使用连接池的数据源
JNDI	使用JNDI实现的数据源

第三方连接池 ： C3P0 ; durid
// TODO

3.mybatis原理

mybatis是对jdbc的封装
1.我们在Spring容器中注册了SqlSessionFactoryBean，该类实现了InitializingBean接口，所以在容器初始化时会调用afterPropertiesSet方法，创建SqlSessionFactory，把一些相关配置全部加载进Configuration；
2.与spring进行集成的时候，我们在Spring容器中注册了包扫描，它会把路径下的dao接口注册到BeanDefinitionRegistry，并且改变的他的类型为MapperFactoryBean;
3.当请求过来的时候，通过MapperFactoryBean的getObject()通过JDK动态代理的方式生成了他的代理对象；
4.在代理对象中，通过SqlSessionFactory获取SqlSession，通过SqlSession进行数据库的操作；
5.打开sqlSession，获取数据库连接；
6.从缓存（SqlMapExecutorDelegate对象的map）中获取根据xml生成的statement对象 sqlExecutor生成prepareStatement；
7.执行sql,返回封装结果。

3. spring框架中需要引用哪些jar包，以及这些jar包的用途

###4. springMVC的原理

###5. springMVC注解的意思

###6. spring中beanFactory和ApplicationContext的联系和区别

###7. spring注入的几种方式（循环注入）

8. spring如何实现事物管理的

1.Spring的事务管理依赖于数据库对事务的支持；
2.Spring有两种事物处理机制，一是声明式事物，二是编程式事物；
3.Spring的声明式事务管理在底层是建立在AOP的基础之上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。声明式事务最大的优点就是不需要通过编程的方式管理事务，这样就不需要在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事务规则声明（或注解），便可以将事务规则应用到业务逻辑中。因为事务管理本身就是一个典型的横切逻辑，正是AOP的用武之地。Spring开发团队也意识到了这一点，为声明式事务提供了简单而强大的支持。Spring强大的声明式事务管理功能，这主要得益于Spring依赖注入容器和SpringAOP的支持。依赖注入容器为声明式事务管理提供了基础设施，使得Bean对于Spring框架而言是可管理的；而SpringAOP则是声明式事务管理的直接实现者。和编程式事务相比，声明式事务唯一不足地方是，后者的最细粒度只能作用到方法级别，无法做到像编程式事务那样可以作用到代码块级别。但是即便有这样的需求，也存在很多变通的方法，比如，可以将需要进行事务管理的代码块独立为方法等等。核心接口 PlatformTransactionManager事务管理器 。
4.编程式事务Spring的编程式事务即在代码中使用编程的方式进行事务处理，可以做到比声明式事务更细粒度。有两种方式一是使用TransactionManager，另外就是TransactionTemplate。
5.这样也会产生一些问题；比如在同一类内部，使用嵌套事务时，事务不生效的问题，原因是因为方法进行内部调用时，内部没有通过AOP代理，直接调的目标方法，所以不生效；解决方法是调用内部方法的代理。
Spring的7种事务传播行为

行为	含义
PROPAGATION_REQUIRED	如果存在一个事务，则支持当前事务。如果没有事务则开启
PROPAGATION_SUPPORTS	如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行
PROPAGATION_MANDATORY	如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常
PROPAGATION_REQUIRES_NEW	总是开启一个新的事务。如果一个事务已经存在，则将这个存在的事务挂起
PROPAGATION_NOT_SUPPORTED	总是非事务地执行，并挂起任何存在的事务
PROPAGATION_NEVER	总是非事务地执行，如果存在一个活动事务，则抛出异常
PROPAGATION_NESTED	如果一个活动的事务存在，则运行在一个嵌套的事务中（嵌套类；内部报错，内部回滚；外部报错，全部回滚）.如果没有活动事务,则按PROPAGATION_REQUIRED属性执行

事务的4种特性
原子性
一致性
隔离性
持久性

事务的4种隔离级别

隔离级别	影响
ISOLATION_DEFAULT	默认级别 （对大多数数据库来说就是ISOLATION_READ_COMMITTED）；MySQL可以使用"select @@tx_isolation"来查看默认的事务隔离级别
ISOLATION_READ_UNCOMMITTED	读未提交，即能够读取到没有被提交的数据，所以很明显这个级别的隔离机制无法解决脏读、不可重复读、幻读中的任何一种，因此很少使用
ISOLATION_READ_COMMITTED	读已提交（大多数数据库的默认级别），即能够读到那些已经提交的数据，能够防止脏读，但是无法限制不可重复读和幻读
ISOLATION_REPEATABLE_READ	重复读，读取了一条数据，这个事务不结束，别的事务就不可以改这条记录，这样就解决了脏读、不可重复读的问题，但是幻读的问题还是无法解决
ISOLATION_SERIALIZABLE	串行读，代价最大、可靠性最高的隔离级别，所有的事务都是按顺序一个接一个的执行。

名称	定义
脏读	A事务读取B事务尚未提交的更改数据
不可重复读	不可重复读是指A事务读取了B事务已经提交的更改数据。假如A在取款事务的过程中，B往该账户转账100，A两次读取的余额发生不一致
幻读	A事务读取B事务提交的新增数据,会引发幻读问题。幻读一般发生在计算统计数据的事务中，例如银行系统在同一个事务中两次统计存款账户的总金额，在两次统计中，刚好新增了一个存款账户，存入了100，这时候两次统计的总金额不一致

9. springIOC

1.IOC是“控制反转”，或者说是“依赖注入”，它不是什么技术，而是一种设计思想；
2.它解决了类与类之间的强耦合问题；
3.对Spring来说，就是由SpringIOC容器来负责对象的生命周期、对象间依赖关系的管理。

10. spring中bean的实例化过程

1.容器启动阶段，将所有的bean实例化为BeanDefinition注册在spring容器的BeanDefinitionRegistry中；
2.请求过来的时候，如果是单例的，先检查是否已经实例化过，是则直接返回，如果是prototype的进入实例化流程
3.当需要实例化bean的时候–>通过beanName获取BeanDefinition，以获取bean的相关信息–>通过反射或Cglib字节码的方式生成BeanWrapper实例–>通过操作BeanWrapper设置对象的属性–>检查它的aware接口去注入相关依赖，如果他依赖没有实例化，先实例化依赖–>BeanPostProcesser前置处理–>检查是不是InitializingBean决定是否调用afterPropertiesSet方法–>BeanPostProcesser后置处理等–>获取我们需要的实例化对象。

10. spring AOP的原理

1.Spring AOP 采用JDK动态代理机制和Cglib动态字节码生成技术实现的；
2.JDK动态代理机制和字节码技术都是在运行期间为目标对象生成一个代理对象，并将横切逻辑织入到这个代理对象中，系统最终使用的是织入了横切逻辑的代理对象，而不是真正的那个目标对象。
3.JDK动态代理机制基于接口，必要需要有接口；Cglib动态字节码基于类，是继承，不能有final；
4.在JDK动态代理中，发起请求调用a()方法–>代理对象重写的a()方法–>重写的a()方法调用invoke()–>invoke()方法中做切面处理、逻辑调用–>最终返回；
5.应用场景：安全检查、性能检查、异常处理、缓存等。

###11. hibernate中的1级和2级缓存的使用方式以及区别原理（Lazy-Load的理解）

###12. Hibernate的原理体系架构，五大核心接口，Hibernate对象的三种状态转换，事务管理

#六、多线程

###1. Java创建线程之后，直接调用start()方法和run()的区别

###2. 常用的线程池模式以及不同线程池的使用场景

###3. newFixedThreadPool此种线程池如果线程数达到最大值后会怎么办，底层原理。

###4. 多线程之间通信的同步问题，synchronized锁的是对象，衍伸出和synchronized相关很多的具体问题，例如同一个类不同方法都有synchronized锁，一个对象是否可以同时访问。或者一个类的static构造方法加上synchronized之后的锁的影响。

###5. 了解可重入锁的含义，以及ReentrantLock 和synchronized的区别

###6. 同步的数据结构，例如concurrentHashMap的源码理解以及内部实现原理，为什么他是同步的且效率高

###7. atomicinteger和Volatile等线程安全操作的关键字的理解和使用

###8. 线程间通信，wait和notify

###9. 定时线程的使用

###10. 场景：在一个主线程中，要求有大量(很多很多)子线程执行完之后，主线程才执行完成。多种方式，考虑效率。

###11. 进程和线程的区别

###12. 什么叫线程安全？举例说明

###13. 线程的几种状态###

###14. 并发、同步的接口或方法

###15. HashMap 是否线程安全，为何不安全。 ConcurrentHashMap，线程安全，为何安全。底层实现是怎么样的。

###16. J.U.C下的常见类的使用。 ThreadPool的深入考察； BlockingQueue的使用。（take，poll的区别，put，offer的区别）；原子类的实现。

###17. 简单介绍下多线程的情况，从建立一个线程开始。然后怎么控制同步过程，多线程常用的方法和结构

###18. volatile的理解

###19. 实现多线程有几种方式，多线程同步怎么做，说说几个线程里常用的方法

#七、网络通信
###1. http是无状态通信，http的请求方式有哪些，可以自己定义新的请求方式么。

###2. socket通信，以及长连接，分包，连接异常断开的处理。

###3. socket通信模型的使用，AIO和NIO。

###4. socket框架netty的使用，以及NIO的实现原理，为什么是异步非阻塞。

###5. 同步和异步，阻塞和非阻塞。

###6. OSI七层模型，包括TCP,IP的一些基本知识

###7. http中，get post的区别

###8. 说说http,tcp,udp之间关系和区别。

###9. 说说浏览器访问http://www.taobao.com，经历了怎样的过程。

###10. HTTP协议、 HTTPS协议，SSL协议及完整交互过程；

###11. tcp的拥塞，快回传，ip的报文丢弃

###12. https处理的一个过程，对称加密和非对称加密

###13. head各个特点和区别

###14. 说说浏览器访问http://www.taobao.com，经历了怎样的过程。

#八、数据库MySql

1. MySql的常用存储引擎

特性	MyISAM	InnoDB	MEMORY
存储限制	有	64TB	有
事务安全	不支持	支持	不支持
锁机制	表锁	行锁	表锁
B树索引	支持	支持	支持
哈希索引	不支持	不支持	支持
全文索引	支持	不支持	不支持
集群索引	不支持	支持	不支持
数据缓存		支持	支持
索引缓存	支持	支持	支持
数据可压缩	支持	不支持	不支持
空间使用	低	高	N/A
内存使用	低	高	中等
批量插入的速度	高	低	高
支持外键	不支持	支持	不支持

1.MyISAM存储引擎：由于该引擎不支持事务、也不支持外建，所以访问速度比较快。因此对事务完整性没有要求并比访问为主的应用适合该存储引擎。
2.InnoDB存储引擎：由于该引擎在事务上存在优势，及具有提交、回滚和崩溃恢复的能力的事务安装，所以比MyISAM存储引擎占用更多的磁盘空间。因此需要进行频繁的更新、删除操作，同事对事务的完整性要求比较高的，需要实现并发控制的场景，适合。
3.MEMORY存储引擎：改存储引擎使用内存来存储数据，因此该引擎是数据访问速度快，但安全上没有保障。如果应用中设计数据比较小，需要进行快速访问，则适合使用该存储引擎。
4.使用哪一种引擎需要灵活选择，一个数据库中多个表可以使用不同引擎以满足各种性能和实际需求，使用合适的存储引擎，将会提高整个数据库的性能。

2. 索引

索引的种类：普通索引、唯一索引、全文索引、单列索引、多列索引、空间索引
适合建索引的场景：
a)经常被查询的字段，即where子句
b)在分组的字段，即在Group by 子句
c)存在依赖关系的字段，即主键或外建
d)设置唯一约束的字段
不适合场景：
a)不经常被使用
b)拥有许多重复数值的字段
索引的优化： 见数据库优化；
索引原理：
// TODO

###3. Mysql怎么分表，有几种方式，有什么工具，以及分表后如果想按条件分页查询怎么办(如果不是按分表字段来查询的话，几乎效率低下，无解)

###4. 分表之后想让一个id多个表是自增的，效率实现

###5. MySql的主从实时备份同步的配置，以及原理(从库读主库的binlog)，读写分离

6. 写SQL语句。。。

/* mysql删除表中相同数据，只保留最早的一条数据 */
/* mysql不能先select一个表的记录，在按此条件进行更新和删除同一个表的记录 */
delete from t_user where 
name in (select name from (SELECT name from t_user GROUP BY name HAVING count(name)>1) x )
and id NOT in (select id from (select min(id) id FROM t_user GROUP BY `name`) y);

###7. 索引的数据结构，B+树

###8. 事务的四个特性，以及各自的特点（原子、一致、隔离、持久），项目怎么解决这些问题

9. 数据库的锁：行锁，表锁；乐观锁，悲观锁，怎么实现

类型	实现
行锁	UPDATE T … WHERE ID = ？ ; SELECT … FROM T FOR UPDATE
表锁	UPDATE T … ； MYISAM 下 增删改
乐观锁	SELECT * , version FROM T… --> UPDATE * , vesion WHERE id = ? AND version = ?
悲观锁	SELECT * FROM T WHERE ID = ? FOR UPDATE --> UPDATE …FROM T WHERE ID = ?

innodb的行锁是通过索引添加的，所以where条件没索引会锁表

10. 数据库事务的几种粒度；

粒度：表锁、行锁 ；
锁的类型：

类型	代号	粒度	sql
共享锁	S	行、多个行	SELECT … LOCK IN SHARE MODE
排它锁	X	行、多个行	SELECT … FOR UPDATE
意向共享锁	IS	表锁
意向排它锁	IX	表锁

注意
会话事务会自动给 INSERT、UPDATE、DELETE 加上排它锁
锁生效与否与数据库引擎有关,如MYISAM新增就直接锁表
锁与事务隔离级别有关
InnoDB锁为行级锁，注意此时Where条件指定列要有主键或者索引

锁兼容性

	X	S	IX	Is
X	冲突	冲突	冲突	冲突
S	冲突	兼容	冲突	兼容
IX	冲突	冲突	兼容	兼容
IS	冲突	兼容	兼容	兼容

11. 关系型和非关系型数据库区别

12.树形列表，一次性取出节点及节点以下子节点，表怎么设计

表设计

字段	含义
id	id
name	节点名称
pid	父节点id
path	父节点全路径，例：1,2,3

思路
利用 FIND_IN_SET 函数，获取当前节点及其所有子节点。

//获取第一个节点为1的所有子节点
select * from t_tree where FIND_IN_SET(1,path) = 1

13.数据库优化

Sql优化

#九、设计模式

###1. 单例模式：饱汉、饿汉。以及饿汉中的延迟加载,双重检查

###2. 工厂模式、装饰者模式、观察者模式。

###3. 工厂方法模式的优点（低耦合、高内聚，开放封闭原则）

#十、算法

###1. 使用随机算法产生一个数，要求把1-1000W之间这些数全部生成。（考察高效率，解决产生冲突的问题）

###2. 两个有序数组的合并排序

###3. 一个数组的倒序

###4. 计算一个正整数的正平方根

###5. 说白了就是常见的那些查找、排序算法以及各自的时间复杂度

###6. 二叉树的遍历算法

###7. DFS,BFS算法

###9. 比较重要的数据结构，如链表，队列，栈的基本理解及大致实现。

###10. 排序算法与时空复杂度（快排为什么不稳定，为什么你的项目还在用）

###11. 逆波兰计算器

###12. Hoffman 编码

###13. 查找树与红黑树

#十一、并发与性能调优

###1. 有个每秒钟5k个请求，查询手机号所属地的笔试题(记得不完整，没列出)，如何设计算法?请求再多，比如5w，如何设计整个系统?

###2. 高并发情况下，我们系统是如何支撑大量的请求的

###3. 集群如何同步会话状态

###4. 负载均衡的原理

###5 .如果有一个特别大的访问量，到数据库上，怎么做优化（DB设计，DBIO，SQL优化，Java优化）

###6. 如果出现大面积并发，在不增加服务器的基础上，如何解决服务器响应不及时问题“。

###7. 假如你的项目出现性能瓶颈了，你觉得可能会是哪些方面，怎么解决问题。

###8. 如何查找 造成 性能瓶颈出现的位置，是哪个位置照成性能瓶颈。

###9. 你的项目中使用过缓存机制吗？有没用用户非本地缓存

#十二、其他

###1.常用的linux下的命令

###2.redies

十三、在广金所项目中遇到了那些问题，后来是怎么解决的

1.分布式环境下，要求合同号每天从1开始增加，考虑并发

2.嵌套事务不生效

Spring 事务是基于SpringAOP 来实现的，在同一个实现类中a()方法直接调用b()方法，由于是本地调用，所以是没有横切逻辑包含其中，所以不生效；
解决办法，a()方法调用b()的代理对象，或者不写在同一个类中。

3.报表系统，大数据量环境下，数据访问缓慢

5.君子签非对称加密问题

7.并发情况下，产品剩余额度更新问题，用redies

8.等额本息的算法，最后一期怎么算的

前面通过公式进行等额本息的计算，在最后一期进行尾差法（总本金-前面全部兑付本金）进行等额本息的计算。

9.对账是怎么实现的

对账分：充值/提现；交易；佣金
步骤：
1.获取银行推送数据并入库；
2.抽取本地数据存入每日账单表；
3.通过关联查询（数据对不上，附表会存在流水号为null的情况），如果存在差异则对账成功，存在差异则取出数据

10.兑付数据中，借款人的钱不够投资人的兑付

投资人当期要还1000本金，3个投资人要兑付1000本金，由于他可能是除不净的，所以存在3个人本金加起来不是1000整的情况。
在我们平台由于对借款人采取进位、对投资人采取摸位，差额用一个字段存储。

https://blog.csdn.net/wangyunpeng0319/article/details/72803096