基础必备知识

1、语言基础

1.1 Java基本数据类型及长度

类型	占存储空间
byte	1字节
boolean	1个bit位
short	2字节
char	2字节
float	4字节
int	4字节
long	8字节
double	8字节

1.2 位运算

位运算符	作用
&	两个操作数都为1，结果为1 ，否则为 0
|	两个操作数的位只有一个为1结果就为1，否则为0
~	取反运算，0取反为-1，1取反为-2
^	异或运算 ，相同为0 不同为1
<<	左移
>>	右移
>>>	忽略符号位右移

//利用位运算求两个int类型整数求和
while(b != 0){
   int _a = a ^ b;
   int _b = (a & b) << 1;
   a = _a;
   b = _b;
}
return a;

//a+=b 和 a=a+b有什么区别
byte a = 20;
byte b = 19;
b+=a;
b=a+b; //报错

//Object中有哪些方法
private static native void registerNatives();
protected  native Object clone();
protected  void  finalize(); 
public final native Class<?> getClass();
public native int hashCode();
public boolean equals(Object obj);
public String  toString();  //返回当前类的名字 + @ + hashCode值的16进制数

1.3 jdk1.8的新特性

Lambda表达式
常用方法：

1. filter()
2. count()
3. limit()
4. skip()
5. map()
6. concat()
7. forEach()
8. collect()

Date 与 Time API，稳定的日期与时间库
接口中可以有静态，默认的方法

1.4 内存模型

内存区域：
     1、方法区、堆 （线程共享）
     2、虚拟机栈、本地方法区、程序计数器（生命周期和线程同步，不需要GC）
堆存放所有对象的实例以及数组，是重点GC对象

方法区存放了要加载的类信息（名称、修饰符）、类中的静态常量、类中定义位final类型的常量、Field信息、方法信息，当程序中通过Class对象的getName.isInterface等方法来获取对象时，这些数据都是来自于方法区，它存储的信息相对比较稳定，在一定条件下才会被GC

1.5 GC回收，双亲委派模式

主要的GC是堆的垃圾回收，如果一个对象没有任何引用，那么它将会被回收。
一般采用引用计数法 和 可达性分析发（根搜索发）来判断对象是否存活。

GC ROOTS对象向下搜索，判断是否有引用链

• 虚拟机栈中引用的对象
• 方法区中类静态属性引用的对象
• 方法区中常量引用的对象
• 本地方法栈中JNI引用的对象

1.6 内存泄漏，内存溢出

内存泄漏memory leak，内存泄漏是指程序在申请内存后，无法释放已经申请的内存
内存溢出out of memory，是指程序在申请内存时，没有足够的内存空间供其使用
jmap -dump:format=b,file=dumpFileName pid

2、框架集合

2.1 Java提供的集合关系图

