烂笔头

一 Java基础：

1.1 集合

   1 Collection:

      1.set :无序、不重复，实现类有：HashSet 、EnumSet、TreeSet、LinkedHashSet    

      2.queue：队列，实现有Deque（双端队列）、ArrayQueue、LinkedList    

      3.list：可重复，有序，实现类：Vector、Statck、ArrayList、LinkedList

总结：对于场景选择合适集合，对于set集合的Iterator遍历时不能对集合修改，否则会抛出异常；通过ListIterator可以实现双向遍历；Arrays.asList()方法返回的ArrayList是Arrays对象的内部类，因此不能做修改

   2  Map

   1.map是基于key-value键值对，实现类有：HashMap、HashTable、TreeMap、LinkedHashMap、WeakHashMap

 总计：HashMap与HashTable的区别在于：HashMap是非线程安全的，在高并发下会生成闭环，当遍历时造成CPU飙升，允许null键值对，而HashTable是线程安全的，不能允许null，其实HashTable也是保留类，并不推荐使用，若要确保线程安全可以通过如下方式：

 Collections.synchronizedXxx()、ConcurrentHashMap(分段锁)等方式；

扩展：CopyOnWriteXxx（）并发集合，具有若一致性问题

Collections是集合框架的工具类：对于集合排序、查找、同步控制，有点比较实用：生成不可变集合

emptyXxx()返回一个空集合；singletonXxx（）只有一个元素；unmodifiableXxx（）不可变集合

 

1.2 IO、NIO

1 IO流：从字节来分可分为字符流/字节流；从传输方向分为输入流/输出流

1.3 多线程

创建线程的方式：继承Thread   、 实现Runnable接口  、实现Callable接口（可以通过Future获取返回结果）

介绍一下通过Callable实现多线程：

public class ThreadC implements Callable {
    public Object call() throws Exception {
        System.out.println("线程执行");
        return "线程返回结果";
    }
 
