java知识大纲

下图梳理了java基础和面试题，包括JVM类加载机制、java集合、java多线程、java基础、面试问题等，有需要的朋友收藏下图学习吧！

java

GC

分代收集算法

在新生代-复制算法

因为在新生代中 每次gc只有少量的对象还存活，只要通过复制存活的对象来完成收集即可。

老年代-标记算法

在老年代存放的都是长期存活的对象，只有少量需要回收，只需要一一标记回收，直接释放内存即可。

分区收集算法

将整个堆空间分成连续的小分区，每个小区间独立使用，回收。好处：不需要停掉整个堆空间，只需要根据小分区来回收，很短暂的停顿。

GC垃圾收集器

新生代

复制收集

标记-整理收集

老年代

标记-整理收集

serial（连续）垃圾收集器

通过单线程去收集垃圾，同时会暂停所有线程，所以能获得最高的单线程收集效率，简单高效。 在jdk1.3.1前使用

ParNew（新式）垃圾收集器 （serial+多线程）

是serial垃圾收集器多线程版本，同样会暂停其他工作线程，默认开启和cup数目线程，是所有新生代的默认垃圾收集器。

Parallel Scavenge（并行清除）收集器

根据吞吐量控制收集时间，配置最大GC时间 时间越少，就会牺牲新生代的内存空间。内存越小 收集越快。

Serial Old 收集器

用于年老代收集算法， 单线程标记整理算法。配合Parallel Scavenge收集器 一起使用，新生代多线程，老年代单线程。 只能保证新生代吞吐量，不能保证整体吞吐量。

Parallel Old （并行年老代）收集器

在jdk1.6后，使用多线程整理标记算法，给年老代也提供吞吐量优先的垃圾收集器，对吞吐量有要求可以搭配Parallel Old （年老代） 和 Parallel Scavenge 收集器

cms收集器

多线程标记-清除算法 是一种年老代垃圾收集器。优点 获取最短垃圾回收停顿时间。

步骤

初始标记：标记 GCRoots（根）能直接关联的对象 ，如静态变量在调用的对象，如果无效就收集。

并发标记：根据GC roots 找到的对象 顺藤摸瓜 继续找下去。 这个不会暂停工作线程。

重新标记： 当用户程序运行导致 标记的对象继续被使用，需要修正 仍要暂停所有工作线程。

并发清除：清除GC Roots（根) 不可达对象，能和工作线程一起运行，不用暂停线程

G1 收集器

目前垃圾收集器理论发展最前沿的成果

1.基于标记-整理算法 不会产生内存碎片

2.可以非常精准控制停顿时间，在不牺牲吞吐量的前提下，实现低停顿垃圾回收

将堆内存划分几个大小固定的独立区域，并将这几个区域进行一个优先级排序，每次根据允许的收集时间，根据垃圾最多的区域 优先回收。 区域划分和优先级区域回收机制，确保在有限时间内获得最高的垃圾收集效率

java IO/NIO

阻塞IO模型

当用户发起io请求，内核会检查数据是否准备就绪，如果没有就绪就会等待就绪，用户线程处于阻塞状态，用户线程就会交出cpu。当数据准备好了 内核将拷贝到用户线程，并返回结果给用户线程。

非阻塞IO模型

当一个请求io,发起read方法，数据没有准备好，用户线程会一直发送read方法确认，直到数据准备好。非阻塞IO模型中，用户线程不断询问内核数据是否准备好，不会交出CPU ，会导致cpu占用率很高。

多路复用io模型

应用多路复用IO有NIO, 会开启一个子线程去监测 轮询多个socket的状态，当socket真正有需要处理的指令，才需要使用到IO资源。 可以大大减少资源的占用。 非阻塞IO是通过用户线程轮询， 但多路复用io的是用内核来执行循环，效率大大提高。 一旦响应体很大，会导致后续事件得不到及时处理，会影响新的轮询。

信号驱动IO

当用户线程发起了一个IO请求操作，会给对应的socket注册一个信号函数，线程可以先去做其他事情，当内核将数据复制到用户线程内存中，通知线程进行处理。 优点：线程不用阻塞。 缺点： 当数据量变大，信号产生频繁，性能会降低。

异步io模型

用户线程只需要给内核发送一个异步 IO 请求，就可以去其他的事情。 当内核将数据处理完成，回调操作成功通知 ，用户线程直接可以使用数据。IO操作两个阶段都不需要用户线程阻塞，全部由内核处理，收到信号IO就操作完成。

IO包

字节流

InputStream输入流

ByteArrayInputStream 字节数组输入流

fileInputSteam 文件输入流

FilterInputStream 过滤器输入流

BufferedInputStream 缓冲输入流

DataInputStream 数据输入流

LineNumberInputStream 行号输入流

Pushback(普修白客)InputStream 回推输入流

ObjectInputStream 对象输入流

PipedInputStream 管道输入流

SequenceInputStream 顺序输入流

StringBufferInputStream 字符串输入流

OutputStream 输出流

BayteArrayOutputStream 字节输出流

fileOutSteam 文件输出流

FilterOutStream 过滤器输出流

BufferedOutStream 缓冲输出流

DataOutStream 数据输出流

PrintStream 字符打印输出流

ObjectOutStream 对象输出流

PipedOutStream 管道输出流

字符流

Reader 读取流

BufferedReader 缓冲读取流

lineNumberReader 行号读取流

CharArrayReader字符数组读取流

FilterReader 过滤器读取流

PushbackReader 回推读取流

InputStreamReader 输入流读取流

FileReader 文件读取流

PipedReader 管道读取流

StringReader 字符串读取流

Writer 写入流

BufferedWriter 缓冲写入流

CharArrayWriter 字符数组写入流

FilterWriter 过滤器写入流

OutputStreamWriter 输出流写入流

FileWriter 文件写入流

PipedWriter 管道写入流

PrintWriter 字符打印写入流

StringWriter 字符串写入流

NIO

NIO三大核心

Channel(通道)

Channel和io 流是一个级别。流是单向的，但Channel是双向。

实现类有： 1. FileChannel 文件通道 2.DatagramChannel 数据报通道 3.SocketChannel 网络通道 4.ServerSocketChannel 服务网络通道

Buffer（缓冲区）

缓冲区实际上是个容器，连续数组。channel读写数据都要经过Buffer，

实现类： 1.ByteBuffer 字节缓冲区 2.IntBuffer 整数缓冲区 3.CharBuffer 字符缓冲区 4.LongBuffer 长缓冲区 5.DoubleBuffer 双重缓冲区 6.FloatBuffer 浮动缓冲区 7.ShortBuffer 短暂缓冲区

selector(选择器)

Selector类 轮询监测通道是否有事件发生，如果有事件要处理，就对每个事件相应响应，有读写事件，调用函数来进行读写，只需要单线程去处理，可以减少性能的开销。

基于Channel(通道)和Buffer（缓冲区）进行操作，数据读取 是从通道到缓冲区，写入是从缓冲区到通道。selector（选择器）用于监听多个通道的事件，比如连接打开，数据到达，通过单线程进行监听多个数据通道。IO是面向字流，NIO面向缓存区。

NIO缓存区： 只需要将数据读取到缓冲区，在缓冲区中可以前后移动，处理过程中灵活。但是要检查数据是否包含，不能覆盖未处理数据。 同比IO 需要从流读取所有数据，需要前后移动数据，也需要放入缓冲区操作。

NIO的非阻塞：只需要一个线程向通道发送一个请求读取数据，能拿到当前的可以用的数据，如果当前没有数据就什么也拿不到，当前线程可以去做其他事情。

JVM类加载机制

加载：加载class文件到内存里，作为方法区类的各种数据调用入口。 也可以读取jar包 ，war包。 或者是代理动态生成，jsp文件转换成class。

验证

检查class文件是否符合虚拟机的规范，不危害虚拟机的安全。

准备

这个阶段是为类分配内存，对变量进行赋值。 非static变量，在class编译后生成构造器 进行赋值。 static 的变量， 在编译时就给变量ConstantValue属性赋值。

解析

将符号引用解析成直接引用 解析前： String s=”adc”; System.out.println(“s=”+s); 解析后：System.out.println(“s=”+”abc”);

符号引用

虚拟机能接受的引用符号必须是一致的，引用符号定义要符合虚拟机的规范。 引用的目标不一定会加载到内存中。

直接引用

直接指向目标的指针，或者是一个能间接定位的句柄。但必须在内存是存在的。

初始化

所有class 加载完成后，进行执行java代码实现初始化

类构造器

