Java技术体系

8位，有符号

-128（-2^7）~127（2^7-1）

默认值0

byte a = 100，byte b = -50

16位，有符号

-32768（-2^15）~32767（2^15-1）

默认值0

short s = 1000，short r = -20000

32位，有符号

-2,147,483,648（-2^31）~2,147,483,647（2^31-1）

默认值0

int a = 100000, int b = -200000

64位，有符号

-9,223,372,036,854,775,808（-2^63）~9,223,372,036,854,775,807（2^63-1）

默认值0L（"L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写）

long a = 100000L，Long b = -200000L

补充

单精度、32位、符合IEEE 754标准的浮点数

默认值 0.0f

浮点数不能用来表示精确的值，如货币

float f1 = 234.5f

双精度、64 位、符合 IEEE 754 标准的浮点数

浮点数的默认类型为 double 类型

默认值 0.0d

double d5 = 12.9867，doubled1=7D

BigDecimal

单一的 16 位 Unicode 字符。本质也可以理解为整数类型。

\u0000（十进制等效值为 0）~\uffff（即为65535）

char 数据类型可以储存任何字符

char letter = 'A';

补充

boolean数据类型表示一位的信息

只有两个取值：true 和 false

默认值 false

boolean one = true

void 

Byte

Short

Integer

Long

Float

Double

Character

Boolean

int i =128; byte b = (byte)i;

(int)23.7 == 23; (int)-45.89f == -45

低 ------------------------------------> 高
byte,short,char—> int —> long—> float —> double

（A＆B），得到12，即0000 1100

（A | B）得到61，即 0011 1101

（A ^ B）得到49，即 0011 0001

（〜A）得到-61，即1100 0011

A << 2得到240，即 1111 0000

A >> 2得到15即 1111

A>>>2得到15即0000 1111

+=

-=

*=

/=

%=

<<=

>>=

&=

|=

^=

b=(a==1)?20:30

关键字 protected 是一个限定符，它确保 finalize() 方法不会被该类以外的代码调用。

单继承

多重继承

不同类继承同一个类

多继承（不支持，只能通过接口实现）

通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

指向当前对象自己的引用。

final 关键字声明类可以把类定义为不能继承的，即最终类；
或者用于修饰方法，该方法不能被子类重写：

构造方法不能被重写。

参数列表与被重写方法的参数列表必须完全相同。

返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类
（java5 及更早版本返回类型要一样，java7 及更高版本可以不同）。

访问权限不能比父类中被重写的方法的访问权限更低。
例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected。

父类的成员方法只能被它的子类重写。

声明为 final 的方法不能被重写。

声明为 static 的方法不能被重写，但是能够被再次声明。

子类可以重写父类所有方法，
除了声明为 private 和 final或static 的方法。

如果不能继承一个类，则不能重写该类的方法。

public abstract class Employee
{
   private String name;
   private String address;
   private int number;
   
   //其余代码
}

例

如果一个类包含抽象方法，那么该类必须是抽象类。

任何子类必须重写父类的抽象方法，或者声明自身为抽象类。

JDK 1.8 以后，接口里可以有静态方法和方法体了。

JDK 1.8 以后，接口允许包含具体实现的方法，
该方法称为"默认方法"，默认方法使用 default 关键字修饰。

JDK 1.9 以后，允许将方法定义为 private，使得某些复用的代码不会把方法暴露出去。

StackOverFlowError（堆栈溢出）

OutOfMemoryError（内存不足）

NoClassDefFoundError

IncompatibleClassChangeError

IOException

ReflectiveOperationException

NullPointException（空指针）

ArithmeticException（算术条件异常）

IndexOutOfBoundsException(索引越界)

ClassCastException(类转换异常)

ArrayStoreException(数据存储异常，操作数组时类型不一致)

IO操作的BufferOverflowException异常

IllegalArgumentException

实现Runnable接口，重写run方法，执行线程需要丢入runnable接口实现类，调用start方法
//线程开启不一定立即执行，由cpu调度执行
public class TestThread implements Runnable{
    @Override
    public void run() {
        // run()方法线程体
        for (int i = 0; i <10 ; i++) {
            System.out.println("子线程xxxxx");
        }
    }

    public static void main(String[] args) {
        //创建runnable接口的实现类对象
        TestThread testThread = new TestThread();

        //创建线程对象，通过线程对象来开启我们的线程，代理模式
        Thread thread = new Thread(testThread);

        //调用start()方法开启线程
        thread.start();

        for (int i = 0; i <100 ; i++) {
            System.out.println("主线程xxxx");
        }
    }
}

