Quartz

1. 入门

核心组件

• Scheduler：调度器
• Job：接口，特定任务需要实现该接口，并实现execute方法。
• JobDetail：对某个Job实例的封装
• Trigger：Job的触发器，即指定某个任务在什么情况下执行。
• JobBuilder：使用build方法返回一个JobDetail对象。使用了设计模式中的建造者模式。
• TriggerBuilder

TCP建立连接与释放连接

三次握手

为什么要三次，两次或者四次不行吗

TCP的三次握手是基于可用性、安全性、高效性来设计的。

首先我们假设A是请求建立连接端，即客户端；B为服务端。

讨论为什么不是两次。两次的话有以下缺点：

• 对于二次握手，服务器无法验证客户端真伪，容易造成dDOS攻击。

• 前两次连接就客户端的初始序列号达成了一致（A发送SYN包，seq=0；B收到，ACK=1，SYN=1，ack=1，seq=0），即客户端知道了自己应该发送第几个序列号给服务端，但服务端无法知道客户端是否接收到了自己发的同步包，即服务端不知道该发第几个序列号给客户端。

• 防止旧的重复链接造成混乱，比如旧的syn比新的syn先到达服务端。

Java中的自动拆箱装箱

Java中共有8种基本数据类型，每一个基本类型都有对应的类。由基本数据类型封装成类的过程叫装箱，反过来叫拆箱。比如Integer->int和int ->Integer。在Integer这个类中，类加载的时候会在内存中创建一个-128-127的Integer数组，当自动装箱时就会调用Integer.valueOf这个方法，首先会判断数值是否在这个缓存范围内，不在的话会调用new Integer方法在内存中创建对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public class Test{
    public static void main(String[] args) {
       Integer a = new Integer(9);
       Integer b = new Integer(9);
       Integer c = Integer.valueOf(9);
       Integer f = Integer.valueOf(9);
       Integer d = 9;//调用nteger.valueOf自动装箱
       int e = 9;
        // 比较地址
       System.out.println(a == b);//false,==比较引用地址，堆内存中new了两个对象地址肯定不一样
       System.out.println(a == c);//false，c是初始缓存中的对象，和new出的地址不一样
       System.out.println(c == d);// true, 会自动装箱，相当于是同一个对象
       System.out.println(c == f); // true 都是缓存中的同一对象
       //注意 e 是基本数据类型 自动拆箱，比较值
       System.out.println(c == e); // true
       System.out.println(e == a); // true
    }
}

Spring学习笔记

依赖注入

官方文档地址：https://docs.spring.io/spring-framework/docs/2.0.x/reference/beans.html#beans-constructor-injection

依赖注入（Dependency Injection）指的是某个类中使用到其他类时，我们不直接new，而是可以通过构造器或者setter方法等手段将需要的类作为参数传给使用的类，在合适的时候实现注入。如果没有容器，就需要我们手动去实现何时注入，有了Spring容器之后，容器就会自动帮我们去管理并注入这些依赖项，这就叫控制反转（Inversion of Control），即将bean的控制权交给容器。

Spring中依赖注入主要有两种方式：

• setter注入、

1
2
3
4
5
6
7
8
9
10
11
12

public class SimpleMovieLister {

    // the SimpleMovieLister has a dependency on the MovieFinder
    private MovieFinder movieFinder;

    // a setter method so that the Spring container can 'inject' a MovieFinder
    public void setMovieFinder(MovieFinder movieFinder) {
        this.movieFinder = movieFinder;
    }
    
    // business logic that actually 'uses' the injected MovieFinder is omitted...
}

• 构造器注入（不推荐，容易引发“循环依赖”，导致容器无法启动）

1
2
3
4
5
6
7
8
9
10
11
12

public class SimpleMovieLister {

    // the SimpleMovieLister has a dependency on the MovieFinder
    private MovieFinder movieFinder;

    // a constructor so that the Spring container can 'inject' a MovieFinder
    public SimpleMovieLister(MovieFinder movieFinder) {
        this.movieFinder = movieFinder;
    }
    
    // business logic that actually 'uses' the injected MovieFinder is omitted...
}

Bean的作用域和生命周期

Spring中Bean的作用域可分为：

• singleton（单例，默认）
• prototype
• request
• session
• global session

singleton时容器在启动过程中就会自动创建bean，prototype时，容器会在使用时才会去创建。

Java中的等待/唤醒机制

Java中实现等待唤醒机制共有三种方法：

• Java1.5之前，使用synchronized配合wait与notify实现等待唤醒
• Java1.5及之后，由于并发工具包的加入，我们可以用lock、lock中的Condition对象的await，signal实现等待唤醒
• LockSupport类中的静态方法park、unpark。

前两种方法的缺点：

• 都需要配合锁来使用，否则会报异常IllegalMonitorStateException
• 若先notify、后wait，则等待的线程会无限期等待

LockSupport的优点：

• 无需配合锁来使用，其底层使用了Unsafe类，通过设置凭证（permit）来实现，permit初始为0，unpark会使permit数量加一（最多为1），因此重复调用unpark的效果与调用一次相同；park方法会使permit数量减一，多次调用可能会造成阻塞。
• 若先unpark后park，则park不会阻塞线程

为什么等待通知要配合锁来使用？

如果没有锁的加入，可能会由于线程调度导致wait的线程错过notify，从而造成该线程无限期阻塞。

CountDownLatch使用案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