编译器会手机类中的变量，生成构造器进行赋值。构造器执行顺序 父构造器早与子构造器。 不会执行类初始化的情况： 1. 通过子类引用父类的静态字段，只会触发父类的初始化，而不会触发子类的初始化。 2. 定义对象数组，不会触发该类的初始化。 3. 常量在编译期间会存入调用类的常量池中，本质上并没有直接引用定义常量的类，不会触 发定义常量所在的类。 4. 通过类名获取Class对象，不会触发类的初始化。 5. 通过Class.forName加载指定类时，如果指定参数initialize为false时，也不会触发类初 始化，其实这个参数是告诉虚拟机，是否要对类进行初始化。 6. 通过ClassLoader默认的loadClass方法，也不会触发初始化动作

类加载器

类加载器在JVM外实现，让应用程序来决定

启动类加载器（(Bootstrap ClassLoader）: 负责加载JAVA_HOME\lib目录下的类和jar包，也可以通过-Xbootclasspath参数指定路径去加载。

扩展类加载器（Extension ClassLoader）： 负责加载 JAVA_HOME\lib\ext 目录中的，或通过java.ext.dirs系统变量指定路径中的类 库

应用程序类加载器（Application ClassLoader）： 负责加载用户路径（classpath）上的类库。可以继承java.lang.ClassLoader 实现自定义加载器。

双亲委派

当类请加载，会先让父类先去加载，当父类加载器无法加载，在委派子类加载器去加载。无论怎么加载，都由顶层加载器加载到都是同一个Object类。

OSGI(Open Service Gateway Initiative)动态模型系统

面向java的动态模型系统，是java动态化模块化系统的规范

动态改变构造

无需重启去动态改变构造的功能，最小化耦合度和促使这些耦合可以管理。osgi 是面向服务的架构，让组件动态发现对方。

模块化编程与热插拔

osgi 可以实现 部分代码部署 停止 重新安装。但是不遵守双亲委托模型，不是用顶层加载器去加载，而是由自定义动态加载器去加载。

java集合

接口继承与实现关系

集合类：set(集)，list(列表包含queue)和Map(映射)

Collection: collection是集合list,set,queue的最基本接口

Iterator:迭代器，可以通过迭代器遍历集合所有的数据

Map

是映射表的基础接口

集合框架

Collection

List

ArrayList 数组列表

当删除，插入需要大量的复制 移动，比较消耗性能。比较适合的场景查找和遍历。

排列有序，可重复

底层使用数组

速度快，增删慢，getter()和seth

线程不安全

当容量不够时，ArrayList是当前*1。5+1

Vector 矢量

排列有序，可重复

底层使用数组

速度快，增删慢

线程安全，效率低

当容量不够时，Vector默认扩一倍容量

LinkedList 链表集合

排列有序，可重复

底层使用双向循环链表数据结构

查询速度慢，增删快，ADD()和remove()方法快

添加数据在尾部添加

线程不安全

可以成堆栈，队列，双向队列使用。

Set

set 存储无序，值不能重复

HashSet 哈希集

HashSet 数据结构 数组+链表 || 数组+红叉数树 将对象的hashcode算出来放到数组中，然后将对象放入数组下标中的链表。 当有相同哈希code，会比对象是否一致，一致就帮不能存储。 只能放不同的对象。

排列无序，不可重复

底层是HashMap

存取速度快

底层使用HashMap

TreeSet 树集

排列无序，不可重复

add可以进行升序 降序的排序，适用于Integer和String对象，但是自定义对象不可以，如果要支持需要重写Comparable接口的compareTo()方法

底层使用二叉树实现

排序存储

内部都是TreeMap的SortedSet

LinkeHashSet链表哈希集

采用hash表存储，并用双向链表记录插入顺序

内部是LinkeHashMap

继承HashSet类，操作与父类相同。

Queue

在两端出入的list,通过数组和链表实现。

Map

HashMap

键不可重复，值可重复

底层哈希表

线程不安全

允许Kay值为NULL, value也可以为NULL

可以使用synchronizedMap方法让hashMap有线程安全的能力

java7中

数据结构是数组+单向链表 数组放的是Entry的实例，包含四个属性 Kay,value,hash值，和用于单向链表的next

capacity(分配的存储容量) 数组每次扩容大小是当前两倍 loadFactor（负载因子），默认是0.75 threshoid(扩容的阈值): 等于capacity*loadFator

java8中

hashMap数据结构 数组+链表+红叉树

当链表元素超过8个，将链表转换为红黑树

HashTable

键不可以重复，值可重复

底层哈希表

线程安全

kay,value都不允许null

TreeMap

键不可以重复，值可重复

底层二叉树

java 多线程

Thread类

实现Runnable的一个实例，真正启动先，需要调.start方法，start方法是一个native（本地）方法。启动一个新线程，并调用run方法

Runnable接口

自定义类 当已经继承了其他类，不能继承Thread类。可以通过实现Runnable接口，实现run方法。调用时候new Thread（myThread）传入，调用start方法启动。

ExecutorService（线程池服务类），Callable<class>（可调用）接口， Futrue接口

ExecutorService 实现线程池

callable 让线程执行完成后调用这个接口实现返回方法

Futrue 获取返回的内容

线程池

基于线程池的方式

因为每次生成 销毁一个线程 非常消耗资源。 所以通过缓存起来，提前创建好，使用的时候调用。

newCachedThreadPool（缓存线程池）

创建一个根据需要的线程池，当需要的时候会创建一个线程，并把线程缓存起来。 同时也会检测如果线程超过60秒未被调用就清除掉。这样的好处不会占用很多资源。适用于异步任务。

newFixedThreadPool 固定线程池

创建固定数量可重用的线程池，当所有线程都在活动的状态时提交附加任务。没有可用线程时候，会先放到队列等待可用线程处理。如果在执行期间失败导致任何线程终止，会有新的线程代替处理。

newScheduledThreadPool 计划线程池

自定义计划的线程池，线程可以设置一定时间执行

newSingleThreadExecutor单线程池

这个线程池创建后只有一个线程，当这个线程死亡就会在创建一个线程继续执行任务

线程生命周期（状态）

新建（new）

由JVM分配内存，初始化其成员变量

就绪（runnable）

当线程对象调用了start()方法后，JVM会创建方法的调用栈和程序计数器，等等运行。

运行（running）

当就绪的线程获得CPU后就执行run方法，当前状态就处于运行状态

阻塞（Blocked）

阻塞状态是因为某种原因，让线程放弃CPU使用权。暂停运行直到Runnable就绪状态，才有机会再次运行。

等待阻塞 运行的线程执行wait()方法，JVM把线程放到等待队列

同步阻塞 运行时的线程碰到同步锁，当前有其他线程占用了这个对象，JVM会将线程放入锁池中

其他阻塞 （sleep/join） 调用sleep()和join()方法 或者发送i/O请求。JVM让当前线程阻塞。当sleep超时，join等待线程终止或超时，io请求结束。线程就会回到可运行状态。

死亡（Dead）

run()或者call()方法执行完结束

线程抛出未捕获的异常或者error

调用stop()方法，但是这种方法会容易死锁。

并不是创建线程池后，cpu一直被占着，是在多个线程中切换，多次运行，阻塞切换。

终止线程4种方式

程序运行结束

使用退出标志退出线程，如满足某种条件进行终止，使用while循环当条件是true或false 的变量来控制退出。 定义变量在外部控制 使用volatile 关键字

Interrupt()方法

阻塞过程中调用Interrupt() 会抛出InterruptException异常 ，一定要捕获异常break来跳出循环才能正常结束run方法

使用interrupt()方法做中断标志，和自定义中断标志是一样的。

stop()方法终止线程

Thread.stop()方法调用后会抛出ThreadDeatherror的错误，并且会是否子线持有的所有锁，导致其他数据拿到破坏的数据会出现程序错误。

sleep 与 wait 区别

sleep（）是Thread类的 wait()方法是对象的

sleep 根据设置时间会程序暂停，让出cpu给其他线程，但是他的监控依旧保持着。到了指定时间就会回到运行状态

sleep 不需要获取对象锁

wait（）方法 线程会放弃对象锁，将这个对象放入对象的等待锁定池中。只有针对此对象调用notify（） 通知线程，进入对象锁定池中获得对象锁进入运行状态。获得对象锁才有操作对象数据的权利。

java后台线程

Daemon(守护)线程 优先级是最低，给用户线程提供服务，守护线程创建的线程还是守护线程，线程级别是JVM，以Tomcat为例，应用暂停了，守护线程还在。 垃圾回收线程经典的守护线程，当无垃圾可回收，会回自动离开。当服务没有用户线程，守护线程也会去离开。JVM中的全部是守护线程。与系统共生死。通过设置setDaemon(true) 开启守护线程。

start 与 run 区别

start()方法来启动线程，不需要等待方法中run()执行，会往下执行。start是主线程执行，run是新开的子线程执行。

start（）方法只是让线程进入准备阶段

run()让线程进入运行状态，执行run函数当中的代码。run方法结束，线程终止。

java锁

乐观锁

不会对某个数据进行上锁，只是在修改前拿到数据记录一个版本号，在修改前查询一下这个数据对比一下版本号和内容，发现版本没对上会修改失败。重新进行去最新值，在进行查询对比。 一般需要循环来做。 通过CAS操作

悲观锁

每次去拿数据都会觉得别人会修改数据，都对数据进行上锁，别人过来只能block(阻塞)着 直到拿到锁。

自旋锁

当持有锁的线程在很短时间释放,那些等待拿到锁的不需要做内核态和用户态的切换（阻塞和运行），只需要让线程等一等，等持有锁的线程释放在立即获得。所以需要一直查询锁的状态。

优点

自旋可以减少线程阻塞和再唤醒的消耗。这些操作会导致两次的上下文切换

缺点

如果线程占用锁大量的时间，会导致大量的线程在自旋。会有大量的cpu消耗

可以设置自旋的时间或次数来控制，不能一直自旋下去，在jdk1.6 上限次数10次，1.7以后由JVM来决定

非公平锁

选择线程的方式，随机 就近原则。执行效率远超公平锁。synchronized 和Reentrantlock.lock()方法采用的非公平锁

公平锁

先提出申请的线程先获得，先到先得原则

Synchronized 同步锁

可以将任意非null的对象当作锁，他属于悲观锁，同时属于可重入锁。

锁升级 偏向锁→轻量级锁→重量级锁。 锁膨胀模式 不能降级。用户态转向内核态， 并发越高性能越差。

作用范围

作为方法时候，锁住的是对象的实例

当作用是静态方法时，锁住的是calss实例

作用域一个对象实例时，锁住的是所有以该对象为锁的代码块，它有多个队列，多个线程一起访问某个对象。监视器的时候，对象监视器会将这些线程存储在不同的容器中。

synchronized 核心组件

wait set(等待组) 哪些调用wait()方法的线程会放到这里面

Contention list （竞争队列）： 所有请求锁的线程都会放到这个队列里

Entry List(入口列表):当在竞争队列的线程有资格被候选就放到这个EntryList中

OnDeck （上位）在任意时刻 最多只有一个线程正在竞争锁资源，这个线程成为OnDeck

！OnDeck 当前释放锁的线程

synchronized实现

线程排队顺序 ContentionList（竞争队列） → EntryList（入口队列） → OnDeck状态

Owner（所有者）线程不会把锁传递给 Owner线程

ReentantLock 重进入锁

继承Lock接口，除了能完成synchronized所有工作以为，提供了诸如可响应中断锁，可轮询锁请求，定时锁等避免多线程死锁的方法。

Lock接口方法

lock()方法 执行方法时，如果锁定与空闲状态，当前线程获得的锁，反之禁用当前线程，直到当前线程获得锁。禁用后代码就不会往下走

tryLock() 试图去获取锁， 如果获取到返回true,否则返回false。 如果当前锁不可用，不会导致当前线程不可用，代码还是会继续走下去。

unlock()

执行此方法时，当前线程将释放持有的锁，锁只有持有线程才能释放

newCondition()

条件对象，获取等待通知用。只和当前锁绑定，只有获得锁的线程，才能调用await()方法，而调用后，当前线程将缩放锁。

getHoldCount()

获取当前线程执行lock的次数

getQueueLength

返回正等待获取锁的线程数量，不包含持有锁线程

getWaitQueueLength

当前condition对象 被多少个线程调用await()方法，十个调用，返回10。

hasWaiters（等待者）

查询现在有多少个线程等待，或者是condition对象，调用await()方法线程有多少个

hasQueuedThread(Thread thread)

查询指定线程是否在等待获取锁

hasQueuedThreads()

是否有线程等待此锁

ReentrantLock和synchronized

synchronized是由JVM自动解锁，ReentrantLock加锁需要手动解锁

ReentrantLock重入锁 相比syncharonized同步锁 优势 可中断，公平锁 多个锁。

Condition类和 Object类锁方法区别

Condition.wait()=obj.wait()

signal()方法=notify()方法

signalAll()方法=notifyAll()方法

重入锁可以唤醒制定线程，对象锁只能随机唤醒

tryLock和 lock和lockInterruptibly的区别

tryLock能获得锁就返回true，不能就立即返回false，tryLock(long timeout,TimeUnit unit)，可以增加时间限制，如果超过该时间段还没获得锁，返回false

lock能获得锁就返回true，不能的话一直等待获得锁

lock 和 lockInterruptibly，如果两个线程分别执行这两个方法，但此时中断这两个线程， lock不会抛出异常，而lockInterruptibly会抛出异常

Semaphroe 信号量

实例设置一个计数的信号量，当设置为1 只能是一个线程获得许可，其他竞争的线程会被阻塞，常见案例 对象池，数据库连接池。

Semaphore 与 ReentrantLock

semaphore基本完成ReentrantLock的所有工作。调用acquire(获取) 方法与release(释放)方法 来获得和释放临界资源

semaphore.acquire() 默认响应中断锁，与 ReentrantLock.lockInterruptibly()作用效果一致。在等待临界资源过程中可以被Thread.interrupt()方法中断。

semaphore 实现了可轮询的锁清秋和定时锁，tryAcquire与tryLock方法名不一样，其他方法名都一样。

释放锁也需要手动进行，必须在finally代码块中完成

ActomicInteger（原子整数）

一个提供原子操作的Integer的类，也有AtomicBoolean、AtomicInteger、AtomicLong、AtomicReference 等，他们的实现原理相同。也可以通过AtomicReference<v>将一个对象的所有操作转化为原子操作。 线程 安全 同步

可重入锁（递归锁）

当前线程在外层函数获得锁之后，在内层递归函数仍然有获得该锁的代码，但是不受影响。 ReentrantLock和synchronized 都是重入锁

ReadWriteLock 读写锁

读锁，允许同时多个线程同时读，但是不允许同时写，那就上读锁

写锁，只允许一个人写，且不允许读，就上写锁。

实现 java.util.concurrent.locks.ReadWriteLock接口

共享锁和独占锁

独占锁模式下 每次只有一个线程持有锁，是一种悲观保守的加锁策略，当某个线程在读取，其他的线程就必须等待，这样限制了不必要的并发性。读操作不会影响到数据的一致性。

共享锁运行多个线程同时获取锁， 如ReadWriteLock(读写锁) 运行一个资源被多个线程读，或允许一个线程写操作。但是读写不能一起操作。

重量级锁

阻塞同步，悲观锁。 重量级锁会导致线程从用户态切入内核态，对性能消耗非常大。

轻量级锁

为了传统重量级锁的性能消耗，通过对锁的升级，偏向锁，轻量级锁 最后升级到重量级，这个过程也叫锁膨胀。

偏向锁

为了减少线程重入（CAS）的开销。当只有一个线程 锁可以多次被获取。 但是一但有多个线程请求马上升级到CAS。

分段锁

如ConcurrentHashMap 实现就进行分区 然后进行上锁。

锁优化

减少锁持有时间 只有线程安全要求在上锁

减少锁颗粒

减少在大对象上上锁， 尽量将需要上锁的模块拆出来一个小的对象上锁。大大增加并行度，降低锁的竞争。偏向锁，轻量级锁成功概率才会提高。案例 ConcurrenHashMap.

锁分离

常见的锁分离，读写锁（ReadWriteLock） 读写只允许存在一种操作。

锁粗化

当有多个线程操作一个对象，将所有线程合并成一次请求，经常操作数据。

锁消除

在编译期间，编译器对不会发生并发的锁场景，去除掉上锁。

线程基本方法

wait 线程等待

调用这个方法的线程进入waiting状态，等待其他线程执行完通知。调用wait方法会是方法对象锁。wait方法需要在同步代码块中使用。

sleep线程休眠

让当前线程进行休眠，sleep方法不会释放当前对象锁。线程进入TIMED-WATING状态

yieId线程让步

调用yieId方法会让当前线程让出CPU执行时间片，与其他线程一起重新竞争CPU时间片。优先级高的线程大概率性竞争成功。

interrupt线程中断

interrupt方法会给线程通知一个通知信号，处于running状态的线程不会终止。 只有sleep()方法的线程 调用Interrupt() 会抛出中断异常，提前结束休眠状态。

抛出InterruptedException的方法，会清理中断标识。

中断状态在线程固有一个标识，通过标识线程可以安全终止。在线程的run方法内部可以 根据thread.isInterrupted()的值来优雅的终止线程。

join方法

调用join方法，线程进入阻塞状态，让线程等待其他线程终止，然后状态从阻塞状态转为就绪状态。

应用场景，当主线程需要到子线程处理结果，需要在子线程结束后再继续处理，所以在启动子线程后调用join()方法。

notify通知

调用了wait方法，线程就自动进入等待队列， 等待当前线程执行完后线程调用notify通知方法，随机唤醒一个等待的线程。调用notifyAll()方法，唤醒所有线程，进行竞争锁。

其他方法

1. isAlive()： 判断一个线程是否存活。 2. activeCount()： 程序中活跃的线程数。 3. enumerate()： 枚举程序中的线程。 4. currentThread()： 得到当前线程。 5. isDaemon()： 一个线程是否为守护线程。 6. setDaemon()： 设置一个线程为守护线程。(用户线程和守护线程的区别在于，是否等待主线 程依赖于主线程结束而结束) 7. setName()： 为线程设置一个名称。 8. setPriority()： 设置一个线程的优先级。 9. getPriority():：获得一个线程的优先级

线程上下文切换

时间片 就是cpu线程给每个任务分配的工的处理时间段，为时间片。

线程给每个任务执行完一段时间后，将当前任务的状态保存下来，在加载下个一个任务，继续服务下个任务，任务状态继续保存下来，这个过程就是上下文切换。

上下文：指某一个时间点cpu寄存器和程序计数器的内容

寄存器：cpu中的高速缓存

程序计数器：记录代码执行到的位置，存当前执行位置和下一个执行位置。

PCB- 切换帧 用于存储上下文切换的

上下文切换活动：挂起一个进程，将当前上下文状态存入寄存器 找到下个任务，从寄存器中恢复 根据上下文信息跳转到指定程序计数器所指向的位置，以恢复程序执行中。

引起线程上下文切换的原因：

IO阻塞 会将任务挂起 执行下个。

时间片用完，系统会调用下个任务。

当前任务没有抢占到锁，被调度器挂起。

用户代码挂起。

硬件中断

同步锁与死锁

同步锁：保证线程 同步互斥，就是指并发执行的多个线程，在同一时间内只允许一个线程访问共享数据。

死锁：多个线程同时被阻塞，全部都在等待锁资源释放。事实上已经没有线程在操作资源了。

线程池原理

将创建指定数量的线程，放入缓存起来，当有任务来了，将线程放入任务队列中进行处理。特点：线程复用；控制最大并发数；管理线程

线程复用：重写Thread类，在其start方法添加不断循环从Queue(队列)中拿Runnable类。在获取下个Runnble之前可以是阻塞的。

线程池的组成

1. 线程池管理器：用于创建并管理线程池 2. 工作线程：线程池中的线程 3. 任务接口：每个任务必须实现的接口，用于工作线程调度其运行 4. 任务队列：用于存放待处理的任务，提供一种缓冲机制

线程池配置

corePoolSize 线程核心数量

maximumPoolSize 最大线程数量

keepAliveTim空闲线程存活时间

workQueue 工作队列

threadFactory线程工厂

unit：keepAliveTime的单位。

handler 拒绝策略

handler 拒绝策略

AbortPolicy（中止策略）: 直接抛出异常，阻止系统正常运行

CallerRunsPolicy（调用者运行策略）:直接用调用者线程来处理当前被丢弃的任务。 这样会影响任务提交线程的性能有可能急剧下降。

DiscardOidestPolicy（丢弃最老策略）: 丢弃最老的任务，就是马上要执行的任务，并重新提交任务。

DiscardPolicy（丢弃策略）:这个策略丢弃无法处理的任务，不做任何处理。

以上内置拒绝策略均实现了RejectedExecutionHandler接口，若以上策略仍无法满足实际 需要，完全可以自己扩展RejectedExecutionHandler接口

java线程池工作过程

刚创建时，里面没有一个线程，任务队列也是当作参数传进去。 不会 就算队列中有任务也不会执行。

当调用execut() 线程做的判断循序

运行线程数量小于corePoolSize（核心线程数量），就创建一个线程运行任务

运行线程数量大于或等于corePoolSize,那将这个任务放入队列

队列满了，正在运行的线程处理小于maximumPoolSize(最大线程数量) ，那么创建非核心线程运行这个任务。

队列满了，当前正在运行的数量超过最大线程数量，就抛出异常RejectExecutionException

当一个线程执行完任务就取下个任务执行

当线程无事可做，在配置活跃时间后，当前运行线程大于corePoolSize，这个线程就停掉。当所有任务都完成后，最终会收缩corePoolSize的大小

阻塞队列原理

当队列的没有数据，消费端没有请求，会把线程全部挂起。

当队列数据满，生产者所有线程会挂起。

执行方法

插入

add方法 将指定元素插入队列中，插入成功返回true,没有空间就抛出。

offer() 和add方法的区别，空间不足不会报错 返回false

put（）将指定元素插入此队列中，将等待可用空间

offer(E o, long timeout, TimeUnit unit),可以设置等待时间，在制定时间内，还不能往队列中加入Blockingqueue,则返回失败。 插入队列也有时间限制？

获取

poll（time）取走BlockingQueue 里排在首位的对象，如果不能取出，则等time时间过后 取不出就返回null

poll投票(long timeout,timeUnit unit) 取队列首位的对象，在规定时间内，一旦有数据就马上取出来返回，否则超时返回null。

take() 如果队列为空，阻断进入等待状态直到有数据进入。

drainTo() 将队列的数据一次性全部取出。这样就不用进行加锁或者释放锁

java中的阻塞队列

1. ArrayBlockingQueue （数组阻塞队列）：由数组结构组成的有界阻塞队列。 公平队列，所有生产者线程和消费者线程，都要有序按照先后顺序访问队列。先阻塞生产者线程，就往队列插入数据。或先阻塞消费者线程，就先从队列中取数据。

2. LinkedBlockingQueue （链表阻塞队列） ：由链表结构组成的有界阻塞队列。先进先出，对于生产者和消费端的线程都有独立的锁，支持同时并发操作数据。提高了整个队列的性能。

3. PriorityBlockingQueue （优先级阻塞队列）：支持优先级排序的无界阻塞队列。 默认情况会对元素进行排列，可以实现compareTo()方法自定义。 相同优先级的元素无法保证顺序。

4. DelayQueue（延时队列）：使用优先级队列实现的无界阻塞队列。支持延时取队列的数据，只有在延时期到后才能取数据。

缓存设计 设置延时时效，会有一个线程轮询DelayQueue，直到取到数据，说明缓存有效期到了。

定时任务调度 DelayQueue队列 保持了当天执行任务和执行时间，一旦从队列获取到任务就开始执行。

5. SynchronousQueue（同步队列）：不存储元素的阻塞队列。每一个put 就必须要等待take，否则不能继续添加元素, 队列只做传递的的作用。

6. LinkedTransferQueue（链表传输队列）：由链表结构组成的无界阻塞队列。

transfer方法 生产者通过方法传递给消费者，如果没有消费者就会将元素放入tail节点中，并等到该元素被消费者消费了后才返回。

traTransfer方法，会先试探看有没有消费者，有就传递，没有就立即返回false。

7. LinkedBlockingDeque（链表阻塞双向队列）：由链表结构组成的双向阻塞队列，可以进行双向操作数据，比起单向多了一个入口，竞争就减少了一半。

相比其 他的阻塞队列，LinkedBlockingDeque 多了 addFirst，addLast，offerFirst，offerLast， peekFirst，peekLast 等方法，以 First 单词结尾的方法，表示插入，获取（peek）或移除双端队 列的第一个元素。以 Last 单词结尾的方法，表示插入，获取或移除双端队列的最后一个元素。另 外插入方法add等同于addLast，移除方法remove 等效于removeFirst。

CyclicBarrier、CountDownLatch、Semaphore

CountDownLatch 线程计数器， 比如说A任务，需要等待开启的2个子线程任务结束才继续执行，通过计数，等待执行。

CyclicBarrier（回环栅栏-等待至barrier状态再全部同时执行） 当一组线程请求进来，等到指定的状态，在全部执行。调用await() 当前所有线程改成barrier（围栏）状态，可以设置超时时间。

Semaphore 信号量 可以控制同时访问的个数，通过acqueire() 获取一个许可，如果没有许可就等待， 调用release()释放一个许可

1. public void acquire(): 用来获取一个许可，若无许可能够获得，则会一直等待，直到获得许 可。 2. public void acquire(int permits):获取permits个许可 3. public void release() { } :释放许可。注意，在释放许可之前，必须先获获得许可。 4. public void release(int permits) { }:释放permits个许可。 上面4个方法都会被阻塞

volatile 关键字

变量可见性，当线程去拿变量，也有其他线程在操作变量，会先进行同步最新的值

禁止重排序 java

如何在两个线程之间共享数据

共享内存关注点 可见性和有序原子性

java 内存模型 JMM 解决了可见性和有序性的问题，而锁解决了原子性和问题，理想情况下要做到同步和互斥。

同步 简单的方式使用synchronize代码块进行控制，将runnable类做完一个类的内部类，来实现这个类的数据共享。

ThreadLoadl作用 （本地线程存储）

线程内的局部在当前线程的生命周期范围，当前线程内共享。

ThreadLoadlMap 每个线程都有一个，可以将线程的对象放入其中，各管个的，线程隔离不会被其他线程影响到。通ThreadLoadl.get()方法取得自己的线程保存的类。

ThreadLoadMap是线程的一个属性。

ConcurrentHashMap(并发HashMap)

由segment数组和HashEntry数组+链表结构组成。

concurrentHashMap

segment数组 （上锁）

hashEntry数组加链表

hashEntry数组加链表

segment数组 （上锁）

hashEntry数组加链表

hashEntry数组加链表

当线程要操作hashEntry数据，需要先拿到segment的锁

java中用到的线程调度

抢占式调度 ：指每条线程执行的时间，线程的切换都有系统控制，系统控制指的是在系统某种运行机制下，可能每条线程的都分同样的的执行时间片。也有可能某个线程一直得不到执行的时间片。在这种机制下，一个线程的堵塞不会导致整个进程的堵塞。

协同式调度：接力棒式调度，当一个线程执行完了通知下一个线程进行执行。一直传递下去。 有一个弊端 当其中一个线程中断了停止 会导致整个系统瘫痪。

JVM的线程调度实现：java使用的线程调度是抢占模式，通过java中线程优先级分配时间片。优先级越高先执行，但是不等于能独占时间片。优先级越高分配的时间片越多，但是 优先级越低不会等同于分配不到时间片。

进程调度算法

先来先服务调度算法：每次调度从后背队列中取出一个或多个最先进入队列的任务，进行调入内存，分配资源，创建进程。放入就绪队列。 采用FCFS算法，从就绪队列选出一个最先进入的进程，为它分配处理机。算法比较简单，可以算的上基本上公平。

短作业(进程)优先调度算法

java基础

基本数据类型

float 浮点型

在内存占4个字节

异常分类及处理

概念：某个方法不能正常的完成业务，通过一种途径退出当前任务。

异常分类，Throwble是java语言中所有错误和异常的超类，下一层时候Error和Exception

error是指java运行时的内部错误和资源耗尽错误，如超时，内存溢出等 抛出错误是尽量告知用户，剩下做的尽力安全终止。

Exception （异常） 有两个分支，一个是运行时异常RuntimeException ,一个是CheckedException 检查异常

RuntimeException 运行时异常 空指针，转换异常。 这个错误抛出来一定是程序员写出来的错误。

CheckedException 如IO异常 sql异常

throw和throws

throws 后面跟着多个异常类，只是用来声明异常，一般定义在方法参数列表后面，这方法里面可能会发生的那些异常。

throw 后面跟着的是异常对象

两种都是消极处理异常，自己都没办法处理。将异常交给调用方进行处理。

反射机制

在运行时候可以知道任意一个类的属性和方法，动态的获取信息和动态调用对象方法。

反射应用场景

在运行时候对象有两种类型 编译时类型和运行时类型，编译时类型是声明实例对象决定，如A a=new A()。 运行时类型，是由实际赋值给对象的类型决定，如：A a=new B();

当外部系统请求进来的是Object 对象，就没办法事先知道对象信息，这个时候可以通过反射来获取对象中的内容。

反射API

Class类：反射的核心类，可以获取类的属性，方法等信息

Fieid类：表示类的成员变量 ，可以获取类的属性值

Method类

表示类的方法，它可以用来获取类的方法信息或者执行方法

Constructor（构造器)类