继承Thread类，重写run()方法，调用start开启线程
//线程开启不一定立即执行，由cpu调度执行
public class TestThread extends Thread{
    @Override
    public void run() {
        // run()方法线程体
        for (int i = 0; i <10 ; i++) {
            System.out.println("子线程xxxxx");
        }
    }

    public static void main(String[] args) {
        //main线程，主线程
        //创建一个线程对象
        TestThread testThread = new TestThread();
        //调用start()方法开启线程
        testThread.start();

        for (int i = 0; i <100 ; i++) {
            System.out.println("主线程xxxx");
        }
    }
}

1. 创建 Callable 接口的实现类，并实现 call() 方法，
该 call() 方法将作为线程执行体，并且有返回值。

2. 创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，
该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。

3. 使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。

4. 调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值。

真正的线程池接口。
底层逻辑实现分别实现了Runnable接口，以及Callable和Future接口，
而Future是以Thread对象的target创建线程。

常见子类

工具类、线程池的工厂类，用于创建并返回不同类型的线程池。底层依赖的是ExecutorService。

常用方法

提高响应速度（减少了创建新线程的时间）

降低资源消耗（重复利用线程池中线程，不需要每次都创建）

便于线程管理

运行状态中的线程执行 wait() 方法，
使线程进入到等待阻塞状态。

线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。

通过调用线程的 sleep() 或 join()或suspend() 发出了 I/O 请求时，线程就会进入到阻塞状态。
当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，
线程重新转入就绪状态。

程序顺序规则
（Program Order Rule）

管程锁定规则
（Monitor Lock Rule）

volatile变量规则
（Volatile Variable Rule）

线程启动规则
（Thread Start Rule）

线程中断规则
（Thread Interruption Rule）

线程终止规则
（Thread Termination Rule）

对象终结规则
（Finalizer Rule）

传递性
（Transitivity）

数据依赖

控制依赖

为了遵守as-if-serial语义，编译器和处理器不会对存在数据依赖关系的操作做重排序。
但是as-if-serial规则允许对有控制依赖关系的指令做重排序。
在单线程程序中，对存在控制依赖的操作重排序，不会改变执行结果，但是多线程下确有可能会改变结果。

重排序类型（3种）

final重排序规则

volatile重排序规则

内存重排序规则

参考资料

当线程释放锁时，JMM会把该线程对应的本地内存中的共享变量刷新到主内存中。 
线程A释放一个锁，实质上是线程A向接下来将要获取这个锁的某个线程发出了（线程A 对共享变量所做修改的）消息。

当线程获取锁时，JMM会把该线程对应的本地内存置为无效。
从而使得被监视器保护的临界区代码必须从主内存中读取共享变量。线程B获取一个锁，
实质上是线程B接收了之前某个线程发出的（在释放这个锁之前对共 享变量所做修改的）消息。

当一条线程修改了volatile变量的值，
新值对于其他线程来说是可以立即得知的。

禁止指令重排序优化。

不能保证原子性

修饰变量。简单变量或者对象等。

volatile变量原则

一文搞懂volatile的可见性原理

使用场景

Java的对象锁和类锁

使用规则

注意

加锁释放锁原理

可重入原理

原子性

可见性

有序性

Mutex Lock

synchronized锁优化（JDK1.6）

synchronized的缺点

Lock

synchronized使用场景详解

synchronized详解

深入剖析synchronized

深入分析synchronized原理和锁膨胀过程

修饰类

修饰方法

修饰参数

修饰变量

见前述重排序

volatile只能修饰变量，而synchronized可以修改变量，方法以及代码块。

volatile在多线程中不会存在阻塞问题，synchronized会存在阻塞问题。

volatile能保证数据的可见性，但不能完全保证数据的原子性，
synchronized即保证了数据的可见性也保证了原子性。

volatile解决的是变量在多个线程之间的可见性，
而sychroized解决的是多个线程之间访问资源的同步性。

问题描述

解决方案

问题描述

解决方案

问题描述

解决方案

分配、拷贝、扩充、释放堆外内存

设置、获得给定地址中的值

内存屏障

动态创建类

获取field的内存地址偏移量

检测、确保类初始化

获取对象成员属性的内存偏移量

非常规对象实例化

存储、获取指定偏移地址的变量值

返回数组元素内存大小

返回数组首元素偏移地址

返回内存页大小

返回系统指针大小

线程挂起、恢复

获取、释放资源

AtomicBoolean，AtomicInteger，AtomicLong是类似的，分别针对bool，interger，long的原子类。

AtomicIntegerArray，AtomicLongArray，AtomicReferenceArray是数组原子类。

AtomicReference，AtomicMarkedReference，AtomicStampedReference是引用相关的原子类。