    public static void main(String []args){
        ThreadC threadC=new ThreadC();
        FutureTask futureTask=new FutureTask(threadC);
        new Thread(futureTask).start();
        try {
            Object  obj=futureTask.get();
            System.out.println(obj);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
//输出结果
线程执行
线程返回结果
 

  线程之间的状态转换（线程的状态：创建  就绪   执行   阻塞   终止）

                    

对于线程中常用的方法有：
sleep():当前线程休眠，但对象锁保持不放
wait():，通常在和notify()一起作用在synchronized方法中，在执行完后让线程进入等待队列
notify:唤醒在此对象监听器的线程，如果有多个则随机唤醒一个
yeild():线程让步，暂停当前线程，让同级或更高优先级线程执行
join():当前线程进入阻塞，等待其他线程终止
interrupt():中断线程信号

线程同步:   
线程的特点 ：可见性  有序性   在不同步处理情况下多个线程并发执行的时候造成执行顺序随机，变量数据不可靠
 

public class ThreadD{
    public  /*synchronized */ void  print(String name){     //传入字符串，按字符输出
        for(int i=0;i<name.length();i++){
            System.out.print(name.charAt(i));
        }
    }
    public  static void main(String []args){
        final ThreadD threadD=new ThreadD();
             Thread a=new Thread(new Runnable() {                   //创建两个线程执行print()方法，预期输出lisizhangsan，不在print方法加synchronized时输出结果就会变得随机
                 public void run() {
                     threadD.print("lisi");
                 }
             });
        Thread b=new Thread(new Runnable() {
            public void run() {
                threadD.print("zhangsan");
            }
        });
             a.start();
             b.start();
    }

}

synchronized关键字的作用域有二种： 
1）是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法； 
2）是某个类的范围，synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。 

2、除了方法前用synchronized关键字，synchronized关键字还可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。用法是: synchronized(this){/*区块*/}，它的作用域是当前对象； 

3、synchronized关键字是不能继承的，也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法； 
 

线程池原理
public ThreadPoolExecutor(int corePoolSize,
                               int maximumPoolSize,
                               long keepAliveTime,
                               TimeUnit unit,
                               BlockingQueue<Runnable> workQueue,
                               RejectedExecutionHandler handler) 

corePoolSize：线程池核心线程数量

maximumPoolSize:线程池最大线程数量

keepAliverTime：当活跃线程数大于核心线程数时，空闲的多余线程最大存活时间

unit：存活时间的单位

workQueue：存放任务的队列

handler：超出线程范围和队列容量的任务的处理程序    
 

RejectedExecutionHandler：饱和策略
当队列和线程池都满了，说明线程池处于饱和状态，那么必须对新提交的任务采用一种特殊的策略来进行处理。这个策略默认配置是AbortPolicy，表示无法处理新的任务而抛出异常。JAVA提供了4中策略：

1、AbortPolicy：直接抛出异常

2、CallerRunsPolicy：只用调用所在的线程运行任务

3、DiscardOldestPolicy：丢弃队列里最近的一个任务，并执行当前任务。

4、DiscardPolicy：不处理，丢弃掉。

ExecutorService threadPool = Executors.newFixedThreadPool(3);// 创建可以容纳3个线程的线程池 

ExecutorService threadPool = Executors.newCachedThreadPool();// 线程池的大小会根据执行的任务数动态分配  

ExecutorService threadPool = Executors.newSingleThreadExecutor();// 创建单个线程的线程池，如果当前线程在执行任务时突然中断，则会创建一个新的线程替代它继续执行任务  

ScheduledExecutorService threadPool = Executors.newScheduledThreadPool(3);// 效果类似于Timer定时器
 

1.4 JVM

Java虚拟机在执行Java程序的过程中会把它所管理的内存划分成若干个不同的数据区域，这些数据区域都有各自的用途，以及创建和销毁时间，Java虚拟机所管理的内存将会包括以下几个运行时数区域

程序计数器
程序计数器是一块比较小的内存空间，它可以看做是当前线程所执行的字节码的行号指示器。在虚拟机的概念模型里，字节码解释器工作时就是通过改变这个计数器的值来选取下一条需要执行的字节码指令，分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成。

由于Java虚拟机的多线程是通过线程轮流切换并分配处理器执行时间的方式来实现的，在任何一个确定的时间，一个处理器都只会执行一条线程中的指令。因此，为了线程切换后能恢复到正确的执行位置，每条线程都需要有一个独立的程序计数器，各条线程之间计数器互不影响，独立存储，我们称这类内存区域为“线程私有”的内存。

如果线程正在执行的是一个Java方法，这个计数器记录的是正在执行的虚拟机字节码指令的地址；如果正在执行的是Native方法，这个计数器值则为空。次内存区域是唯一一个在Java虚拟机规范中没有规定任何OutOfMemoryError情况的区域。

Java虚拟机栈
与程序计数器一样，Java虚拟机栈也是线程私有的，它的生命周期与线程相同。虚拟机栈描述的是Java方法执行的内存模型，每个方法在执行的同时都会创建一个栈帧用于存储局部变量表、操作数栈、冬天链接、方法出口等信息，每一个方法从调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中入栈到出栈的过程。

经常有人把Java内存区分为堆内存和栈内存，这种分发比较粗糙，Java内存区域的划分实现上远比这个复杂。这种划分方式比较流行只能说明大多数程序员最关注的，与对象内存分配关系最密切的内存区域就是这两块。所指的“堆”在后面会讲到，所指的“栈”就是现在正在说的虚拟机栈，或者说是虚拟机栈中的局部变量表部分。

局部变量表存放了编译期可知的各种基本数据类型（boolean、byte、short、char、int、float、long、double）、对象引用（reference类型）和returnAddress类型。

其中64位长度的long和double类型的数据会占用两个局部变量空间，其余的数据类型只占用一个。局部变量表所需的内存空间在编译器以及完成分配，当进入一个方法时，这个方法所需要在栈帧中分配多大的局部变量空间是完全确定的，在方法运行期间不会改变局部变量表的大小。

在Java虚拟机规范中，对这个区域规定了两种异常状况：如果线程请求的栈深度大于虚拟机所允许的深度，将抛出StackOverflowError异常；如果虚拟机可以动态扩展，如果扩展时无法申请到足够的内存，就会抛出OutOfMemoryError异常。

本地方法栈
本地方法栈与虚拟机栈所发挥的作用是非常相似的，它们之间的区别不过是虚拟机栈位虚拟机执行Java方法服务，而本地方法栈则为虚拟机使用到的Native方法服务。在虚拟机规范中堆本地方法栈中的方法使用的语言、使用的方式与数据结构没有强制的规定，因此具体的虚拟机可以自由实现它。

Java堆
对于大多数应用来说，Java堆是Java虚拟机所管理的内存中最大的一块。Java堆是被所有线程共享的一块内存区域，在虚拟机启动时创建。次内存区域的唯一目的就是存放对象顺利，几乎所有的对象实力都在这里进行分配。这一点Java虚拟机规范中的描述是：所有的对象实例以及数据都要在堆上分配，但是随着JIT编译器的发展和逃逸分析技术逐渐成熟，栈上分配、标量替换优化技术将会导致一些微妙的变化发生，所有的对象都分配在多少也逐渐变得不是那么“绝对”了。

Java堆是垃圾收集器管理的主要区域，因此很多时候也被成为”GC堆”。从内存回收的角度来看，由于现在的收集器基本上都采用分代收集算法，所以Java堆还可以细分为：新生代和老年代；再细致一点可以分为Eden空间、From Survivor空间、To survivor空间等。从内存分配的角度来看，线程共享的Java堆中可能划分出多个线程私有的分配缓冲区，不过无论如何划分，都与存放内容无关，无论哪个区域，存储的都依然是对象实例，进一步划分的目的是为了更好地回收内存，或者更快的分配内存。在堆中没有内存完成实例分配，并且堆也无法再扩展时，将会抛出OutOfMemoryError异常。

方法区
方法区与Java堆一样，是各个线程共享的内存区域，它用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。虽然Java虚拟机规范把方法区描述为堆的一个逻辑部分，但是它却有一个别名叫做“非堆”，目的应该是与Java堆区分开来。

很多人都愿意把方法区称为永久代，本质上两者并不等价，仅仅是因为HotSpot虚拟机的设计团队选择把GC分代收集扩展至方法区，或者说使用永久代来实现方法区而已，这样HotSpot的垃圾收集器可以像管理Java堆一样管理这部分内存，能够省去专门为方法区编写内存管理代码的工作。对于其他虚拟机，不存在永久代的概念。原则上，如何实现方法区是属于虚拟机的实现细节，不受虚拟机规范束缚。
Java虚拟机规范对方法区的限制非常的宽松，除了和Java堆一样不需要连续的内存和可以选择固定大小或者可扩展意外，还可以选择不实现垃圾收集，相对而言，垃圾收集行为在这个区域是比较少出现的，但并非数据进入了方法区就如永久代的名字一样“永久”存在了。这个区域的内存回收目标主要是针对常量池的回收和堆类型的卸载，一般来说，这个区域的回收确实是必要的。当方法区无法满足内存分配的需求时，将抛出OutOfMemoryError异常。

运行常量池
运行常量池是方法区的一部分。Class文件中除了有类的版本、字段、方法、接口等描述信息外，还有一项信息是常量池，用于存放编译器生成的各个字面量和符号引用，这部门内容将在类加载后进入方法区的运行时常量池存放。

Java虚拟机堆Class文件每一部分的格式都有严格的规定，每一个字节用于存储哪种数据都必须符合规范上的要求才会被虚拟机认可、装载和执行，但对于运行时常量池，Java虚拟机规范每一个做任何细节上的要求，不同的供应商实现的虚拟机可以按照自己的要求来实现这个内存区域。不过，一般来说，除了保持Class文件中描述的符号引用外，还会把翻译出来的直接引用也存储在运行常量池中。

运行常量池相对于Class文件常量池的另外一个重要特性是具备动态性，Java语言并不要求常量一定只有在编译期才能生成，也就是并非预置入Class文件中的常量池的内容才能进入方法区运行时常量池，运行期间也可能将心的常量放入池中，这种特性被开发人员利用的比较多的就是String类的intern()方法。

常量池无法再申请到内存时会抛出OutOfMemoryError异常。

直接内存
直接内存不是虚拟机运行时数据区的一部分，也不是Java虚拟机规范中定义的内存区域。但是这部分的内存也被频繁的使用，而且也可能导致内存溢出的异常。

在JDK1.4中加入了NIO类，引入了一种基于通道的I/O方式，它可以使用Native函数库直接分配堆外内存，然后通过一个存储在Java堆中的DirectByteBuffer对象作为这块内存的引用进行操作。这样能在一些场景中显著的提高性能，因为避免了在Java堆和Native堆中来回复制数据。

显然，本机直接内存的分配不受到Java堆大小的限制，但是，既然是内存，肯定还是会受到本机总内存大小以及处理器寻址空间的限制。
 

JVM调优思路:

如果看年轻代的内存使用率处在高位，导致频繁的Minor GC，而频繁GC的效率又不高，说明对象没那么快能被回收，这时年轻代可以适当调大一点。

如果看年老代的内存使用率处在高位，导致频繁的Full GC，这样分两种情况：如果每次Full GC后年老代的内存占用率没有下来，可以怀疑是内存泄漏；如果Full GC后年老代的内存占用率下来了，说明不是内存泄漏，要考虑调大年老代。

对于G1收集器来说，可以适当调大Java堆，因为G1收集器采用了局部区域收集策略，单次垃圾收集的时间可控，可以管理较大的Java堆。

 

JVM常用参数

-Xms  初始化堆大小
-Xmx  堆最大值
-Xss  栈大小
-XX：NewSize   设置新生代大小值
-XX:NewRatio   3   :代表新生代和老年代比值是1/3
-XX:MaxPermSize   持久代大小
-XX :SurvivorRatio 8:代表 Survivor和eden比值为1：1：8
-XX：HeapDumpOnOutOfMemoryError   发生内存溢出转存堆到文件
-XX:HeapDumpPath    转存文件路径
-XX:OnOutOfMemoryError   后面跟一个脚本路径，发生异常会执行

-XX:+PrintGC 输出GC日志
-XX:+PrintGCDetails 输出GC的详细日志
-XX:+PrintGCTimeStamps 输出GC的时间戳（以基准时间的形式）
-XX:+PrintGCDateStamps 输出GC的时间戳（以日期的形式，如 2013-05-04T21:53:59.234+0800）
-XX:+PrintHeapAtGC 在进行GC的前后打印出堆的信息
-Xloggc:../logs/gc.log 日志文件的输出路径

 

ps -aux|grep java

df -lh磁盘空间
free -h 内存

jstack  打印jvm内存栈信息

jstat -gcutil 对java垃圾回收信息的统计

jinfo -flags  pid   java运行的参数

jmap -histo  打印java对象信息、实例数

 

二 框架

2.1 Spring

组件注册

容器启动和扩展

SpringMVC

2.2 Mybatis

2.3 SpringBoot

 

三 微服务分布式

3.1 SpringCloud生态体系

Hystrix服务熔断

GateWay网关路由

ZipKin服务链路追踪

Security服务鉴权

Admin服务监控

 

3.2 分布式事务

二阶段式提交

尽最大努力通知形

3.3 分布式锁

基于Mysql的乐观锁和悲观锁

基于Redis实现分布式锁

基于Zookeeper实现分布式锁

基于Redisson实现分布式锁

3.4 分布式任务调度

Quartz

   

XXL-Jobs

 

四 中间件

4.1 Redis缓存中间件

4.2 Redisson综合中间件

4.3 RabbitMQ消息中间件

4.4 ElasticSearch搜索引擎

 

五 MySQL数据库

5.1 Mysql优化处理

5.2 索引原理

5.3 锁

5.4 分表分库