表示类的构造器

反射使用步骤

获得想要操作的class对象，它是反射的核心，可以通过class对象我们可以任意调用类的方法

调用class类中的方法，即就是反射的使用阶段

使用反射API来操作这些信息。

获取class对象

调用某个对象的 getClass() 方法 Person p=new Person(); Class clazz=p.getClass();

调用某个类的 class 属性来获取该类对应的 Class 对象 Class clazz=Person.class;

使用 Class类中的 forName() 静态方法 ( 最安全 / 性能最好 ) Class clazz=Class.forName("类的全路径"); (最常用)

创建对象

Person p=(Person) clazz.newInstance();

Constructor c=clazz.getDeclaredConstructor(String.class,String.class,int.class);

java注解

概念：annotation(注解) 是java 提供的一种对元程序中袁术关联信息和元数据的途径和方法，Annataion是一个接口，程序可以通过反射来获取指定程序中元素的Annotation对象，然后通过Annotation对象来获取注解的元数据信息。

4种标准注解

java5中定义了4个标准的meta-annotation类型

@Target 注解所修饰的对象范围，packages(封包)，types(类，接口，枚举，类型)，类型成员（方法，构造方法，成员变量，枚举值），方法参数和本地变量（如循环变量，catch参数）。 修饰后注解接口 可以定义在那些类型范围

