java知识体系

单链表

双链表

链表

数组

树

数据结构

算法

cpu

内存

硬盘

内核态和用户态

操作系统

零拷贝

操作系统和计算机基础

单例模式

策略模式

工厂模式

观察者模式

。。。

设计模式

微服务

DDD领域建模

单体架构

zk

架构

执行 过程 

减少数据服务器需要扫描的数据盘次数，也就是减少io的此时

帮助服务器避免排序和创建临时表

将随机io变为顺序io

快速查询where条件的行

减少分组和排序的时间

在查询过程中使用优化器提高查询效率

可以在表连接查询的时候减少扫描的行数

索引优点

频繁作为查询条件的字段，并且字段的值比较散列

经常使用表连接的字段

经常需要使用范围查找的字段

经常需要排序的字段

索引用处

表记录很少

维护索引成本较高，这个需要平衡

增删改比较频繁的字段

字段的值不散列的字段，例如status  可能只有0、1两个值

不使用索引的字段

INNODB如果没有创建主键和唯一键，存储引擎会自动生成一个6bit的row_id

会涉及到回表

唯一非空索引

主键索引

唯一值，值可为空

唯一索引

没有唯一性，可为空

普通索引

查找文本中的关键词

全文索引

查询从索引的最左侧的列开始并且不跳过中间列

where  a=？ 使用索引

where b=？ 不使用索引

where b=? and a=?  使用索引  因为mysql的server有优化器，会对查询语句进行优化

where a=? and b=？and c=?  使用索引

where a=? and b>?  and c=?   a命中索引  b会使用索引  c不会使用索引

where  a=? and c=?  a命中索引  c不会使用索引

where b=3 order by a   都不使用索引

where a=3 order by c  a使用索引  c不走索引

最左匹配原则

组合索引

innodb通过B+树对主键创建索引，叶子节点会存储数据

聚簇索引

myisam的主键索引叶子节点存储的是数据在磁盘的地址，根据磁盘地址再去查询数据

普通索引的叶子节点存储的数据是主键的值，也属于非聚簇索引

非聚簇索引

索引分类

innodb的普通索引的叶子节点存储的是表的主键的值，通过普通索引的树查询到主键值以后还需要到主键索引的树查询数据

回表

在普通索引的数据中就能查询到数据不需要回表

执行计划中extra列的值为using index

例如select id from table where  a = ？

覆盖索引

执行计划的extra列using index condition  

举例1 ：创建组合索引（name，age）执行select * from table where  name  like '?%' and  age = ? ;  5.6之前现根据name把所有数据查询出来，然后在server层进行挨个字段的数据筛选    5.6之后会存储引擎根据name和age两个字段都做筛选，将符合条件的数据返回给server

索引下推  5.6开始

技术名词

like操作中，如果百分号出现在左边就会索引失效，例如 name like '%张' 或是  name like '%张%'

查询条件字段发生了类型转换，例如  phone为varchar类型，但是使用phone=13333333333 这样也可以查询到数据，但是索引是失效的

where中除了主键索引以及整形字段索引以外使用<、>、!=

使用or但是只有其中一个字段没有创建索引，例如  name = 'zhangsan'  or  age  = 20   如果name有索引但是age没有索引就会不命中索引

使用not in

使用is null  或是is not  null当查询的数量达到总表的30%以上

组合索引中的字段不使用最左侧的字段做查询条件的

EXPLIAN 的extra字段为Using filesort说明排序未使用索引

index  name   pk  id

如果select age from table order by  name  ，这时候索引是失效的，explian的type是ALL，查询的列没有索引，但是排序的列有索引，索引失效

如果是select * from table  order by  name  索引失效

select * from table  order by  id  索引失效 explian 的type为index

select name  from table order by id  索引生效

如果where中条件字段有索引而且orderby的字段也有索引，那么where中的索引是生效的，orderby中的索引失效的

如果orderby的列是多列，那么列的顺序要跟组合索引的顺序一致才可以使索引生效

排序的索引

如果数据量较多，未设置limit的话索引是失效的

例如：select * from class  left  join user on  class.id=user.classid  --如果两个表都没有创建索引则会进行全表扫描，扫描的行数为两个表做笛卡尔积（class 20行  user 30行  就是20*30）   --如果class  index  id  ；user index  classid  则user的classid索引有效，物理扫描的行数为20*1

尽量给被驱动表的关联字段创建索引