AtomicLongFieldUpdater，AtomicIntegerFieldUpdater，AtomicReferenceFieldUpdater是FieldUpdater原子类。

CLH自旋锁

图示

在分布式锁的实现中，比较常见的是基于队列的方式进行不同节点中“等锁线程”的统一调度和管理。

以基于ZooKeeper的分布式锁为例

AQS是JUC提供的一个用于构建锁和同步容器的基础类。

JUC包内许多类都是基于AQS构建的，AQS解决了在实现同步容器时设计的大量细节问题。

AQS是CLH队列的一个变种，主要原理和CLH队列差不多。

AQS为锁获取、锁释放的排队和出队过程提供了一系列的模板方法。

抽象方法

（1）可中断获取锁

（2）可非阻塞获取锁

（3）可限时抢锁

通过实现类显式锁还能实现具有其他功能的锁。

ReentrantLock类实现了Lock接口。

它拥有与synchronized相同的并发性和内存语义，但是拥有了限时抢占、可中断抢占等一些高级锁特性。

ReentrantLock基于内置的抽象队列同步器（Abstract Queued Synchronized，AQS）实现，在争用激烈的场景下，能表现出表内置锁更佳的性能。

悲观锁

乐观锁

自旋锁

适应性自旋锁

公平锁

非公平锁

可重入锁

不可重入锁

共享锁

排它锁

无锁

偏向锁

轻量级锁

重量级锁

直接导入普通的 Java 类。

配合自定义的 ImportSelector 使用。

配合 ImportBeanDefinitionRegistrar 使用。

数组

存储方式

分类

排布着有规律的非零元的矩阵称为特殊矩阵
（非零元排布有规律，也可以说是零元排布有规律）。
我们可以找出规律把矩阵（N维数组）转为一维数组来存储。

稀疏矩阵含有的非零元很少且无规律。

两个栈指针重合为栈满。

共享栈的好处在于提高栈空间利用率。
可能存在一个栈快溢出，另一个栈还没怎么用的情况。

卡特兰数

定义

定义

例图

广度优先搜索

深度优先搜索

给定n个权值作为n的叶子结点，
构造一棵二叉树，若带权路径长度达到最小，
称这样的二叉树为最优二叉树，也称为哈夫曼树(Huffman tree)。

二叉排序树或者是一棵空树

或者是具有下列性质的二叉树

定义

AVL树

红黑树

参考资料

应用

B+树中分支结点有m个关键字，其叶子结点也有m个，
其关键字只是起到了一个索引的作用，
但是B树虽然也有m个子结点，但是其只拥有m-1个关键字。

B+树中的数据都存储在叶子结点上，
也就是其所有叶子结点的数据组合起来就是完整的数据，
但是B树的数据存储在每一个结点中，并不仅仅存储在叶子结点上。

B+树的分支结点仅仅存储着关键字信息和儿子的指针
（这里的指针指的是磁盘块的偏移量），
也就是说内部结点仅仅包含着索引信息。

B树在找到具体的数值以后，则结束，而B+树则需要通过索引找到叶子结点中的数据才结束，
也就是说B+树的搜索过程中走了一条从根结点到叶子结点的路径。

B+的内部结点并没有指向关键字具体信息的指针。因此其内部结点相对B树更小。
如果把所有同一内部结点的关键字存放在同一盘块中，那么盘块所能容纳的关键字数量也越多。
一次性读入内存中的需要查找的关键字也就越多。相对来说IO读写次数也就降低了。

由于非终结点并不是最终指向文件内容的结点，而只是叶子结点中关键字的索引。

所以任何关键字的查找必须走一条从根结点到叶子结点的路。所有关键字查询的路径长度相同，导致每一个数据的查询效率相当。

数据库索引采用B+树的主要原因是 B树在提高了磁盘IO性能的同时并没有解决元素遍历的效率低下的问题。

B+树只要遍历叶子节点就可以实现整棵树的遍历。

父节点的值比每一个子节点的值都要大

父节点的值比每一个子节点的值都要小

树转换二叉树

森林转换二叉树

二叉树转换森林

先根遍历

后根遍历

141. 环形链表

206. 反转链表

public class Singleton {     private static Singleton instance;     private Singleton (){}     public static Singleton getInstance() {      if (instance == null) {          instance = new Singleton();      }      return instance;     } }

当有多个线程并行调用 getInstance() 的时候，就会创建多个实例。

public class Singleton {
    private static Singleton instance;
    private Singleton (){}

    public static synchronized Singleton getInstance() {
     if (instance == null) {
         instance = new Singleton();
     }
     return instance;
    }
}