@Documented（记录，文档） 描述-javadoc: 注释在公共API上，通过javadoc类进行工具文档化

@Retention（保留） 定义被保留的时间长短 用于扫描注解的生命周期。

@Inherited阐述了某个被标注的类型是被继承 如果一 个使用了@Inherited 修饰的 annotation 类型被用于一个 class，则这个 annotation 将被用于该 class的子类。

注解处理器

注解处理主要通过反射去拿到class的注解

java内部类

可以在类内部定义一个类，类的类型有：静态内部类，成员内部类，局部内部类，匿名内部类四种。

静态内部类：可以访问外部类的所有静态方法，及时是private(私有) 也可以。

成员内部类：定义在类里面非静态，就成员内部类。成员内部类不能定义静态方法和变量，应为成员内部类不是静态的。 如果里面有静态变量，优先加载静态变量。

局部内部类

定义在方法中的类，如new Thread(){}

匿名内部类（要继承一个父类或者实现一个接口、直接使用 new 来生成一个对象的引用）

java 泛型

在编译期间安全检测机制，检测类传入对象是否符合规范。如Map<String,String> 传入int 在编译期就报错。

泛型方法<E>,该方法在调用时可以接收不同类型的参数，根据传递给泛型方法的参数 类型，编译器适当地处理每一个方法调用。