例如  select *  from class inner join  user on  class.id = user.classid  alert table class add index X(id)  --索引优化，MySQL会自己选择驱动表和被驱动表  --一张大表一张小表，大表创建索引然后放到被驱动表的位置，有利于减少物理行数扫描

innerjoin中优化器会优化选择表的顺序，一般情况吧小标放到前面可减少物理扫描行数

表关联

select * from emp e where e.eid not in (select d.eid from dept d where d.eid is not null);-- 优化子查询：确保索引不失效select * from emp e left join dept d on e.eid=d.eid where d.eid is null;

子查询

单列的索引和组合索引同时存在的时候组合索引优先生效

索引的命中和扫描的数据量还有查询的类型收到MySQL优化器等因素的影响，具体情况需要更具体的分析

索引失效和优化

哈希索引可以在O(1)的时间复杂度内查到单条记录，但是数据是无序的

由于数据的存储不是按照哈希值的顺序存储的，所以无法用于排序和分组

只能支持精确的单条查找，无法用于部分查找和范围查找

存在哈希冲突的问题，依然还是需要遍历对应的链表

哈希表

红黑树和二叉树单节点只能存一个数据，数据量过大还是会导致树的层数太多

红黑树和二叉树

所有的键值都在整颗树的节点上

查询可能在非叶子节点结束

每个节点最多有m棵子树（m代表树的阶）

所有叶子节点在同一层，每个节点有m-1个key

每个节点都会存储key和data，每个节点的存储空间大小是固定的，如果data较大，则会导致每个节点key的个数变小，从而导致树的层数增加，增加查找的io次数

b树

非叶子节点只存储key，叶子节点存储key和data

叶子节点的之间是有指针相互链接，构成了链式的循环结构，兼顾了顺序查询的性能

每个节点最多有m棵子树（m代表阶数）

所有的叶子节点在同一层，最多有m-1个key

存储数据是有序的，提高排序和分组的效率

假设索引字段类型是Bigint，8bit，每两个元素之间存的是下一个节点的地址，mysql分配的是6bit，也就是说一个索引后面配对一个节点地址，成对出现，可以算一下16K的节点可以存多少对也就是多少个索引，8b+6b=14b，16K /14b=1170个索引，叶子节点有索引有data元素，假设占1K，那一个节点就放16K/1K=16个元素，假设树高是3，所有节点都放满，能放多少数据？可以算一下，1170*1170*16=21902400，2千多万，mysql设置16K的大小，数据就可以存2千多万就已经足够了吧，既能保证一次磁盘IO不要Load太多的数据 又能保证一次load的性能，即便表的数据在几千万的数量也能保证树的高度在一个可控的范围。

b+树

索引数据结构选择

show status like 'Handler_read%';

Handler_read_first  读取索引第一个条目的次数，如果这个值很高说明全索引扫描很多

Handler_read_key 一个索引被使用的次数

Handler_read_last  读取索引最后一列的次数

Handler_read_next  通过索引读取索引字段下一字段的次数

Handler_read_prev  通过索引读取索引的上一条字段数据的次数

Handler_read_rnd  从固定位置读取行的次数，如果值比较高说明大量的结果集进行了排序或是全表扫描、关联查询没有用到合适的key

Handler_read_rnd_next  从数据节点读取下一条数据的次数

参数解释

索引监控

索引基本知识

索引

redolog

binlog

MVCC

undolog 

事务隔离

排它锁

共享锁

间隙锁

锁机制

读写分离

主从复制

故障恢复

集群

mysql

数据类型

持久化

哨兵模式

集群模式

分布式锁

redis

es

MongoDB

数据存储

构造器

子主题

不可继承

继承

合理隐藏，合理暴露

封装

多态

面向对象

自动装箱拆箱

包装类

8个基本数据类型

数据类型文章

基础数据类型

substring

StringBuffer

StringBulider

字符串常量池

String文章

String

put流程图

putval

getval

resize

key的哈希值无符号右移16位  (h = key.hashCode()) ^ (h >>> 16)

hash

(n - 1) & hash   数组长度减1与哈希值进行与计算

下标计算

tableSizeFor

公众哈

HashMap

Treemap

HashTable

linkedHashMap

map

Collections

内存连续

查找快

插入慢

扩容机制

ArrayList

查找较慢

插入删除快

LinkList

Vector

List

TreeSet

HashSet

LinkedHashSet

set

Queue

Collection

线程 安全的原理