将整个 getInstance() 方法设为同步（synchronized）。

synchronized重量级锁，导致效率不高。

是对懒汉式线程不安全方式的优化，做到了线程安全。

原因

将 instance 变量声明成 volatile

代码

当 epoll_wait 检测到描述符事件发生并将此事件通知应用程序，应用程序可以不立即处理该事件。
下次调用 epoll_wait 时，会再次响应应用程序并通知此事件。

同时支持block和no-block socket

epoll默认模式

当 epoll_wait 检测到描述符事件发生并将此事件通知应用程序，应用程序必须立即处理该事件。
如果不处理，下次调用 epoll_wait 时，不会再次响应应用程序并通知此事件。

ET模式在很大程度上减少了epoll事件被重复触发的次数，因此效率要比LT模式高。

epoll工作在ET模式的时候，必须使用非阻塞套接口，
以避免由于一个文件句柄的阻塞读/阻塞写操作把处理多个文件描述符的任务饿死。

只支持no-blocksocket

一个事务的所有操作，要么全部完成，要么全部不完成。

强一致性

弱一致性

事务隔离级别

数据库能够防止由于多个并发事务交叉执行而导致数据的不一致。

指事务结束后，对数据的修改是永久的，不会回滚到之前的状态。

提交请求阶段(投票阶段)

提交执行阶段(完成阶段)

二阶段提交要求每个阶段必须保证实现自己的承诺，即如果请求阶段阶段承诺成功，那么在执行的时候就不能失败，这样保证了整体的一致性。

目前常用的是XA协议(也叫做X/Open Distributed Transaction Processing即DTP)

MySQL数据库

在提交请求阶段需要预留资源，即锁定资源，期间其他人不能操作。

数据库是独立的系统，实际上的分布式系统，业务复杂性会远高于数据库系统。

Try

Confirm

Cancel

基本可用指的是分布式系统出现了不可预知故障的时候，允许损失部分可用性。
响应时间合理延长，功能上适当做服务降级。

与主备架构的区别

缓存预热

无状态

故障转移

多地多活

限流

降级

熔断

线上压测

线下压测

冷备份

热备份

会造成大量回调函数的嵌套，代码可读性不佳。
因为没有多线程，在多核的机器上，也没办法实现并行执行。

Nginx

Node.js

1.所有Actor状态是Actor本地的，外部无法访问。

2.Actor必须只有通过消息传递进行通信。

3.一个Actor可以响应消息，推出新Actor，改变其内部状态。
或将消息发送到一个或多个其他参与者。

4.Actor可能会堵塞自己,但Actor不应该堵塞它运行的线程。

共享内存更适合单机多核的并发编程，而且共享带来的问题很多，编程也困难。
随着多核时代和分布式系统的到来，共享模型已经不太适合并发编程。

MpaReduce

单Reactor单线程

单Reactor多线程

多Reactor多进程

多Reactor多线程

Reactor 反应堆设计模式

高性能IO模型分析-Reactor模式和Proactor模式

Worker之间通信区别于Actor模式，是通过channel进行消息发布和侦听。

channel使worker之间实现松耦合。
即发送者不知道自己的消息被哪个消费者接收，
消费者也不知道自己接收的哪个发送者的消息。

Channel不需要缓冲消息，Actor需要。

Go语言

1

大量用户同时刷新界面，会对服务器的带宽造成非常大的压力；

用户在秒杀前后可以多次重复点击按钮，造成很多不必要的请求；

用户可以通过脚本进行抢购，并且抢购成功率非常高；

服务端承受高并发请求，会出现响应过慢或失败等情况；

数据库承受高并发请求，会导致连接池耗尽和响应缓慢；

如果数据库更新设计的不合理，可能会出现超卖的情况；

1

预先把网页的静态资源存放在CDN节点，用户在刷新界面时直接从CDN获取静态资源，从而降低刷新秒杀界面对服务器造成的压力。

1

用户在秒杀开始前点击按钮，造成很多无用请求；

用户在秒杀开始后多次点击按钮，造成很多重复请求；

1

URL动态化

1

使用验证码不仅可以增加脚本秒杀的难度，还可以降低请求的QPS

1

通过Nginx过滤，我们可以把100W的请求过滤为1000个请求，大大减少了服务器端的压力。

1

Redis是不支持事务的，所以可能出现扣减为负数的情况，这种情况下我们可以使用Lua脚本来保证一次扣减操作的原子性，从而保证扣减结果的正确性。

削峰填谷最好的实践就是MQ了。

使用 SETNX 指令

使用 SET 扩展指令

使用 Redisson 的分布式锁

基于 Redis 多机实现的分布式锁 Redlock