泛型类<T>泛型类的声明和非泛型类的声明类似，除了在类名后面添加了类型参数声明部分。和泛型方法一 样，泛型类的类型参数声明部分也包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数， 也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。因为他们接受一个或多个参数， 这些类被称为参数化的类或参数化的类型。

类型通配符 ？

通配符一般是？代表具体的类型参数，如list<?> 在逻辑上是List<String>

JAVA序列化

将对象状态改为持久化保存到内存和硬盘中

用于远程对象传输

序列化对象以字节数组保持-静态成员不保存

继承 Serializable 接口，生成序列化 ID ，在反序列化 校验两个类的id是否一致

序列化过程 序列化 →字节对象→反序列化

Transient （短暂，过客）通过此关键字阻止变量序列化到字节文件中。如 int 型的是 0，对象型的是 null

java复制

复制可以理解为引用

直接赋值复制： A a1=a2, 这里的复制就是a2的地址引用到a1上。当a1 里的变量发生变化 a2里面的变量也跟变化

浅复制（复制引用但不复制引用的对象），当前对象的非静态字段复制到该新对象，如果字段是值类型的， 那么对该字段执行复制；如果该字段是引用类型的话，则复制引用但不复制引用的对象。

深复制 深拷贝不仅复制对象本身，而且复制对象包含的引用指向的所有对象

序列化（深clone一中实现）在Java语言里深复制一个对象，常常可以先使对象实现Serializable接口，然后把对 象（实际上只是对象的一个拷贝）写到一个流里，再从流里读出来，便可以重建对象。

ACID

原子性 atomicity

一致性 consistency

隔离性 isolation

持久性 durability

系统

TPS 每秒处理的事务

1000毫秒/一次事务处理时间=TPS数量

QPS 每秒处理的查询

1000毫秒/一次查询处理时间=QPS数量

分布式

CAP理论

consistency(一致性)

所有节点同一时间要完全一致， 在某个节点修改了，要同步到其他节点

Availability(可用性)

既服务一直可用，而且正常响应，系统能够很好的为用户服务，不出现用户操作失败或者访问超时等用户体验不好的情况。

partition Tolerance 分区容错性

分布式系统某个节点或者分区网络故障，仍然能对外提供满足一致性和可用性的服务。当一台或几台机器挂掉了，其他剩余的机器还能正常运转，对外正常提供服务，不影响用户的体验。

BASE理论

Basically Available (基本可用)

响应时间上的损失：正常情况下，处理用户请求需要0.5秒返回结果，但是系统故障了，处理用户请求的时间变成3秒