spread

ConcurrentHashMap

ConcurrentLinkedDeque

ConcurrentLinkedQueue

CopyOnWriteArrayList

CopyOnWriteArraySet

concurrent集合

集合框架

枚举

aio

bio

netty

nio

字节流、字符流

输入流、输出流

io

实现接口的方式

生成了一个$Proxy0的类、

jdk动态代理

继承的方式

cglib动态代理

自己模拟一个动态代理？

自己模拟aop

动态代理

静态代理

反射

序列化

注解

线程等待队列和同步队列

线程的状态以及转换

调用run是同步串行进行执行的，先执行线程的代码，然后继续在往下执行

start是异步执行线程的代码，主程序继续往下执行，会有新的线程执行线程的代码

run和start的区别

减少单继承带来的编码不方便

实现runnable接口生成的线程对象可以共享成员变量资源

class MyThread2 implements   Runnable{        @Override        public  void run(){            System.out.println(\"实现runnable\");        }    }new Thread(new MyThread2()).start();

实现Runnable接口

线程独立运行

class MyThread extends  Thread{        @Override        public  void run(){            System.out.println(\"继承thread\");        }    } new MyThread().start();

继承Thread

new Thread(()->{            System.out.println(\"lambda\");        }).start();

lambda表达式

thread

runnable

Executeors.newCachedRhread

启动线程的三种方式

面试题

创建线程的三种方式

sleep

暂时让出cpu，进入同步队列，就绪状态，然后等待cpu，

yield

t1线程中调用t2的join方法，此时t1等待t2执行完后在继续执行t1

join

方法

打断后会抛出一个异常，可以catch住异常然后处理这个异常

static class MyThread2 implements   Runnable{        @Override        public  void run(){            System.out.println(\"实现runnable\");            try {                Thread.sleep(3000);            } catch (InterruptedException e) {                e.printStackTrace();                System.out.println(\"线程被打断以后将会出现在这里\");            }            System.out.println(\"继续执行\");        }    }Thread t=new Thread(new MyThread2());        t.start();        t.interrupt();运行结果：     实现runnable线程被打断以后将会出现在这里继续执行java.lang.InterruptedException: sleep interrupted at java.lang.Thread.sleep(Native Method) at com.ecarx.demo.firstdemo.controller.WWW$MyThread2.run(WWW.java:27)

打断interrupt

主内存和工作内存

内存模型

lock与volatile关系详解

lock addl

内存可见

指令重排序 happen-before

内存屏障

指令重排和内存屏障

禁止指令重排

volatile

修饰方法的时候会在字节码文件加上访问标识ACC_SYNCHRONIZED

public synchronized String tes(){        System.out.println(2222);        return \"\";    }

修饰代码块的时候，会在代码块前后加上moniterenter  和moniterexit

synchronized（对象）{}

使用

锁升级流程图

锁升级

锁定的对象补可以使用string常量还有integer、long等基础数据类型

synchronized

创建线程池

参数设置

线程池的参数

线程池的额问题

线程池

object o=new  object（）；  o属于强引用

强引用

SoftReference<Object> so = new SoftReference<>(new Object());

引用存在的情况下，垃圾回收不会被回收，但是当内存不够的时候就会被回收

软引用

WeakReference<Object> wo = new WeakReference<>(new Object());

即使有引用，当gc的时候会直接被回收

弱引用

堆外内存回收过程：1.JVM在堆内只保存堆外内存的引用，用DirectByteBuffer对象来表示2.每个DirectByteBuffer对象在初始化时，都会创建一个对应的Cleaner对象3.当DirectByteBuffer对象在某次GC中被回收，只有Cleaner对象知道堆外内存的地址4.当下一次GC执行时，Cleaner对象会触发自身clean方法清理对应的堆外内存5.Cleaner对象在下次GC时被回收

堆外内存的优点：1、保持了一个较小的堆内内存，可以减少垃圾收集对应哟的影响。2、在使用缓存时，需要消耗一些内存空间来提升速度，使用堆内内存会给虚拟机带来GC压力，使用硬盘或者分布式缓存的响应时间会比较长，这时候堆外缓存会是一个比较好的选择。3、堆内内存由JVM 管理，属于用户态，而堆外内存由操作系统管理，属于内核态。如果从堆内向磁盘些数据时，数据会被先复制到堆外内存，即内核缓冲区，然后再由操作系统写入磁盘。使用堆外内存，直接写入磁盘，提升了效率。

堆外内存的缺点：1、堆外内存的缺点就是内存难以控制。2、使用堆外内存就间接失去了使用JVM管理内存的可能性，一旦发生内存溢出时排查起来非常困难。

堆外内存泄露：1.操作系统对每个进程能管理的内存都是有限制的，对于32位系统而言，Linux最大接近4G，Windows大概2G，如果堆内实际内存1.6G，那留给堆外内存的大小也就0.4G2.堆外内存不会像新生代和老年代那样，发现空间不足就通知收集器进行回收3.它只能等待老年代满了后触发Full GC，然后JVM会“顺便地”清理堆外内存中废弃的对象4.在极端情况下，如果JVM一直没有执行Full GC的话， 堆外内存也一直得不到释放

管理堆外内存

虚引用

引用类型

threadlocal

一般具有两把以上的锁，在锁定一把的时候等待另一把锁

多巴锁合并成一把锁

解决方案

筷子做成集合

其中一个人抢的锁跟其他人不一样（混进一个左撇子）

混进一半的左撇子

哲学家就餐问题

死锁

LockSupport

wait+notify

两个线程交替打印1A2B3C4D......

交替打印

生产者消费者

多线程

Automic类

concuuect集合

唤醒条件：1：线程调用了unpark; 2:其它线程中断了线程；3：发生了不可预料的事情

park（Thread t）阻塞线程，没有其他线程唤醒无法醒来，主要是在线程内部设定了标志位

public static void unpark(Thread thread) {        if (thread != null)            UNSAFE.unpark(thread);    }

unpark（Thread t）唤醒线程，及时线程没有睡眠，也能叫醒

在Linux系统下，是用的Posix线程库pthread中的mutex（互斥量），condition（条件变量）来实现的。mutex和condition保护了一个_counter的变量，当park时，这个变量被设置为0，当unpark时，这个变量被设置为1

其实park/unpark的设计原理核心是“许可”：park是等待一个许可，unpark是为某线程提供一个许可。如果某线程A调用park，那么除非另外一个线程调用unpark(A)给A一个许可，否则线程A将阻塞在park操作上。有一点比较难理解的，是unpark操作可以再park操作之前。也就是说，先提供许可。当某线程调用park时，已经有许可了，它就消费这个许可，然后可以继续运行。这其实是必须的。考虑最简单的生产者(Producer)消费者(Consumer)模型：Consumer需要消费一个资源，于是调用park操作等待；Producer则生产资源，然后调用unpark给予Consumer使用的许可。非常有可能的一种情况是，Producer先生产，这时候Consumer可能还没有构造好（比如线程还没启动，或者还没切换到该线程）。那么等Consumer准备好要消费时，显然这时候资源已经生产好了，可以直接用，那么park操作当然可以直接运行下去。如果没有这个语义，那将非常难以操作。所以只要我们的 park/unpark 成对出现，无论执行顺序如何，都不会因此造成死锁但是这个“许可”是不能叠加的，“许可”是一次性的。比如线程B连续调用了三次unpark函数，当线程A调用park函数就使用掉这个“许可”，如果线程A再次调用park，则进入等待状态。park不需要获取某个对象的锁因为中断的时候park不会抛出InterruptedException异常，所以需要在park之后自行判断中断状态，然后做额外的处理。就像 sleep ，notify 唤醒后，jvm 会帮助我们检查一次是否有 interrupt 信号，其原理之前做过解析 https://www.cnblogs.com/niuyourou/p/12392942.html ，将检查 interrupt 信号的逻辑放在阻塞线程的逻辑之后，一旦被唤醒，首先执行检查 interrupt 信号的逻辑，检查完后退出 sleep/wait 方法，程序继续向下执行。而 park / unpark 并没有提供类似的机制，如果需要我们应自己在 park 方法后加入检查 interrupt 信号的逻辑。著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

cas

aqs

ReentrantLock

lock

juc

error和exception

java基础

springboot

springcloud

aop

ioc

spring

dubbo

mybatis

开发框架

内存区域

垃圾回收算法

垃圾回收器

字节码文件

类加载过程

<dependency>    <groupId>org.openjdk.jol</groupId>    <artifactId>jol-core</artifactId>    <version>0.9</version></dependency>

查看对象布局的工具

JAVA OBJECT  layout

对象的内存布局

jvm

网络模型

tcp

udp

http、https

网络

java