2.2 HashMap和HashTable和ConcurrentHashMap有何不同，ArrayList和Vector和LinkedList有何区别(Hash系讲一下源码）

HashMap常见的K-V存储集合，但是在多线程环境下，线程不安全。

1. 判断当前桶是否为空值，空的话就需要初始化
2. 根据当前的key的hashCode定位到具体的桶并判断是否为空，为空表明没有Hash冲突直接在当前位置创建一个新桶即可
3. 如果当前桶有值，也就是发生了Hash通途

2.3 hash碰撞、冲突、散列函数

3、多线程

3.1 撸代码保证线程执行顺序

3.2 进程线程区别（概念问题）

3.3 Java中CountDownLatch 和 CycliBarrier区别，Runnable和Callable区别

3.4 线程状态，如何终止线程，volatile原理实现和使用场景

3.5 手撸生产者消费者模型

3.6 ThreadLocal 、FutureTask、interrupt、interrupted、isInterrupted

3.7 线程池，创建线程池的五个核心参数

3.8 sleep 和 wait的区别

3.9 fail-fast 和 fail-safe

3.10 性能调优监控工具jps、jstack、jmap、jhat、jstat、hprof使用和注意事项

3.11 synchronized 和 ReentrantLock

3.12 fork join框架

3.13 偏向锁、轻量级锁、重量级锁

3.14 Java的原子操作，CAS

4、JavaWeb

4.1 四种请求方式的区别

4.2 tomcat内存优化

4.3 状态码、TCP、UDP

5、linux常用命令

6、Mysql

6.1 乐观锁与悲观锁的区别？

6.2 索引、事务隔离级别、存储引擎、主从库不一致怎么解决

7、redis

7.1 redis的数据结构

7.2 redis的持久化机制

7.3 热点数据

7.4 redis常见的性能问题和解决方案

7.5 redis的并发竞争问题如何解决

7.6 redis事务的命令和特征

8、Spring

8.1 IOC实现关键源码、和DI的区别

8.2 什么是aop

8.3 Springbean实例化，作用域，生生命周期，事务管理，事务的隔离级别和传播行为

8.4 BeanFactory和ApplicationContext有什么区别？

8.5 JDK动态代理和Cglib动态代理的区别

8.6 如何解决循环依赖

8.7 @Transactional的使用

8.8 获取Spring容器的常用4种方式

8.9 Spring支持的三种依赖注入方式

9、Mybaties

9.1 原理

9.2 mybaties和映射文件的关系

9.3 延迟加载、缓存、Excutor执行器、分页插件

10、Springboot

10.1 核心配置，启动流程，配置文件格式，核心注解

10.2 日志框架、热部署、配置加载顺序

10.3 Springboot2.0 和Springboot1.0有什么区别

11、微服务SpringCloud全家桶

11.1 和Dubbo有什么区别

11.2 服务熔断和服务降级

11.3 Eureka和Zookeeper服务注册与发现有什么区别

1. 熟悉哪几种设计模式？他们之间的区别？

• 单例模式: 对象的创建模式，保证了JVM中只存在一个实例对象，可以减少GC，较少对象存储资源。缺点: 不可继承，没有接口。
• 工厂模式: 提供一种创建对象的最佳方式，接口提供类别，实现类生产具体对象。

public interface car{
    public car getcar();
}
public class bmCar implements car{
    public car getcar(){
       return new bmCar();
    }
}

• 建造者模式: 在需要生成复杂内部结构时使用，即将多个简单的对象一步一步构建称为一个复杂对象
• 适配器模式: 继承或者依赖已有的对象，消除由于接口的不匹配而导致的不兼容问题。分为类的适配器、对象的适配器、接口的适配器
• 装饰器模式: 在原来的接口和实现类添加方法，构成一个新的实现类
• 代理模式: 把目标方法交给代理去执行，和适配器的区别： 适配器主要是为了去修改接口定义的方法，以为了去适配更多的功能，而代理模式不改变接口方法。和装饰器的区别: 装饰器是为了增强功能，而代理模式是为了加强控制
• 观察者模式: 对象间一对多的依赖关系，当一种对象发生改变的时候，其他所有依赖他的对象都得到通知，并发生对应的改变，

3. 手写单例模式？

• 首先要考虑什么是单例模式？为什么要用单例模式？
  单例模式是一个创建对象模式，只产生一个实例对象。使用单利模式的目的是减少相同对象的个数，进而减少GC，减少内存占用。
• 饥饿模式（先以类的实例对象作为类的全局变量，即类初始化的时候就在内存中存在实例对象）

public class EalerSingleton{
	private static instance = new EalerSingleton();
    private EalerSingleton(){}
    public static getSingleton(){
        return  instance;      			
    }
}
//优点:线程安全，但是需要提前创建实例

• 线程安全的饥饿模式

public class Singleton{
      private static class SingletonHolder(){
          private static Singleton instance = new Singleton();
      }
      private Singleton(){}
      public Singleton getInstance(){
           return SingletonHolder.instance;
      }
}

• 线程安全的懒汉模式

public class LazySingleton{
    private static LazySingleton instance = null;
    private LazySingleton(){}
    public synchronized LazySingleton getInstance(){
        if(null == instance ){
           instance = new LazySingleton();
        }
        return instance;
    }
    
}
//缺点:只有在第一次创建的时候才会走判断，所以可以考虑减小锁的力度

• 高效一点的懒汉单例模式

public class LazySingleton{
    private static LazySingleton instance = null;
    private LazySingleton(){}
    public LazySingleton getInstance(){
        if( null == instance ){
           synchronized(LazySingleton.class){
               LazySingleton temp = instance;
               if( null == temp ){
                  synchronized(LazySingleton.class){
                     temp = new LazySingleton();
                  }
               }
               instance = temp;
           }
        }
        return instance;
    }
}
//可以解决指令重排序问题，用以下这种也可以
public class LazySingleton{
    private static volatile LazySingleton instance = null;
}

• 通用型的单例模式

public class SingleParent{
     private static Map<Class<? extends SingleParent> , SingleParent> INSTANCE_MAP = new HashMap();
     private SingleParent(){}
     public synchronized static <E extends SingleParent>SingleParent getInstance(Class<E> instanceClass){
     if(INSTANCE_MAP.containsKey(instanceClass)){
         return INSTANCE_MAP.get(instanceClass);
     }else{
         SingleParent instance = instanceClass.newInstance();
         INSTANCE_MAP.put(instanceClass,instance);
         return instance;
     }
     }    
}

4. 常见的http状态码？

• 200：请求成功
• 204：请求处理成功，但是没有任何资源返回给客户端
• 206：部分请求
• 301：永久重定向
• 302：临时重定向
• 303：GET临时重定向
  当301、302、303响应状态码返回的时候，所有的浏览器都会把POST改成GET，并删除请求报文内的主题。
• 304：资源已找到，但是未符合请求头的请求条件
• 400：请求语法错误
• 401：需要HTTP协议认证信息
• 403：被服务器拒绝
• 404：服务器上没有请求的资源
• 500：服务器内部错误
• 502：网关错误
• 503：服务器正忙

线程池

public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,
          TimeUnit unit,BlockingQueue<Runnable> workQueue,
          ThreadFactory threadFactory,RejectedExecutionHandler handler)

corePoolSize - 池中所保存的线程数，包括空闲线程。

maximumPoolSize - 池中允许的最大线程数。

keepAliveTime - 当线程数大于核心时，此为终止前多余的空闲线程等待新任务的最长时间。

unit - keepAliveTime 参数的时间单位。

workQueue - 执行前用于保持任务的队列。此队列仅保持由 execute 方法提交的 Runnable 任务。

threadFactory - 执行程序创建新线程时使用的工厂。

handler - 由于超出线程范围和队列容量而使执行被阻塞时所使用的处理程序。