系统功能上的损失：正常情况下，用户可以使用全部功能，但是某个核心功能应该访问量剧增，导致核心功能无法使用

Soft state(软状态)

数据同步运行一定时间的延迟

Eventually consistet(最终一致性)

系统中所有的数据副本，在经过一段时间的同步，最终能够达到一个一致的状态，不要求实时。

嵌入式服务器

如入tomcat.jar,springboot内置了tomcat.jar，也不用在打war包 只需要一个JVM ,通过命令就可以启动tomcat。

面试问题

String 和 Stringbuffer ,StringBuilder区别

String 是用final修饰 不可变，每次都是新的对象

StringBuffer和StringBuilder 每次都是相同的一个对象。

StringBuffer 是线程安全的，因为方法都用synchroized修饰。

StringBuilde是线程不安全 相对于 StringBuffer 新能更快一些。

优先使用StringBuilde，在多线程的情况下使用StringBuffer

GC如何判断对象可以被回收

引用计数法：当对象引用一次就+1，引用释放时计数器减1，当计数器为0时候代表对象可以被回收了。但是这种方法会有一个问题 A引用了B B引用了A 两个对象引用计数为1 就无法被回收

可达性分析法：搜索所走过的路称为引用链，当一个对象到GC Roots 没有任何引用相连，证明这个对象是不可用的，那么虚拟机就判断可回收对象。

Final关键字

修饰的变量在声明时需要赋值或者通过构造器赋值

修饰基本数据类型 值永远不会改变

修饰对象所引用指向永远不会改变

在局部变量中修饰，可以不赋值，但是在使用前一定要赋值，不然报错。

final int[] iarr=[1,2.3] 可以更改数组里面的值，但是数组对象无法赋值。

jdk jre jvm 区别

jdk 提供给开发者使用的开发包

jer 提供给需要运行java程序的用户使用

jvm 虚拟机 解析calss文件 翻译成机器码运行

hashMap和HashTable 的区别

HashTable和HashMap实现方法基本一样，但是所有方法都加入syn代码块， 线程是安全的，但是执行效率低。

HashMap 是数组+KeyValue对象 +链表 或红黑树实现

第一次存储对象，先计算出对象的hashcode,将放入数组某个位置，hashCode同时存放

当放入的对象的hashcode已经存在，就调用equal方法比较，类型一致 覆盖原先的值，不一致 创建链表 将新旧值都放入链表。

当链表达到了一定长度后，链表就会升级红黑树存储。

当key值为null 默认放在数组下标0的位置

Arraylist和LinkedList

LinkedList

底层链表 存放的是node对象 顾名思义就是链条一样，存储是无序的， 在两个数据中间插入数据，只需要将链接断开，新值在链接上两个值即可。插入和删除 不会造成大量的数据移位，效率高。

不适合查询，因为需要逐一遍历。for 循环 通过get(i) 下标去查找 也会去遍历整个list去找这个下标

Arraylist

基于动态数组，连续存储，下标访问（随机访问）

动态数组的实现， 当list最初始的数组已经满了 会创建一个长度更长的数组，将老数据拷贝过来，将新的数据插入，然后回收老的数组。 插入速度相对慢与于linkedLIst，但是插入是进行尾部插入 效率还是能接近链表插入速度。

查询快，是通过下标查找，下标是有序的。

什么是字节码

字节码就是java类编译后的.class文件，有jvm去执行调用解释器翻译成机器码，进行程序运行。

传统编译型的语言，是编译一句在解释一句成机器码 java 先将所有代码编译好成字节码.class文件 ，jvm只需要拿到class文件就可以直接进行解释。

守护线程

主要是为非守护线程提供服务的线程，非守护线程叫用户线程，如果说GC中垃圾回收就是守护线程。守护线程 在所有用户线程关闭后就会被立即关闭。

守护线程创建的子线程也是守护线程。

它是jvm级别的线程

应用场景：为用户线程提供服务支持的情况 当成程序关闭，这个线程就立刻关闭。

session共享有什么方案

无状态服务，丢弃session , 通过用户登录信息验证完成后， 返回一个加密后的token给用户保持登录

将session放入到cookie中， 每次请求过来把cookie带过来。但是有风险。

session 同步 每台服务器之间进行相互同session,这样可以保证每台服务器有全部的session ,但是非常消耗性能，而且有网络延迟的原因会导致同步不一致。通过Tomcat 集群 实现，只要配置一下就可以了，不需要大量代码开发，上线快。问题 用户量大 会挤爆所有服务器内存

IP 绑定策略： 给每台服务器设定一个编号， 通过Nginx分发，进行哈希取模计算出在那一台服务器上。 但是当服务器宕机 session就丢失了

redis 将session放到redis中存储。每次请到服务器从redis中取。 这样 可以实现session共享，跨平台登录，服务器重启不影响

负载均衡算法

轮询法

有序 从1 2 3 ，1 2 3 编号分发请求

随机法

进行随机数取模 随机的分发到服务器上

ip哈希法

1.根据服务器数量设置对于的虚拟节点数量。

2.定义一个0到2的32次方-1的hash环。

3.对服务地址进行hash算法，得出hashcode,映射在哈希环上的某个位置上。

4.取模

加权轮询法

给服务器配置好的，增加权重，增加轮询到的次数

加权随机法

给配置好的机器编号 增加随机算法计算出来的概率，总的概率不能超出百分百

类型

通过DNS方式实现负载均衡

Nginx

跟客户端和服务端都会保持一个长连接，性能消耗比较多

使用轮询，加权轮询，ip_hsah

HAproxy

LVS

分布式生成id

雪花算法

长度为64bit的二进制

第1位0默认是0值，第2到42位为时间戳， 第43位到52位为机器码，第53到64位 为自增序号

1.生成时间戳 now左移22位

2.生成机器码 workid左移动12位

3.生成自增序列号，不需要移位，长度不能超过12位，生成最大数值为4096

判断当自增序号=4096时需要 让线程等待一毫秒 在进行生成

分布式锁

分布式锁原则

互斥性。在任意时间只有一个人持有锁

不会发生死锁，客户端上锁后 无论是程序崩溃还是中断，都要解锁

容错性，只有大部分服务正常运行，客户就能加锁解锁

解锁的人必须是上锁的人

锁不能自己失效

db

通过插入主键，插入成功获取锁 ，主键是唯一的。但是插入失败的线程 需要在代码上写循环一直重复插入。也有可能拿到锁的线程 终止了未释放锁，就变成死锁了。

zookeeper

redis锁

布隆过滤器

定义一个特定长度的字节数组，比如十万，然后对值进行3次不同hash取模，第一次100 第二次2000 第三次10000 ，对应的下标的值会改成1。如果是相同的值进行取模 结果是相同，去对应下标找值是否是1 是就存在，不是就不存在

定义一个超长的二进制数组，数组内存放的是0或1。 给这个数组添加一个数据 6。对这个6进行多次hash取模，得出多个结果下标为 5 ，10 ，21。对应的下标位的值会由0为1。

查询是否在存在数组，进行相同多次hash取模，计算出来的下标。根据下标找到对应位置，查看这些值是否全部为1，是就存在，否就是不存在。

因为hash算法 有不同值计算出来hashcode是一致的，所以出现误判，两个值计算的下标一致。

解决方案：1.增加二进制数组的长度 2.增加hash取模计算次数， 通过设置参数降低误判率来实现。

误判率设置的越低，数组长度越长，hash计算次数约多。 但是效率也会降低，建议0.01

并发容器

ContDownlatch

应用场景：使用一个主线程 创建多个子线程进行任务， 主线程调用latch.await()阻塞

int a=5； latch=new CountDownLatch(a) 底层使用AQS.state 进行计数

new Thread(B(latch)) 创建一个线程，并运行直到 执行latch.countDown()方法，对任务数量-1。 同时开5个线程去完成任务，当全部执行latch.conuntDown()方法，任务数量就变成0

任务数量变成0后就唤醒 调用latch.await()方法的主线程 继续向下走。

CyclicBarrier（循环栅栏）

应用场景：需要多个子线程阻塞等待，大家都准备好了同时执行

每个子线程都会调.await()进行等待唤醒，当线程都是等待状态就开始执行

Semaphore(信号标)

就想许可证一样，创建了10个线程，信号量只有3个，只有3个线程可以执行，否则阻塞 当某个拥有了信号标的线程执行完了，又把信号标还回去，通知其他需要的线程。

sp.acquire() 获取信号标

sp.release()释放信号标

底层使用AQS.state 进行计数

BIO ,NIO,AIO

应用场景

BIO 调用acceet() 和read（）方法 会出现两次阻塞，缺点 没有连接 没有数据读取 会一直阻塞。 后者导致影响新的连接接入。单线程进行