import java.util.concurrent.*;
public class CountDownLatchDemo {
    private static CountDownLatch startSignal = new CountDownLatch(1);
    // 用来表示裁判员需要维护的是6个运动员
    private static CountDownLatch endSignal = new CountDownLatch(6);

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newFixedThreadPool(6);
        for (int i = 0; i < 6; i++) {
            executorService.execute(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + " 运动员等待裁判员响哨！！！");
                    //等待主线程发出开始信号
                    startSignal.await();
                    System.out.println(Thread.currentThread().getName() + "正在全力冲刺");
                    
                    System.out.println(Thread.currentThread().getName() + "  到达终点");
                    endSignal.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        //为了让所有线程都启动
        Thread.sleep(5000);
        System.out.println("裁判员发号施令啦！！！");
        
        startSignal.countDown();
        //等待所有线程运行结束
        endSignal.await();
        System.out.println("所有运动员到达终点，比赛结束！");
        executorService.shutdown();
    }
}

Spring AOP编程

将重复冗余的代码抽取出来，通过动态代理的方式在程序运行时对程序进行增强和扩展。是面向函数编程的衍生，能够解耦合。

1. 相关概念

• 连接点（Joinpoint）需要被扩展和增强的方法
• 切入点（pointcut）通过切入点表达式，描述一组具有共同性的连接点，比如说对包含“remove”的方法执行后记录日志。
• 通知（Advance）对连接点进行的扩展和增强的行为，例如进行remove后会记录日志，权限验证行为、事务行为。
• 织入（Weaving）将通知连接到连接点，创建代理对象的过程
• 目标对象（Target Object）连接点被织入通知后，生成的代理类创建的代理对象，Spring AOP通过运行时代理实现。
• 切面（Aspect）一个支持对横跨多个模块功能，实现通用同意扩展的行为，例如：事务处理切面、日志记录切面等。切面通常包含切入点表达式和通知。Spring中用@Aspect申明这是一个切面类。

当一个对象不想引用或不能直接引用另一个对象时就可以通过动态代理来实现。

2. Spring中的Advice类型

• @Before前置通知，在切入点方法执行前通知
• @AfterReturning
• @AfterThrowing
• @After后置最终(finally)通知，
• @Around 环绕通知

3. 各类通知的执行顺序

Around -> Before -> proceed（目标方法执行） -> AfterReturning/AfterThrowing -> After -> Around

1
2
3
4
5
6

Around beginning...
Before Advice...
Method Running...
After Returning Advice...1
After(finally) Advice...
Around endding...1(当执行的方法抛出异常，该通知不会出现)

B树与B+树

1. B树

B树又成多路平衡查找树，B树中所有节点的孩子节点数的最大值成为B树的阶（order）。

一棵m阶B树的组成：根节点、内部节点、叶子节点

一棵m阶B树，或为空树，或为满足如下特性的m叉树：

• 树中每个节点至多有m个孩子，即最多含有m+1个key，每个节点的key以非降序存放。根节点至少有两个孩子；

• 除根节点外的所有非叶子节点至少含有ceil(m/2)个孩子

• 所有的叶子节点位于同一层，不包含孩子

m的阶数越高，树的高度越小

2. B+树

B+树的叶子节点包含了所有的key。

3. 区别与联系

• B+树的内部节点仅存储数据对应的key不存储具体的数据，而完整数据存储于叶子节点中（或者说叶子节点存储了指向完整数据的具体地址），而B树内部节点和叶子节点存储了数据的key和完整的数据，当数据量特别大可能会很占内存

• B+树的叶子节点包含了是有序的且用链表进行串联。

• B树的key值在树中是唯一的，而B+树允许重复。

• 在添加、删除节点上。B+树更加高效；在B树中搜索时，可能到不了叶子节点，即在中间节点就找到了目标，而B+树中一定会搜索到叶子节点。

MySQL为何选择B+树而不是B树作为索引？

• B+树索引非叶子节点不存储具体数据，这就使得索引文件“体积”更小，进而在索引查询时能够减少磁盘IO次数，提升查询效率。
• B+树叶子节点包含了所有的key且用链表进行有序连接，方便MySQL进行全表扫描和范围查询。

HashMap源码解读

1. HashMap的数据结构

总的来说hashmap中用到了链表、数组、红黑树这三种数据结构。不同hash值的key放在对应的数组中，当存在hash冲突时，将相同hash值的key用链表保存起来，当链表长度以及所有k-v对的个数达到阈值时，链表就会“树化”为红黑树，以提高查找效率。

2. HashMap的扩容和负载因子

区分两个概念：capacity、size

• size：指的是map中不同key-value键值对的总个数，这个字段会暴露给我们。
• capacity：指的是map中buckets的个数，即table数组的长度

当我们在初始化一个map的时候，默认负载因子为0.75f，当size达到0.75 * capacity时，就会进行扩容，map的扩容是2倍扩容。

table的长度始终都是2的指数次幂，当我们指定的初始化长度不是2的次幂时，会调用tableSizeFor方法自动找到刚好大于该长度的2的次幂的数。默认初始化时table的长度是16。

3. HashMap中的hash方法

4. HashMap的put和get方法

数据库的三范式

1. 第一范式

1NF是对属性的原子性，要求属性具有原子性，不可再分解

2. 第二范式

属性完全依赖于主键，即不存在部份依赖、

3. 第三范式

属性不依赖于其它非主属性，即不存在传递依赖