NIO

accept()和read() 调用完后 有数据马上返回，没数据返回空，不阻塞。 优点：解决多线程问题 缺点：当有1000个连接，只有一个请求是需要操作，需要遍历整个连接查询。每次查询连接是 用户态切换到内核态，性能消耗大。

特性 new io 非阻塞io 是指调同内核非阻塞

AIO 异步非阻塞 将读 写io操作 连接都让内核监听

selector,poll,epoll区别

select poll 两者区别是 select上线1024个连接，poll无上限，概念就是 将多个连接合并成一次传输给内核，解决NIO一个一个去调用内核查询的问题。 缺点：1.重复去给内核送相同连接 内核没有存 2.内核需要重复遍历整个连接

epoll :liunx系统下selector 优先使用这种模式 与select 和poll 处理不一样。 将 accept read write事件交给内核监听。 通过whlie(selector.select(timeout)>0) 方式监听，select方法等于wait() 等待内核检测到有时间了就通知唤醒select方法，处理事件大于0就开始处理 连接，读 ，写。 当有新的连接 epoll会将新的连接存入内核中进行监测。 读 写 也是调内核进行操作。 Nginx,redis 底层使用epoll监听连接

mmap

在内存中分配一块用户空间和内核空间共享空间，用户空间将复制到共享空间 内核直接操作发送 不需要再往内核拷贝一遍。

引用

强引用： 内存溢出都不会回收

弱引用：调完就回收

软引用：内存不足了就优先被回收，适合做缓存

虚引用：管理直接内存， 直接内存指的是jvm中有一块内存的指向内核内存。 虚引用只能用于检测对象，无法主动回收，由jvm才能回收

时间复杂度

常数阶$O(1)$

值不会因为某个值增长而增长，一直保持不变

线性阶$O(n)$

随着其他值增加 也跟着增加 你加一 我加一

平方阶$O(n^2)$

以平方增加

立方阶$O(n^3)$

对数阶$O(logn)$

线性对数阶$O(nlogn)$

指数阶$O(2^n)$

双重验证

单例对象 对象加上volatile关键字

1.判断是否为空

2.synchronize 上锁

3.判断是否为空

4.new对象 返回

volatile 关键字

禁止指令重排序

对象创建过程

1.new 对象 分配内存

2.调用构造函数，init

3.引用指向

防止2 3位置互换，导致引用的对象是半初始化状态

内存屏障

StoreStoreBarrier volatile 写操作 StoreLoadBarrier 必须做完写操作才能进行 load操作

LoadLoadBarrier volatile 读操作 LoadStroreBarrier 必须做完读操作此案进行Strore操作

可见性

当值被修改了 通知内核同步最新的值

hostpot实现

ThreadLocal

用于当前线程内共享使用，线程内的局部变量

entry对象的 key是弱引用，当引用中断了 对象就会被回收

ThreadlocalMap 存放共享对象，key为当前线程

Map允许NULL值为key值，有内存泄漏的风险，调用完后需要调用remove()方法 清除null值

把entry对象的key设置为null ,因为value对entry对象是强引用，当线程一直没被回收，Map一直存在thread中。其他请求在拿到这个线程就可以访问到这个null值的entry

底层数据结构：entry[]数组

CAS 自旋锁

CAS（Compare and swap）比较和替换 1.查询拿到当前的值， 2.在查询一下最新的值 进行比较值是否被修改 ，是 就返回到1 步骤 3.没有被修改 就进行修改 通过cas实现自旋锁机制，需要对cas方法进行循环

ABA问题

在并发场景下 线程1拿到值 a=1 ,线程2进行修改 a=2 ,线程3 修改回 a=1, 线程1在进行修改前 查询 发现还是a=1 ，然后进行修改。 其实已经被其他线程修改了很多遍了，并不是最初拿到的那个对象。

解决方案：给每次修改 上版本号 +1

AtomicInteger

底层实现通过CAS原理实现，通过unsafe类 直接通过内存操作数据

unsafe类 在jdk9版本后无法被实例 或继承，仅限jvm调用 unsafe.compareAndSwapInt()方法 进行自旋

synchronize

锁升级 偏向锁 → 轻量级锁(默认10次自旋)→重量级锁

允许重入

规范：上锁对象 必须是final 不能被修改

子主题

LongAdder

通过数组 进行 分段上锁

将所有请求分配到数组上某个空间，每个空间都独立统计数量，并上锁。

最后对所有空间计算出来的值进行sum ，得出总数

ReentrantLock 重入锁

概念 允许拿到锁的当前线程，可以再次拿到锁。 重入锁每次拿到锁会记录一次重入次数 进行加1操作

公平锁

Lock lock=new ReentrantLock(true)

设置拿锁等待时间

lock.tryLock(timeout)

设置可以被打断的锁

lock.lockinterupptibly()

解锁

lock.nulock()

创建线程队列 FIFO 先进先出

底层调用AQS进行创建队列

lock.newCondition()

condition.await() 将当前线程加入队列中 并阻塞等待

condition.signal() 唤醒队列第一个线程 condition.signalAll() 唤醒默认唤醒的也是第一个线程

AQS

模板方法

volatile int state 一般计数用 公平锁 重入锁 0是没有线程占锁，1已有线程占住锁

FIFO队列 先进先出队列

存入值 使用CAS

六个操作

抢锁

释放锁

入队

出队

阻塞

释放

公平锁

等待队列

node

waitstatus 等待状态 当前入队node，在进行park前，会先将上一个node的waitstatus改成-1，告诉他释放锁以后要unpark通知自己。 waitstatus=0 后面没有节点，不需要unpark通知，一般是队列最后一个节点

放入队列流程 1.先判断是不头node ，

2.

流程

先尝试获取锁， 判断AQS.state是否=0 是，就看一下等待队列是否有线程， 队列没有 就进行修改state=1 成功就返回true 获锁成功 AQS.state=1 当前锁被占用 把自己放入队列等待

非公平锁

1.cas 判断 AQS.state是否=0，是就进行修改为1 抢锁

2.释放锁 修改state=0

exchanger 交换器

帮助两个线程进行交换参数。

什么叫做阻塞队列的有界和无界

有界队列

LinkedBlockingQueue 链表阻塞队列 容量最大 2的31次方

ArrayBlockingQueue 数组阻塞队列 容量满了就帮您扩容 不能继续放数据

存放数量有限

无界队列

ConcurrentLinkedQueue 并发链表队列 无锁队列 底层使用CAS实现

put 操作永远都不会阻塞，空间限制来源于系统资源的限制

底层都使用 CAS 无锁编程

熔断

熔断状态

强制熔断 ALL

强制放行 ALL

部分开启 PART

熔断维度

商户号

全量商户白名单 ，所有商户都支持熔断

单商户白名单，只要在白名单中的商户就支持熔断

不在白名单 强制放行

配置表

优先级：子配置表>总配置表

总配置表

子配置表

熔断配置获取 优先级从小到大

1.本地缓存 启动服务时候将配置从库中查出缓存到Map中

2.OPS配置中心缓存，本地缓存获取不到，就尝试在ops中心获取，支持灵活配置熔断

3.redis缓存 1和2都没获取到 ，从redis缓存中获取

重启

重启模式

全部重启

清除熔断计数

清除总熔断状态

清除单批次熔断状态

清除批次已熔断日志表标识

部分重启

清除熔断计数

更新单批次熔断状态为"未熔断"

清除批次熔断日志表的标识

什么幂等性？

用户在相同参数的操作，请求了多次，最终返回的是第一次操作的结果。

什么是赋值 浅拷贝 深拷贝?

赋值是将对象在栈的地址赋值给引用对象上，不会复制数据。

浅拷贝 ：A a=new A(); A b=a; 当a里面的值发生改变 b也会发生改变。只是a对象的地址指向了b

深拷贝

clone方法重写

创建一个新的对象，同时将旧对象的值对新对象复制进去。

粒度 数据库概念

如时间的粒度 一天 一周，一个月，一个季度，一年。

行级锁，表锁 对操作的数据范围的粒度

netty发生TCP粘包，拆包

原因： 1.写入的数据大于套接字的缓冲区大小，会发生拆包问题 2.写入的数据小于套接字缓冲区大小，并多次发送数据到网络上，会发生粘包问题 3.进行MSS(最大报文长度)大小的TCP分段，当TCP报文长度-TCP头部长度>MSS的时候将发生拆包问题 4.接收方法不及时读取套接字缓冲区的数据，和新发生的数据发生了粘包问题

Netty解决方法：

1.行拆包器-LineBasedFreamDecoder \r\n 根据换行符号 将数据拆成一个数据包

2.基于分隔符的拆包器DelimiterBasedFrameDecoder 根据自定义符号，将数据拆成一个数据包

3.基于定长度的拆包器FixedLengthFrameDecoder 根据设置特定长度，将数据拆成一个数据包

4.httpServerCodec http编解码器

单例模式

饿汉式

懒汉式

枚举

静态内部类

双重校验

线程状态

新建 new

就绪 runnable

运行 run()

阻塞 block()

将线程放入同步队列

有限期等待 sleep()

无限期等待 wait()

将线程放入等待队列

策略模式

定义一个接口，由很多个类来实现这个接口方法，客户调用通过接口调用，只需要传入这个实现的类就可以，这样可以相互替换。不会影响到客户的调用。

责任链

是一种请求模式，它让多个处理器都有机会处理请求，直到成功。责任链模式把多个处理器串成链，然后让请求在链上传递。

MySQL日常怎么调优的？

查询关联表不能超过四个

常用字段查询，要创建索引

组合索引是否满足索引左前缀

什么是java序列化？

序列化就将java对象存到某地方 比如硬盘，网络。也就是对象流化

反序列化 就是把二进制数据反序列化达成对象数据

为什么要序列化？ 答案 方便传输，存储

notify与notifyAll方法为什么是在顶层Object类中?

在 Java 的线程中并没有可供任何对象使用的锁和同步器。这就是为什么这些方法是 Object 类的一部分，这样 Java 的每一个类都有用于线程间通信的基本方法。

java中有哪些实现锁的方式，有什么区别

synchronize同步代码块

重入锁 ReentrantLock

读写锁

lock接口

Condition接口

Stop-The-World jvm暂停工作状态

jvm中一种全局暂停的状态，jvm挂起

导致原因：大部分是GC垃圾回收导致 其他原因 死锁检查，dump线程 堆Dump

GC停顿，是为了更有效的找到需要会收到垃圾，并整理内存空间

危害：长期时间服务停止，没有响应 新生代gc时间段，危害小 老年代gc有时候短，但回收对象量大了会导致停止几秒或者几十秒 堆越大花的时间越长

TCP 四次挥手中 CLOSE-WAIT、TIME-WAIT 分别都发生在什么时候？作用是什么？

CLOSER-WAIT(半关闭状态) 发生在第二次挥手， 这是服务端告诉客户端，收到关闭请求，请等待。

TIME-WAIT 发生在第四次挥手，让连接继续保持连接。保证第四次挥手失败，服务端会重试第三次挥手，能接受到消息。 问题：TIME-WAIT会一直占用端口，当这个状态频繁占用，可能会导致所有端口被占满。解决方法 重用TIME-WAIT或快速回收

HashMap

面试题

为什么装填因子要去0.75

0.75 的意思就是当数组长度达到了百分之75就进行扩容。 当装填因子是1 当容量达到百分百就扩容，很容易造成hash碰撞 当装填因子是0.5 百分之五十扩容，空间利用率不高，导致频繁扩容。 0.75是比较折中的方案

扩容为什么是2的N次方？

原因1：hashMap计算下标位置，通过h & (length-1) 计算 与运算效率更高，等效h%length 取余操作，等效前提length必须是2的整数倍。 与运算速度是求余计算的十几倍。

原因2：防止哈西冲突，位置冲突 为什么要2的整数倍-1 因为 16的二进制 10000 32的二进制 100000 31的二进制 11111 进行与运算，两个同时为1，结果为1，否则为0。 得出来的结果会永远是0

数据结构

1.7jdk 键值对 数组加链表 哈希表 。 7上8下 jdk7 头插法，jdk8 将元素插入尾部

jdk1.8 数据加链表 加红黑树 链表长度达到8并且节点个数达到64 才会升级到到红黑树 红黑树退化到链表 当红黑树大小是6 就退化链表

升级红黑树 因为链表一但很大 要遍历整个链表查找，效率低下。 红黑树 及平衡 有序， 插入和查询性能的平衡点 二分查找

AVL 平衡二叉树

1.7默认长度16位 无论设置多少，一定是2的整数倍 循环capcity(容量)<<=1; 2 4 8 16

threshold(阈值) =Math.min(capcity(容量)*loadFactor(装填因子),MAXIMUM_CAPCITY(最大容量1<<30)+1) min返回两个参数最小的值

通过对hashcoed 进行二次散列后才能得到最终的存放的地址 扰动函数：增加值的的不确定性。

jdk1.8 new HashMap() 只是实例了对象，设置了装填因子。并没有创建数组

put方法， 1.对key进行hash散列算法 2. 先比较hash值， hash值一致， 3.在比较对象类型是不是一样的。 是 就替换， 否，就生成链表添加进去。 jdk1.8 put的时候创建数组

jdk1.8 hash 散列算法 高位与低位进行异或算法 1010111111000010011100100 hashcode 25位 101011111 hashcode向右位于16位 1010111111000010110111011 hashcode异或运算 异或运算 两个操作数的位中比较 相同返回0 不同返回1

jdk node数组 计算下标 通过与运算取模 h & (length-1)

jdk1.8 扩容机制

快速计算扩容后的下标： 1010111111000010011100100 hashcode 101011111 hashcode向右位于16位 1010111111000010110111011 hashcode异或运算 hashcode & (length-1) 运算后得 length=8 index=3 (length<<1) 左移1位 length=16 index=11 扩容后长度增加 11-3=8位 快速法 当前下标+当前数组长度=新数组长度 3+8=11 所以直接下标加当前容量长度，等于新数组的下标

扩容 单向链表 next记录下个元素 链表进行尾插法

Node<K,V> loHead = null, loTail = null; 低位 Node<K,V> hiHead = null, hiTail = null; 高位 与运算 hashcode &oldcap(原容量)=0 低位 否则高位 hahscode xxxx01111 原容量 xxxx10000 与运算 00000 =0 低位 hashcode xxxx11111 原容量 xxxx10000 与运算 10000 =16 高位

放值过程 第一次放值 loHead → A loTail → A 第二次 loHead →A A.next →B loTail →B 第三次 loHead →A A.next →B B.next →C loTail →C

HashMap线程不安全，因为有数据覆盖的问题: 然后A写入新的头结点之后，B也写入新的头结点，那B的写入操作就会覆盖A的写入操作造成A的写入操作丢失。

concurrentHashMap

MAX_ARRAY_SIZE = Integer.MAX_VALUE-8 ,减去的8位空间是为了存储 对象的头信息 和指针

put() 1.首次需要创建 node[] 2.进行key的hash散列算法 3.然后通过CAS进行替换值 4.统计count 5.达到阈值 进行扩容transfer()

扩容

和hashMap区别，hashMap是与运算hashcode & (length-1) ，concurrentHashMap： length=16 取值范围0-15（1111） ，4位 length=32 取值范围0-31（11111） ，5位 xxx01101 13 xxx11101 29 xxx01101 13 在长度16的时候，取后4位为下标，都是13。29发生了哈希碰撞 扩容到32， 根据hashcode的倒数第5位判断， 等于0就跟原数组的下标一致，当前值在低位。 等于1表示原数组的下标加上原数组的长度，就是当前值在新数组的下标位置，当前值在高位。

根据数组长度除于cpu核心数，如小于16 默认使用单线程处理，大于16个筒使用多线程，保证每个线程平均分配。 在扩容时会锁住整个hash表。

数据结构：Node数组+链表+红黑树

与hashMap的区别

1.put:hashMap比较完hashcode和对象后直接替换值 concurrentHashMap 是通过CAS机制进行替换值 2.扩容计算下标： hashMap用与运算的 concurrentHashMap 通过指定位的值 确定是高位还是地位 3.线程安全问题 ：hashMap有线程安全问题 数据会被覆盖 concurrentHashMap 没有线程安全问题， 通过CAS去覆盖值

加密 加签验签

RSA 公钥 私钥

MD5 生成摘要 不可逆 验证数据是否被篡改

wait 和sleep的区别？

索引在什么场景下使用，什么场景下用不到。

Java 中变量不一定要初始化？

在方法中一定要初始化局部变量,全局变量就jvm在创建对象的过程中会给默认初始化

sleep和wait()区别

sleep 不会释放对象锁

wait会释放对象锁，将线程放入等待队列。需要通过notify方法唤醒。只能在synchronized中使用

类初始化加载顺序

静态代码块>main()>构造函数>普通代码块

重写和重载的区别？

重载 方法名一致 参数列表不一致

重写 方法一致 参数列表 返回类型都一致。但只发生在子类和父类，子类重写父类的方法。

抽象类和接口的区别

抽象类的方法可以是抽象也可以是具体的 接口所有方法都是抽象的

抽象类的方法 可以是private public 默认 protected 接口所有成员都是public

调用GC的方法

System.gc()

Runtime.getRuntime().gc()

final 有什么用法

修饰类

修饰方法

修饰变量