欢迎访问小站

近世代数-基础概念

2023-11-12T13:49:00.000Z

# 集合

# 概念与符号表示

集合： $A, B, C$
元素： $a, b, c$
空集： $\varnothing$
元素与集合的关系： $\in, \not\in$
集合之间的关系：
- 子集和超集： $\subseteq, \supseteq$
- 真子集和真超集： $\subsetneqq, \supsetneqq$ 或简写 $\subsetneq, \supsetneq$
- $\subset$ （子集或真子集）， $\supset$ （超集或真超集）
集合运算：
- 并集： $\cup$
- 交集： $\cap$

# 定理 1

两个集合 $A, B$ 相等的充要条件：

$A = B \Leftrightarrow A \subset B, B \subset A$

# 定义 1 - 集合的积

我们称

$A_1 \times A_2 \times ... \times A_n = \{(a_1, a_2, ..., a_n) | a_i \in A_i\}$

为 $n$ 个集合 $A_1, A_2, ..., A_n$ 的积（或笛卡尔积）。

# 定理 2

一般地，如果 $|A| = m, |B| = n$ ，那么 $|A \times B| = mn$ 。

# 习题

设 $B \subset A$ ，但 $B$ 不是 $A$ 的真子集，这种情况什么情形下出现？

当 $A = B$ 时。
设 $A \subset B$ ，则 $A \cap B =$ $A$ ， $A \cup B =$ $B$

# 映射

# 定义 1 - 映射

设 $\phi$ 是从笛卡尔积 $A_1 \times A_2 \times ... \times A_n$ 到集合 $D$ 的一个法则，如果 $A_1 \times A_2 \times ... \times A_n$ 中的每一个元素 $(a_1, a_2, ..., a_n)$ 都有 $D$ 中唯一的元素 $d$ 与之对应，那么则称 $\phi$ 是从 $A_1 \times A_2 \times ... \times A_n$ 到 $D$ 的一个映射。

# 定义 2 - 传统定义

设 $\phi$ 是从集合 $A$ 到集合 $D$ 的一个法则，如果 $A$ 中的每一个元素 $a$ 都有 $D$ 中唯一的元素 $d$ 与之对应，那么则称 $\phi$ 是 $A$ 到 $D$ 的一个映射。

定义 1 和定义 2 可以互相推导，两者是等价的。

推导：

定义 1 中，当 $n=1$ 时，推导出定义 2。
定义 2 中的集合 $A$ ，可以看成是 $A_1 \times A_2 \times ... \times A_n$ 的笛卡尔积结果，笛卡尔积的结果也是一个集合，则可推导出定义 1。

# 例子

例 1 设 $A_1 = A_2 = ... = A_n = D = \mathbb{R}$ ，则

$\phi(a_1, a_2, ..., a_n) = a_1^2 + a_2^2 + ... + a_n^2$

是 $A_1 \times A_2 \times ... \times A_n$ 到 $D$ 的映射。 $\phi$ 实际上就是一个多元函数。
例 2 设 $A_1 = \{东，西\}, A_2 = \{南\}, D = \{高, 低\}$ ，则

$\phi_1(西, 南) = 高$

不是 $A_1 \times A_2$ 到 $D$ 的映射。而

$\phi_2(西, 南) = 高, \phi_2(东, 南) = 低$

是 $A_1 \times A_2$ 到 $D$ 的映射。
例 3 设 $A_1 = D = \mathbb{R}$ ，则

$\phi(a) = 1, a \neq 1$

$\phi(1) = b, b^2 = 1$

不是 $A_1$ 到 $D$ 的映射。因为像必须要唯一，而 $\phi(1) = 1$ 或 $\phi(1) = -1$ 。
例 4 设 $A_1 = D = \mathbb{Z}_+$ ，则

$\phi(a) = a - 1$

不是 $A_1$ 到 $D$ 的映射。因为当 $a = 1$ 时，对应的像为 $0$ ，但这个像 $0$ 不在 $\mathbb{Z}_+$ 中。

# 定义 3 - 映射相等

设 $\phi_1, \phi_2$ 都是从笛卡尔积 $A_1 \times A_2 \times ... \times A_n$ 到集合 $D$ 的映射，如果对于 $A_1 \times A_2 \times ... \times A_n$ 中的每个元素 $(a_1, a_2, ..., a_n)$ ，都有

$\phi_1(a_1, a_2, ..., a_n) = \phi_2(a_1, a_2, ..., a_n)$

则称这两个映射 $\phi_1, \phi_2$ 相等。

注：两个映射相等的要求：

定义域相等；
作用效果相同。

# 例子

例 5 设 $A = D$ 都表示正整数的集合， $\phi_1: A \rightarrow D$ 定义为： $\phi_1(a) = 1, \phi_2: A \rightarrow D$ 定义为： $\phi_2(a) = a^0$ ，则 $\phi_1 = \phi_2$ .

# 习题

例 6 设 $A = \{ 1, 2, 3, ..., 100 \}$ ，找一个 $A \times A \rightarrow A$ 的映射。

# 代数运算

# 结合律、交换律

# 消去律

# 分配律

# 映射与变换

# 同态

# 同构与自同构

# 等价关系与集合的分类

队列详解和源码分析

2023-11-09T06:43:00.000Z

# 队列分类

	package java.util;

	public interface Queue<E> extends Collection<E> {
	//true - 入队成功；异常 IllegalStateException - 容量不足
	// ClassCastException、NullPointerException、IllegalArgumentException
	boolean add(E e);

	//true - 入队成功；false - 容量不足
	// ClassCastException、NullPointerException、IllegalArgumentException
	boolean offer(E e);

	// E - 队头元素出队；异常 NoSuchElementException - 队列为空
	E remove();

	// E - 队头元素出队；null - 队列为空
	E poll();

	// E - 查看队头元素；异常 NoSuchElementException - 队列为空
	E element();

	// E - 查看队头元素；null - 队列为空
	E peek();
	}

	package java.util;

	// Xxx => First 或 Last
	public interface Deque<E> extends Queue<E> {
	boolean addXxx(E e);

	boolean offerXxx(E e);

	E removeXxx();

	E pollXxx();

	//get 对应 Queue 的 element
	E getXxx();

	E peekXxx();

	//------- 新增 -------
	// 在 Queue 基础上新增的
	// 移除 [第一次 / 最后] 出现的元素。
	// ClassCastException、NullPointerException
	//false - 元素不存在；true - 移除成功
	boolean removeXxxOccurrence(Object o);
	}

类文件结构

2023-06-11T10:03:20.000Z

# 参考资料

Chapter 4. The class File Format, oracle 官方技术规范
Chapter 6. The Java Virtual Machine Instruction Set
Chapter 7. Opcode Mnemonics by Opcode

# 无关性的基石

字节码（ByteCode）

# Class 类文件的结构

查看类文件结构的命令

javap -verbose <类文件>

类型	名称	数量
u4	magic	1
u2	minor_version	1
u2	major_version	1
u2	constant_pool_count	1
cp_info	constant_pool	constant_pool_count - 1
u2	access_flags	1
u2	this_class	1
u2	super_class	1
u2	interfaces_count	1
u2	interfaces	interfaces_count
u2	fields_count	1
field_info	fields	fields_count
u2	methods_count	1
method_info	methods	methods_count
u2	attributes_count	1
attribute_info	attributes	attributes_count

# 魔数与版本号

魔数：固定 0xCAFEBABE （咖啡宝贝）

Class 文件的主版本号：

Java SE 9 = 53 [hex: 35]
Java SE 8 = 52 [hex: 34]
Java SE 7 = 51 [hex: 33]
Java SE 6.0 = 50 [hex: 32]
Java SE 5.0 = 49 [hex: 31]
JDK 1.4 = 48
JDK 1.3 = 47
JDK 1.2 = 46
JDK 1.1 = 45

# 常量池

常量池从 #1 开始表示，常量池数量会比实际数量多 1，实际数量是 $constant\_pool\_count - 1$

# 存储内容

字面量：

文本字符串
声明为 final 的常量值等

符号引用（Symbolic References）：

类和接口的全限定名（Fully Qualified Name）
字段的名称和描述符（Descriptor）
方法的名称和描述符

# 常量池格式

	cp_info {
	u1 tag;
	u1 info[];
	}

# tag 标记

类型	标志	描述
CONSTANT_Utf8	1	UTF8 字符串
CONSTANT_Integer	3	整型
CONSTANT_Float	4	单精度浮点型
CONSTANT_Long	5	长整型
CONSTANT_Double	6	双精度浮点型
CONSTANT_Class	7	类或接口
CONSTANT_String	8	字符串
CONSTANT_Fieldref	9	类的字段
CONSTANT_Methodref	10	类的方法
CONSTANT_InterfaceMethodref	11	类的接口方法
CONSTANT_NameAndType	12	字段或方法
CONSTANT_MethodHandle	15	方法句柄
CONSTANT_MethodType	16	方法类型
CONSTANT_InvokeDynamic	18	动态方法调用点

CONSTANT_MethodHandle、CONSTANT_MethodType、CONSTANT_InvokeDynamic 动态调用

# info 信息

# Utf8

	CONSTANT_Utf8_info {
	u1 tag;
	u2 length;
	u1 bytes[length];
	}

length: bytes 的个数。
bytes: 不是 null-terminated，即不是以 '\0' 结尾的字符串，没有结尾符。

# Intefer, Float

	CONSTANT_Integer_info {
	u1 tag;
	u4 bytes;
	}

	CONSTANT_Float_info {
	u1 tag;
	u4 bytes;
	}

bytes: 两者都是 big-endian 存储方式；Float 的按 IEEE 754 floating-point single format 存储。

# Long, Double

	CONSTANT_Long_info {
	u1 tag;
	u4 high_bytes;
	u4 low_bytes;
	}

	CONSTANT_Double_info {
	u1 tag;
	u4 high_bytes;
	u4 low_bytes;
	}

high_bytes, low_bytes: 两者都是 big-endian 存储方式；Double 的按 IEEE 754 floating-point double format 存储

# Class

	CONSTANT_Class_info {
	u1 tag;
	u2 name_index;
	}

name_index: 指向的常量池下标对应的内容是 CONSTANT_Utf8 类型的，类名称的字符串。

# String

	CONSTANT_String_info {
	u1 tag;
	u2 string_index;
	}

string_index: 指向的常量池下标对应的内容是 CONSTANT_Utf8 类型的，字符串。

# Fieldref, Methodref, InterfaceMethodref

	CONSTANT_Fieldref_info {
	u1 tag;
	u2 class_index;
	u2 name_and_type_index;
	}

	CONSTANT_Methodref_info {
	u1 tag;
	u2 class_index;
	u2 name_and_type_index;
	}

	CONSTANT_InterfaceMethodref_info {
	u1 tag;
	u2 class_index;
	u2 name_and_type_index;
	}

class_index: 指向的常量池下标对应的内容是 CONSTANT_Class 类型的，所属的类。
name_and_type_index: 指向的常量池下标对应的内容是 CONSTANT_NameAndType 类型的

# NameAndType

	CONSTANT_NameAndType_info {
	u1 tag;
	u2 name_index;
	u2 descriptor_index;
	}

name_index: 指向的常量池下标对应的内容是 CONSTANT_Utf8 类型的，字段或方法的名称。
descriptor_index: 指向的常量池下标对应的内容是 CONSTANT_Utf8 类型的，字段或方法描述符。

# MethodHandle

	CONSTANT_MethodHandle_info {
	u1 tag;
	u1 reference_kind;
	u2 reference_index;
	}

reference_kind: 值必须在 1～9 范围，方法句柄的类型，类型表示方法句柄的字节码行为，参考（§5.4.3.5）。
reference_index: 常量池的引用下标：
- 如果 reference_kind 的值是 1～4，则引用的常量池下标对应的内容是 CONSTANT_Fieldref 类型
- 如果 reference_kind 的值是 5～8，则引用的常量池下标对应的内容是 CONSTANT_Methodref 类型
- 如果 reference_kind 的值是 9，则引用的常量池下标对应的内容是 CONSTANT_InterfaceMethodref 类型
- 如果 reference_kind 的值是 5，6，7 或 9，则方法或接口的名称一定不是 <init> 或 <clinit>
- 如果 reference_kind 的值是 8，则方法的名称一定是 <init>

# MethodType

	CONSTANT_MethodType_info {
	u1 tag;
	u2 descriptor_index;
	}

descriptor_index: 引用的常量池下标对应的内容是 CONSTANT_Utf8 类型的，方法的描述符。

# InvokeDynamic

	CONSTANT_InvokeDynamic_info {
	u1 tag;
	u2 bootstrap_method_attr_index;
	u2 name_and_type_index;
	}

bootstrap_method_attr_index: 当前类文件中引导方法表的 bootstrap_methods [] 数组的有效索引。
name_and_type_index: 引用的常量池下标的内容是 CONSTANT_NameAndType 类型的，字段或方法的描述符。

# 访问标志

标志名称	标志值	描述
ACC_PUBLIC	0x0001	public 类型
ACC_FINAL	0x0010	final 类型
ACC_SUPER	0x0020	使用 invokespecial 新指令语义
ACC_INTERFACE	0x0200	接口
ACC_ABSTRACT	0x0400	抽象类
ACC_SYNTHETIC	0x1000	表明由编译器产生
ACC_ANNOTATION	0x2000	注解
ACC_ENUM	0x4000	枚举

invokespecial 语义在 JDK 1.0.2 发生改变，因此 JDK 1.0.2 之后编译出的类，ACC_SUPER 一定设置。

# 类 / 父类索引，接口索引集合

# 类索引和父类索引

引用常量池下标，对应的内容是 CONSTANT_Class 类型的结构，该结构中的 name_index 指向 CONSTANT_Utf8 类型的结构，从中可以获取类的全限定名字符串。

# 接口索引集合

interfaces_count
接口计数器，表示索引表的容量，如果没实现任何接口，则该项为 0，以及接下来的接口集合也为空，不再占字节。

接口也是引用常量池下标，对应的内容也是是 CONSTANT_Class 的结构。

# 字段表集合

# fields_count

字段计数器，表明字段表集合包含字段信息的数量。

# 字段表结构

	field_info {
	u2 access_flags;
	u2 name_index;
	u2 descriptor_index;
	u2 attributes_count;
	attribute_info attributes[attributes_count];
	}

# access_flags

标志名称	标志值	描述
ACC_PUBLIC	0x0001	public 修饰符
ACC_PRIVATE	0x0002	private 修饰符
ACC_PROTECTED	0x0004	protected 修饰符
ACC_STATIC	0x0008	static 修饰符
ACC_FINAL	0x0010	final 修饰符
ACC_VOLATILE	0x0040	volatile 修饰符
ACC_TRANSIENT	0x0080	transient 修饰符
ACC_SYNTHETIC	0x1000	表明是由编译器生成
ACC_ENUM	0x4000	enum 类型

# name_index

字段的名称引用，CONSTANT_Utf8 类型。

# descriptor_index

字段的全限定描述符引用，CONSTANT_Utf8 类型。

# attributes_count

属性表计数。

# attributes

属性表集合。

# 方法表集合

# methods_count

方法表集合的计数，表明方法表集合包含方法信息的数量。

# 方法表结构

	method_info {
	u2 access_flags;
	u2 name_index;
	u2 descriptor_index;
	u2 attributes_count;
	attribute_info attributes[attributes_count];
	}

# access_flags

标志名称	标志值	描述
ACC_PUBLIC	0x0001	public 修饰符
ACC_PRIVATE	0x0002	private 修饰符
ACC_PROTECTED	0x0004	protected 修饰符
ACC_STATIC	0x0008	static 修饰符
ACC_FINAL	0x0010	final 修饰符
ACC_SYNCHRONIZED	0x0020	synchronized 修饰符
ACC_BRIDGE	0x0040	表明由编译器产生的桥接方法
ACC_VARARGS	0x0080	表明方法接收不定参数
ACC_NATIVE	0x0100	native 修饰符
ACC_ABSTRACT	0x0400	abstract 修饰符
ACC_STRICT	0x0800	strictfp 修饰符
ACC_SYNTHETIC	0x1000	表明由编译器生成

strictfp 修饰符，floating-point mode is FP-strict，浮点数使用精确模式

# name_index

方法名，CONSTANT_Utf8 类型。

# descriptor_index

方法全限定名描述符，CONSTANT_Utf8 类型。

# attributes_count

属性表集合计数

# attributes

属性表集合

# 属性表集合

属性表集合会在 ClassFile, field_info, method_info, 和 Code_attribute 结构中使用。

# attributes_count

属性表集合计数

# 属性表结构

	attribute_info {
	u2 attribute_name_index;
	u4 attribute_length;
	u1 info[attribute_length];
	}

# attribute_name_index

属性名，引用常量池的下标，对应的内容是 CONSTANT_Utf8 类型的，固定值如下表。

# attribute_length

表明 info 字节的数量

# 预定义的类文件属性集合

属性	since	class file
ConstantValue	1.0.2	45.3
Code	1.0.2	45.3
StackMapTable	6	50.0
Exceptions	1.0.2	45.3
InnerClasses	1.1	45.3
EnclosingMethod	5.0	49.0
Synthetic	1.1	45.3
Signature	5.0	49.0
SourceFile	1.0.2	45.3
SourceDebugExtension	5.0	49.0
LineNumberTable	1.0.2	45.3
LocalVariableTable	1.0.2	45.3
LocalVariableTypeTable	5.0	49.0
Deprecated	1.1	45.3
RuntimeVisibleAnnotations	5.0	49.0
RuntimeInvisibleAnnotations	5.0	49.0
RuntimeVisibleParameterAnnotations	5.0	49.0
RuntimeInvisibleParameterAnnotations	5.0	49.0
AnnotationDefault	5.0	49.0
BootstrapMethods	7	51.0

# ConstantValue

位置：field_info

field_info 结构中的 access_flags 是 ACC_STATIC 才有该属性；

Sun javac 的实现是字段被 static 和 final 修饰才有该属性，其它的初始化是在 <cinit> 中赋值。

	ConstantValue_attribute {
	u2 attribute_name_index;
	u4 attribute_length;
	u2 constantvalue_index;
	}

constantvalue_index
引用常量池的下标，对应的内容的类型根据字段类型不同而不同，类型对应下面的表格。

字段类型	常量类型
long	CONSTANT_Long
float	CONSTANT_Float
double	CONSTANT_Double
int, short, char, byte, boolean	CONSTANT_Integer
String	CONSTANT_String

# Code

位置：method_info

如果方法是 native 或 abstract，则 method_info 中不会有 Code 属性；否则至少存在一个。

	Code_attribute {
	u2 attribute_name_index;
	u4 attribute_length;
	u2 max_stack;
	u2 max_locals;
	u4 code_length;
	u1 code[code_length];
	u2 exception_table_length;
	Exception_info exception_table[exception_table_length];
	u2 attributes_count;
	attribute_info attributes[attributes_count];
	}

	Exception_info {
	u2 start_pc;
	u2 end_pc;
	u2 handler_pc;
	u2 catch_type;
	}

max_stack
方法执行时的最大操作数堆栈 (Operand Stacks) 深度，虚拟机根据这个值来分配栈帧的操作数深度。

max_locals
局部变量表所需的存储空间，单位是 Slot；boolean, byte, char, short, int, float, reference 和 returnAddress 占 1 个 Slot，long 和 double 占 2 个 Slot。

code_length
字节码（code）长度。

code
字节码

exception_table_length
exception_table 的数量。

exception_table
异常处理使用异常表实现，而不是简单的跳转。

[start_pc, end_pc): 记录的是 try-catch 之间的代码行范围，在 code 数组中的下标，异常处理器（exception handler）在该范围的代码行中激活，如果该范围的代码出现了 catch_type 类型的异常，则会跳到 handler_pc 处理异常。
handler_pc: 记录的是开始处理异常的代码行，在 code 数组中的下标。
catch_type: 捕获的异常，指向常量池的下标，对应的内容类型是 CONSTANT_Class；可以指定 0，则必定跳到 handler_pc 中处理，因此，可以作为 finally 的实现。

attributes_count
attributes 中的数量。

attributes
该节是讨论属性集合的，参考

# StackMapTable

位置：Code 属性

参考

	StackMapTable_attribute {
	u2 attribute_name_index;
	u4 attribute_length;
	u2 number_of_entries;
	stack_map_frame entries[number_of_entries];
	}

number_of_entries
entries 的数量。

entries

	union stack_map_frame {
	same_frame;
	same_locals_1_stack_item_frame;
	same_locals_1_stack_item_frame_extended;
	chop_frame;
	same_frame_extended;
	append_frame;
	full_frame;
	}

# Exceptions

位置：method_info

表明该方法可能抛出哪些异常；在 Java 中，throws 关键字的实现。

	Exceptions_attribute {
	u2 attribute_name_index;
	u4 attribute_length;
	u2 number_of_exceptions;
	u2 exception_index_table[number_of_exceptions];
	}

number_of_exceptions
exception_index_table 的数量。

exception_index_table
抛出的异常，引用常量池的下标，对应的内容类型是 CONSTANT_Class。

# InnerClasses

位置：ClassFile

内部类。

	InnerClasses_attribute {
	u2 attribute_name_index;
	u4 attribute_length;
	u2 number_of_classes;
	Class_info classes[number_of_classes];
	}

	Class_info {
	u2 inner_class_info_index;
	u2 outer_class_info_index;
	u2 inner_name_index;
	u2 inner_class_access_flags;
	}

number_of_classes
classes 的数量。

classes

inner_class_info_index: 内部类；引用常量池的下标，对应的内容类型是 CONSTANT_Class。
outer_class_info_index: 宿主类，也是引用 CONSTANT_Class 类型的常量池下标，如果该类是顶级（top-level）的类或接口，以及或者是本地类（方法内部的类）、匿名类，则该项为 0。
inner_name_index: 内部类的名称，如果是匿名内部类，则该值为 0；否则引用 CONSTANT_Utf8 类型的常量池下标。

inner_class_access_flags，访问权限

标志名称	标志值	描述
ACC_PUBLIC	0x0001	public 修饰符
ACC_PRIVATE	0x0002	private 修饰符
ACC_PROTECTED	0x0004	protected 修饰符
ACC_STATIC	0x0008	static 修饰符
ACC_FINAL	0x0010	final 修饰符
ACC_INTERFACE	0x0200	interface 类
ACC_ABSTRACT	0x0400	abstract 修饰符
ACC_SYNTHETIC	0x1000	表明是由编译器生成
ACC_ANNOTATION	0x2000	annotation 类型
ACC_ENUM	0x4000	enum 类型

# EnclosingMethod

位置：ClassFile

如果是匿名类或本地类 (local class) 才会存在该属性。

	EnclosingMethod_attribute {
	u2 attribute_name_index;
	u4 attribute_length;
	u2 class_index;
	u2 method_index;
	}

class_index
该类的全限定名引用，引用常量池下标，对应的内容类型是 CONSTANT_Class

method_index
如果该类不被方法或构造器包围，则该项为 0；否则引用 CONSTANT_NameAndType 类型的常量池。

# Synthetic

位置：ClassFile, field_info, 或 method_info

ACC_SYNTHETIC 标记编译器生成的，不显示在源文件上的类、字段、方法，这些的属性集合里都会存在该属性

	Synthetic_attribute {
	u2 attribute_name_index;
	u4 attribute_length;
	}

attribute_length: 固定为 0。

# Signature

位置：ClassFile, field_info, 或 method_info

签名，Java 通过反射机制获取泛型类型；

因为采用擦除法实现伪泛型，编译后就没有信息了，Signature 是弥补该缺点。

	Signature_attribute {
	u2 attribute_name_index;
	u4 attribute_length;
	u2 signature_index;
	}

signature_index: 引用常量池下标，对应的内容类型是 CONSTANT_Utf8。

# SourceFile

位置：ClassFile，可选

javac -g:none / -g:source 关闭或开启生成源码文件名称。

	SourceFile_attribute {
	u2 attribute_name_index;
	u4 attribute_length;
	u2 sourcefile_index;
	}

sourcefile_index
源码文件名称，引用常量池的下标，对应的内容类型是 CONSTANT_Utf8。

# SourceDebugExtension

位置：ClassFile，可选

保存额外的调试信息，JSP 调试用到。

	SourceDebugExtension_attribute {
	u2 attribute_name_index;
	u4 attribute_length;
	u1 debug_extension[attribute_length];
	}

debug_extension
UTF8 字节，没有结尾符 '\0'。

# LineNumberTable

位置：Code，可选

javac -g:none / -g:lines 关闭和开启，保存代码的行号，抛异常时可以查看到对应行号。

	LineNumberTable_attribute {
	u2 attribute_name_index;
	u4 attribute_length;
	u2 line_number_table_length;
	LineNumberTable line_number_table[line_number_table_length];
	}
	LineNumberTable {
	u2 start_pc;
	u2 line_number;
	}

start_pc: 字节码行号
line_number: 源码行号

# LocalVariableTable

位置：Code，可选

javac -g:none / -g:vars 关闭和开启，保存局部变量的名称；如果没保存，则 IDE 使用 arg0、arg1 等类似的占位符。

	LocalVariableTable_attribute {
	u2 attribute_name_index;
	u4 attribute_length;
	u2 local_variable_table_length;
	LocalVariableTable local_variable_table[local_variable_table_length];
	}
	LocalVariableTable {
	u2 start_pc;
	u2 length;
	u2 name_index;
	u2 descriptor_index;
	u2 index;
	}

[start_pc, start_pc + length): 该局部变量作用域的范围。
name_index: 变量名，引用 CONSTANT_Utf8 类型的常量池。
descriptor_index: 变量的全限定名称，引用 CONSTANT_Utf8 类型的常量池。
index: 在栈帧局部变量表中 Slot 的位置，如果是 long 或 double 类型，则占用 Slot 的 index 和 index + 1。

# LocalVariableTypeTable

位置：Code，可选

泛型中使用，签名。

与 LocalVariableTable 类似，仅 signature_index 不一样。

	LocalVariableTypeTable_attribute {
	u2 attribute_name_index;
	u4 attribute_length;
	u2 local_variable_type_table_length;
	LocalVariableTypeTable local_variable_type_table[local_variable_type_table_length];
	}
	LocalVariableTypeTable {
	u2 start_pc;
	u2 length;
	u2 name_index;
	u2 signature_index;
	u2 index;
	}

signature_index: 引用 CONSTANT_Utf8 类型的常量池。

# Deprecated

位置：ClassFile, field_info, 或 method_info

@deprecated 表明一个类、字段或方法已经不推荐使用了。

	Deprecated_attribute {
	u2 attribute_name_index;
	u4 attribute_length;
	}

# RuntimeVisibleAnnotations

位置：ClassFile, field_info, 或 method_info

记录在运行时，可见的注解；通过 Java 反射 API 可以获取注解信息。

	RuntimeVisibleAnnotations_attribute {
	u2 attribute_name_index;
	u4 attribute_length;
	u2 num_annotations;
	annotation annotations[num_annotations];
	}
	annotation {
	u2 type_index;
	u2 num_element_value_pairs;
	ElementValuePair element_value_pairs[num_element_value_pairs];
	}
	ElementValuePair {
	u2 element_name_index;
	element_value value;
	}

type_index: CONSTANT_Utf8 类型的常量池的下标，注解的全限定名称。
element_value_pairs: 注解中的元素。
element_name_index: 元素名称，CONSTANT_Utf8 类型的常量池的下标。
element_value: 参考下面。

# element_value

	element_value {
	u1 tag;
	Value value;
	}
	union Value {
	u2 const_value_index;

	EnumConst enum_const_value;

	u2 class_info_index;

	annotation annotation_value;

	ArrayValue array_value;
	}
	EnumConst {
	u2 type_name_index;
	u2 const_name_index;
	}
	ArrayValue {
	u2 num_values;
	element_value values[num_values];
	}

tag
元素值对的类型

基本类型:

类型	描述	类型	描述
B	byte	C	char
D	double	F	float
I	int	J	long
S	short	Z	boolean

其它类型：

类型	描述	类型	描述
s	String	e	enum constant
c	class	@	annotation type
[	array

value
根据 tag 的不同取值，使用 value 中对应的字段。

const_value_index
如果 tag 是 B, C, D, F, I, J, S, Z, 或 s 其中一个，则 const_value_index 引用对应类型的常量池。

enum_const_value
如果 tag 是 e，则由 type_name_index 和 const_name_index 组成，记录的是枚举类型的元素。

type_name_index: 枚举的类型全限定名，引用 CONSTANT_Utf8 类型的常量池下标。
const_name_index: 枚举中定义的名称，引用 CONSTANT_Utf8 类型的常量池下标。

class_info_index
如果 tag 是 c，则记录的是 class，引用 CONSTANT_Utf8 类型的常量池下标，类的全限定名称；比如：V 代表 Void.class, Ljava/lang/Object; 代表 Object。

annotation_value
如果 tag 是 @，则记录的是注解，嵌套使用，参考这节的 element_value。

array_value
如果 tag 是 [，记录的是数组，由 num_values 和 values 组成。

values: element_value，参考该节。

# RuntimeInvisibleAnnotations

位置：ClassFile, field_info, or method_info

与 RuntimeVisibleAnnotations 类似，这个是不可见的注解，调用 java 反射 API 时，获取不到。

java 中的 Retention 注解配置。

RetentionPolicy.SOURCE: 源码可见，比如：@Override，编译之后则不存在。
RetentionPolicy.CLASS: 留在 class 文件，但忽略不处理，即记录在 RuntimeInvisibleAnnotations。
RetentionPolicy.RUNTIME: 通过反射机制可以获取，即存储在 RuntimeVisibleAnnotations。

	RuntimeInvisibleAnnotations_attribute {
	u2 attribute_name_index;
	u4 attribute_length;
	u2 num_annotations;
	annotation annotations[num_annotations];
	}

# RuntimeVisibleParameterAnnotations

位置：method_info

方法参数列表里的注解，通过反射机制可以获取到这部分注解信息。

	RuntimeVisibleParameterAnnotations_attribute {
	u2 attribute_name_index;
	u4 attribute_length;
	u1 num_parameters;
	ParameterAnnotation parameter_annotations[num_parameters];
	}
	ParameterAnnotation {
	u2 num_annotations;
	annotation annotations[num_annotations];
	}

# RuntimeInvisibleParameterAnnotations

位置：method_info

方法参数列表里的注解，不能通过反射机制可以获取到这部分注解信息。

	RuntimeInvisibleParameterAnnotations {
	u2 attribute_name_index;
	u4 attribute_length;
	u1 num_parameters;
	ParameterAnnotation parameter_annotations[num_parameters];
	}
	ParameterAnnotation {
	u2 num_annotations;
	annotation annotations[num_annotations];
	}

# AnnotationDefault

位置：method_info

注解类默认值。

	AnnotationDefault_attribute {
	u2 attribute_name_index;
	u4 attribute_length;
	element_value default_value;
	}

# BootstrapMethods

位置：ClassFile

invokedynamic 指引的引导方法限定符。

	BootstrapMethods_attribute {
	u2 attribute_name_index;
	u4 attribute_length;
	u2 num_bootstrap_methods;
	_bootstrap_method bootstrap_methods[num_bootstrap_methods];
	}

	_bootstrap_method {
	u2 bootstrap_method_ref;
	u2 num_bootstrap_arguments;
	u2 bootstrap_arguments[num_bootstrap_arguments];
	}

bootstrap_method_ref
引用 CONSTANT_MethodHandle 类型的常量池下标

bootstrap_arguments
可以引用以下类型的常量：

CONSTANT_String_info
CONSTANT_Class_info
CONSTANT_Integer_info
CONSTANT_Long_info
CONSTANT_Float_info
CONSTANT_Double_info
CONSTANT_MethodHandle_info
CONSTANT_MethodType_info

# 字节码指令

指令：操作码（Opcode）+ 0 至多个操作数（Operands）

Opcode 表

# 加载和存储指令

# 将局部变量加载到操作栈

对应类型：

（i, l, f, d, a）->（int, long, float, double, reference）
（b, c, s）->（byte / boolean, char, short）

指令： iload，lload，fload，dload，aload
格式： <指令> <index>
操作数栈： ... --> ..., value
变化：

将本地变量数组下标 index 下的 value 压入操作数栈；
如果是 l 和 d 类型的指令，则 index 和 index + 1 都入栈，因为占 2 个 Slot。

描述： index 是本地变量数组 (local variable array) 的下标。
注意： aload 指令的 value 是 objectref，且不能用于 returnAddress 类型的加载；相反，存储指令 astore 可以存储该类型。

指令： iload_n，lload_n，fload_n，dload_n，aload_n
格式： <指令>
操作数栈： ... --> ..., value
变化：

将本地变量数组下标 n 下的 value 压入操作数栈。
如果是 l 和 d 类型的指令，则 n 和 n + 1 都入栈，因为占 2 个 Slot。

描述： 代表一组指令，n 可取的值为（0, 1, 2, 3）；n 为 index，用 n 代替 index，隐式指定 index，不带操作数；例如 iload_0 和 iload 0 语义一样。
注意： aload_n 指令的 value 是 objectref，且不能用于 returnAddress 类型的加载；相反，存储指令 astore_n 可以存储该类型。

指令：

iaload，laload，faload，daload，aaload, baload，caload，saload

格式： <指令>
操作数栈： ..., arrayref, index --> ..., value
变化： 将操作数栈中的 arrayref 和 index 推出栈，然后将 arrayref 中 index 下的 value 压入操作数栈。
描述： 加载对应类型的数组下的值。
运行时异常：

arrayref 是 null，抛 NullPointerException 异常；
index 越界，抛 ArrayIndexOutOfBoundsException 异常。

# 2. 将一个数从操作数栈存储到局部变量表

指令： istore，lstore，fstore，dstore，astore
格式： <指令> <index>
操作数栈： ..., value --> ...
变化：

将操作数栈的 value 推出栈，然后设置本地变量数组下标 index 下的 value；
如果是 l 和 d 类型的指令，则设置 index 和 index+1 下标的值，因为占 2 个 Slot。

注意： astore 指令的 value 是 objectref，且可以存储 returnAddress 类型。

指令： istore_n，lstore_n，fstore_n，dstore_n，astore_n
格式： <指令>
操作数栈： ..., value --> ...
变化：

将操作数栈的 value 推出栈，然后设置本地变量数组下标 n 下的 value。
如果是 l 和 d 类型，则设置 n 和 n+1 下标的值，因为占 2 个 Slot。

描述： 代表一组指令，n 可取的值为（0, 1, 2, 3）；n 为 index，用 n 代替 index，隐式指定 index，不带操作数；例如 istore_0 和 istore 0 语义一样。
注意： astore_n 指令的 value 是 objectref，且可以存储 returnAddress 类型。

指令：

iastore，lastore，fastore，dastore，aastore, bastore，castore，sastore

格式： <指令>
操作数栈： ..., arrayref, index, value --> ...
变化： 将操作数栈中的 arrayref, index 和 value 推出栈，然后设置 arrayref 中 index 下的 value。
描述： 存储到指定位置，对应类型的数组。
运行时异常：

arrayref 是 null，抛 NullPointerException 异常；
index 越界，抛 ArrayIndexOutOfBoundsException 异常；
如果是 aastore 指令，源类型与目标类型不兼容（不同类型，不是子类等），抛 ArrayStoreException 异常。

# 扩展局部变量表的访问索引的指令 wide

指令： wide
格式：

wide <opcode> indexbyte1 indexbyte2
wide iinc indexbyte1 indexbyte2 constbyte1 constbyte2

描述：

opcode 是其中一个，iload, fload, aload, lload, dload, istore, fstore, astore, lstore, dstore, ret。
iinc 是另外一个指令，格式不一样。

# 将一个常量加载到操作数栈中

指令： aconst_null
格式： aconst_null
操作数栈： ... --> ..., null
描述： Push null.

指令： bipush
格式： bipush byte
操作数栈： ... --> ..., value
描述： 将 byte 常量压入操作数栈；byte 会符合扩展成 int。

指令： sipush
格式： sipush byte1 byte2
操作数栈： ... --> ..., value
描述： 将 byte1 和 byte2 常量组合成 short（(byte1 << 8) | byte2）一起压入操作数栈；short 会符合扩展成 int。

指令： ldc
格式： ldc index
操作数栈： ... --> ..., value
描述：
将 item 从运行时常量池中加载到操作数栈：

int 或 float 类型常量，按对应类型加载数值到操作数栈；
字符串字面量的引用（reference to a string literal），将 reference 实例压入到栈中；
类的符号引用（symbolic reference to a class），将类的实例压入到栈中；
method type，method handle：java.lang.invoke.MethodType，java.lang.invoke.MethodHandle 对应的实例压入栈中。

异常： 解析类的符号引用（symbolic reference to a class）、method type、method handle 时，可能会抛出对应解析异常。

指令： ldc_w
格式： ldc_w indexbyte1 indexbyte2
操作数栈： ... --> ..., value
描述： 扩展下标（(indexbyte1 << 8) | indexbyte2），和 ldc 描述一致。
异常： 和 ldc 描述一致

指令： ldc2_w
格式： ldc2_w indexbyte1 indexbyte2
操作数栈： ... --> ..., value
描述： 扩展下标（(indexbyte1 << 8) | indexbyte2），将 long 和 double 类型从运行时常量池中加载到操作数栈中。

指令： iconst_<i>
格式： iconst_<i>
操作数栈： ... --> ..., <i>
描述： <i> 可取（m1, 0, 1, 2, 3, 4, 5），m1 即 - 1；将 int 类型常量 - 1 ～ 5 其中一个压入到操作数栈中。

指令： lconst_<l>
格式： lconst_<l>
操作数栈： ... --> ..., <l>
描述： <l> 可取（0，1），将 long 类型常量 0 或 1 压入到操作数栈中。

指令： fconst_<f>
格式： fconst_<f>
操作数栈： ... --> ..., <f>
描述： <f> 可取（0，1，2），将 float 类型常量 0.0，1.0 或 2.0 压入到操作数栈中。

指令： dconst_<d>
格式： dconst_<d>
操作数栈： ... --> ..., <d>
描述： <d> 可取（0，1），将 double 类型常量 0.0 或 1.0 压入到操作数栈中。

# 运算指令

# 加法指令

指令： iadd，ladd，fadd，dadd
格式： <指令>;
操作数栈： ..., value1, value2 --> ..., result
描述： 将操作数栈中的两个值弹出栈然后相加，最后将结果压入栈中。int 和 long 的结果使用补码格式存储。

# 减法指令

指令： isub，lsub，fsub，dsub
格式： <指令>
操作数栈： ..., value1, value2 --> ..., result
描述： 将操作数栈中的两个值弹出栈然后相减，最后将结果压入栈中。int 和 long 的结果使用补码格式存储。

# 乘法指令

指令： imul，lmul，fmul，dmul
格式： <指令>
操作数栈： ..., value1, value2 --> ..., result
描述： 将操作数栈中的两个值弹出栈然后相乘，最后将结果压入栈中。int 和 long 的结果使用补码格式存储。

# 除法指令

指令： idiv，ldiv，fdiv，ddiv
格式： <指令>
操作数栈： ..., value1, value2 --> ..., result
描述： 将操作数栈中的两个值弹出栈然后相除，最后将结果压入栈中。
异常： int 或 long 类型导致 ArithmeticException（除 0 导致的异常）。

# 求余指令

指令： irem，lrem，frem，drem
格式： <指令>
操作数栈： ..., value1, value2 --> ..., result
描述： 将操作数栈中的两个值弹出栈然后求余，最后将结果压入栈中。
异常： int 或 long 类型导致 ArithmeticException（除数为 0 导致的异常）。

# 取反指令

指令： ineg，lneg，fneg，dneg
格式： <指令>
操作数栈： ..., value --> ..., result
描述： 将操作数栈中的值弹出栈然后取反，最后将结果压入栈中。

int 或 long 类型：-x = (~x)+1 （补码）。

# 移位指令

指令： ishl，lshl，ishr，lshr，iushr，lushr
格式： <指令>
操作数栈： ..., value1，value2 --> ..., result
描述：

左移，右移，无符号右移。
int 类型，取 value2 的低 5 位（从 0 开始），value2 & 0x1f，移位范围 [0, 31]。
long 类型，取 value2 的低 6 位（从 0 开始），value2 & 0x3f，移位范围 [0, 63]。
无符合右移：左边用 0 填充移动后的空位。

# 按位与指令

指令： iand，land
格式： <指令>
操作数栈： ..., value1，value2 --> ..., result
描述： 按位布尔与运算。

# 按位或指令

指令： ior，lor
格式： <指令>
操作数栈： ..., value1，value2 --> ..., result
描述： 按位布尔或运算。

# 按位异或指令

指令： ixor，lxor
格式： <指令>
操作数栈： ..., value1，value2 --> ..., result
描述： 按位布尔异或运算。

# 局部变量自增指令

指令： iinc
格式： iinc index const
操作数栈： 无变化
描述：

index：当前帧的本地变量数组下标。
const：下标对应的变量增加 const 数量。
支持 wide，宽字节指令；wide iinc indexbyte1 indexbyte2 constbyte1 constbyte2。

# 操作数栈管理指令

类别 1 计算类型（category 1 computational type）

类别 2 计算类型（category 2 computational type）

Actual type	Computational type	Category
boolean	int	1
byte	int	1
char	int	1
short	int	1
int	int	1
float	float	1
reference	reference	1
returnAddress	returnAddress	1
long	long	2
double	double	2

# 出栈

指令： pop，pop2
格式： <指令>
操作数栈：

..., value --> ... (pop、pop2 支持)
..., value1, value2 --> ... （pop2 支持）

描述：

pop 弹出 1 个栈顶的值，仅类别 1 的计算类型使用；
pop2 弹出 1 个或 2 个栈顶的值，个数的计算是根据类型计算的，long 和 double 占 2 个 Slot；类别 1 和 2 的计算类型使用。

# 复制

指令：

dup，dup_x1，dup_x2, dup2，dup2_x1，dup2_x2

格式： <指令>
描述： 复制栈顶的 1 或 2 个值；根据不同的类别计算类型，操作数栈也有多种形式。
操作数栈：

dup: value 是类别 1，复制栈顶 1 格的值

..., value --> ..., value, value

dup_x1: value1 和 value2 是类别 1；复制的值 value1 下移 1 格【不包括被复制的值的位置】

..., value2, value1 --> ..., value1, value2, value1

dup_x2:

全是类别 1；复制的值 value1 下移 2 格【不包括被复制的值的位置】

..., value3, value2, value1 --> ..., value1, value3, value2, value1
value2 是类别 2，value1 是类别 1；复制的值 value1 下移 2 格【不包括被复制的值的位置】，因为 value2 直接占 2 格了

..., value2, value1 --> ..., value1, value2, value1

dup2:

全是类别 1；复制栈顶 2 格的值

..., value2, value1 --> ..., value2, value1, value2, value1
全是类别 2；复制栈顶 2 格的值，因为类别 2 占 2 格

..., value --> ..., value, value

dup2_x1:

全是类别 1；复制的值 value2 和 value1 下移 1 格【不包括被复制的值的位置】

..., value3, value2, value1 --> ..., value2, value1, value3, value2, value1
value1 是类别 2；value2 是类别 1，复制的值 value1 下移 1 格【不包括被复制的值的位置】，因为 value1 占 2 格

..., value2, value1 --> ..., value1, value2, value1

dup2_x2:

全是类别 1；复制的值 value2 和 value1 下移 2 格【不包括被复制的值的位置】

..., value4, value3, value2, value1 --> ..., value2, value1, value4, value3, value2, value1
value1 是类别 2，其它是类别 1；复制的值 value1 下移 2 格【不包括被复制的值的位置】，因为 value1 占 2 格

..., value3, value2, value1 --> ..., value1, value3, value2, value1
value3 是类别 2，其它是类别 1；复制的值 value2 和 value1 下移 2 格【不包括被复制的值的位置】，因为 value3 占 2 格

..., value3, value2, value1 --> ..., value2, value1, value3, value2, value1
全是类别 2；复制的 value1 下移 2 格【不包括被复制的值的位置，因为 value1 和 value2 占 2 格

..., value2, value1 --> ..., value1, value2, value1

# 交换

指令： swap
格式： <指令>
操作数栈： ..., value2, value1 --> ..., value1, value2
描述：
交换栈顶的第 1 和第 2 格的值；仅支持类别 1 的操作，没有类别 2 的交换指令。

# 类型转换指令

指令：

i2l，i2f，i2d
l2i，l2f，l2d
f2i，f2l，f2d
d2i，d2l，d2f

格式： <指令>
操作数栈： ..., value --> ..., result
描述： i，l，f，d 相互转换。

指令： i2b，i2c，i2s
格式： <指令>
操作数栈： ..., value --> ..., result
描述： int 转换成 byte、char、short 类型。

# 比较运算指令

# 比较大小

指令： lcmp，fcmpl，fcmpg，dcmpl，dcmpg
格式： <指令>
操作数栈： ..., value1, value2 --> ..., result
描述：
比较 value1 与 value2 的大小：

value1 > value2 => result = 1
value1 = value2 => result = 0
value1 < value2 => result = -1

fcmpl 与 fcmpg，dcmpl 与 dcmpg 的区别的是：如果 value1、value2 中任意 1 个是 NaN，则 fcmpl 和 dcmpl 的值是 - 1，而 fcmpg 和 dcmpg 的值是 1。

# 条件分支

指令： ifeq，ifne，iflt，ifge，ifgt，ifle
格式： <指令> branchbyte1 branchbyte2
操作数栈： ..., value --> ...
描述：

value 与 0 比较，包括符号位，value 的类型是 int；
如果成立，则构造 16 位的无符号偏移量，即 (branchbyte1 << 8) | branchbyte2，然后跳到（address + 偏移量）的位置执行指令；
不成立则继续执行 if<cond> 后面的指令。

eq => value = 0
ne => value ≠ 0
lt => value < 0
le => value ≤ 0
gt => value > 0
ge => value ≥ 0

指令：

if_icmpeq，if_icmpne，if_icmplt，if_icmpge，if_icmpgt，if_icmple
if_acmpeq，if_acmpne

格式： <指令> branchbyte1 branchbyte2
操作数栈： ..., value1, value2 --> ...
描述：

i 代表 value1 和 value2 是 int 类型；a 代表 value1 和 value2 是 reference 类型；
value1 与 value2 比较；
如果成立，则构造 16 位的无符号偏移量，即 (branchbyte1 << 8) | branchbyte2，然后跳到（address + 偏移量）的位置执行指令；
不成立则继续执行 if_<cond> 后面的指令。

eq => value1 = value2
ne => value1 ≠ value2
lt => value1 < value2
le => value1 ≤ value2
gt => value1 > value2
ge => value1 ≥ value2

# 引用相关指令

# 创建类示例

指令： new
格式： new indexbyte1 indexbyte2
操作数栈： ... --> ..., objectref
描述：

index = (indexbyte1 << 8) | indexbyte2；运行时常量池；
在垃圾回收堆内存中分配并初始化，然后 objectref 引用该内存，最后将 objectref 压入操作栈。

# 创建数组的指令

# 访问类字段

# 方法调用

# 获取数组长度

# 检查实例类型

# 异常处理

# 同步指令

# 其它指令

指令： nop
格式： nop
描述： 不做任何处理。

6. 包和crate

2023-04-16T11:20:20.000Z

# 包和 Crate

一个包，包含一个或多个 crate，并且只有一个 Cargo.toml 文件，阐述如何构建这些 crate。

# 模块

	// src/lib.rs

	mod front_of_house {
	mod hosting {
	fn add_to_waitlist() {}
	fn seat_at_table() {}
	}

	mod serving {
	fn take_order() {}
	fn server_order() {}
	fn take_payment() {}
	}
	}

相当于路径

crate
    front_of_house
        hosting
            add_to_waitlist
            seat_at_table
        serving
            take_order
            server_order
            take_payment

main.rs 和 lib.rs 都称为 crate 根

整个模块数都植根于隐式模块 crate 下

# 引用模块树的项

相对路径：以 self、super 来标识
绝对路径：以 crate 来标识

使用：：分隔

	mod front_of_house {
	mod hosting {
	fn add_to_waitlist() {}
	}
	}

	pub fn eat_at_restaurant () {
	// 绝对路径
	crate::front_of_house::hosting::add_to_waitlist();

	// 相对路径
	front_of_house::hosting::add_to_waitlist();
	}

建议使用绝对路径，因为项目结构调整是经常的。

# 私有性边界

上面的代码编译会失败，因为知道路径，但有些是私有的，不给使用。

Rust 中所有的条目默认是私有的：函数、方法、struct、enum、模块、常量
父级不能使用子级的东西，而子级可以使用父级的东西。

# pub - 使公有化

	mod front_of_house {
	pub mod hosting {
	pub fn add_to_waitlist(){}
	}
	}

	pub fn eat_at_restaurant() {
	// 绝对路径
	crate::front_of_house::hosting::add_to_waitlist();

	// 相对路径
	front_of_house::hosting::add_to_waitlist();
	}

内部的每一层都要加 pub 才能访问内部

同级是可以直接访问的

# super - 相对路径

super 可以改变模块访问边界，类似目录系统中的 ../ 上一层

	fn server_order() {}

	mod back_of_house {
	fn fix_incorrect_order() {
	cook_order();

	//super 改变路径位置
	// 注意：fn 不算是一层路径
	//mod 才是路径边界
	// 所以 super 是 back_of_house 的上一层
	super::server_order();
	}

	fn cook_order() {}
	}

# pub struct

pub 放在 struct 前：
- struct 是公共的
- struct 内的字段默认是私有的
struct 字段前添加 pub 设置为公共的

	mod back_of_house {
	pub struct Breakfast {
	pub toast: String,
	seasonal_fruit: String,
	}

	impl Breakfast {
	pub fn summer(toast: &str) -> Breakfast {
	Breakfast {
	toast: String::from(toast),
	seasonal_fruit: String::from("peaches"),
	}
	}
	}
	}

	pub fn eat_at_restuarant() {
	let mut meal = back_of_house::Breakfast::summer("Rye");
	//toast 字段是公共的，外部可以访问
	meal.toast = String::from("Wheat");
	println!("I'd like {} toast please", meal.toast);
	// 这里 seasonal_fruit 会报错，因为此字段是私有的，外部不可访问
	meal.seasonal_fruit = String::from("blueberries");
	}

# pub enum

把 pub 放在 enum 前：

enum 是公共的
enum 的变体也都是公共的

	mod back_of_house {
	pub enum Appetizer {
	// 以下变体，默认为公有的，此规则是例外；因为枚举在公共时才有意义
	Soup,
	Salad,
	}
	}

# use - 关键词

使用 use 关键字将路径导入到作用域内

可导入绝对路径或相对路径

	mod front_of_house {
	pub mod hosting {
	pub fn add_to_waitlist() {};
	}
	}

	// 导入绝对路径，建议绝对路径
	use crate::front_of_house::hosting;

	// 以下一行是导入相对路径
	// use front_of_house::hosting;

	pub fn eat_at_restuarant() {
	hosting::add_to_waitlist();
	hosting::add_to_waitlist();
	hosting::add_to_waitlist();
	}

# use - 惯用用法

函数：将函数的父级模块引入作用域（指定到父级），目的：方便知道函数是外部还是当前文件定义的。
struct、enum，其它：指定完整路径（指定到本身）
同名条目：指定到父级

	use std::fmt;
	use std::io;

	// Result 同名，需要指定到父级
	fn f1() -> fmt::Result {/impl/}

	fn f2() -> io::Result {/impl/}

# as - 别名

as 关键字可以为 use 引入的路径指定本地的别名

	use std::fmt::Result;
	use std::io::Result as IoResult;

	fn f1() -> Result {/impl/}

	fn f2() -> IoResult {/impl/}

# pub use - 重新导出名称

在 use 前面添加 pub，重导出模块

	// 外部不能访问
	mod front_of_house {
	pub mod hosting {
	pub fn add_to_waitlist() {};
	}
	}

	// 重导出，这样外部能访问 hosting
	pub use crate::front_of_house::hosting;

	// 外部能访问
	pub fn eat_at_restuarant() {
	hosting::add_to_waitlist();
	hosting::add_to_waitlist();
	hosting::add_to_waitlist();
	}

# package - 使用外部包

Cargo.toml 添加依赖的包（package）：国内建议配置镜像
- https://crates.io
use 将依赖包内特定的条目引入到作用域

# 嵌套路径 - 优化 use 语句

如果使用同一个包或模块下的多个条目，则导致多条 use 语句。可以提取公共部分，把不同的部分放到嵌套路径上。

路径相同部分::{路径差异的部分}

	// use std::cmp::Ordering;
	// use std::io;

	// 使用嵌套路径优化
	use std::{cmp::Ordering, io};

	fn main{}

如果两个 use 路径之一是另外一个的子路径时：

	// use std::io;
	// use std::io::Write;

	// 使用嵌套路径，以及 self 优化路径
	use std::io::{self, Write};

# 通配符 *

使用 * 可以把路径中所有的公共条目都引入到作用域。
应用场景：
- 测试。（将所有被测试代码引入到 tests 模块）
- 用于预导入（prelude）模块

# 将模块拆分到其它文件

模块定义时，如果模块名后面是 ; 结尾，而不是代码块时：

rust 会从与模块同名的文件中加载内容

	// 文件：src/lib.rs

	//rust 会找此文件目录下的 front_of_house.rs 文件
	mod front_of_house;

	// 文件：src/front_of_house.rs

	pub mod hosting {
	pub fn add_to_waitlist() {}
	}

多层模块嵌套时：

	// 文件：src/lib.rs

	//rust 会找此文件目录下的 front_of_house.rs 文件
	mod front_of_house;

	// 文件：src/front_of_house.rs

	//rust 会找此文件目录下的 front_of_house/hosting.rs 文件
	pub mod hosting;

	// src/front_of_house/hosting.rs

	pub fn add_to_waitlist() {}

5. 枚举与模式匹配

2023-04-16T10:20:20.000Z

# 定义枚举

	enum IpAddrKind {
	V4,
	V6,
	}

最后一个逗号可加，可不加

# 枚举值

	let four = IpAddrKind::V4;
	let six = IpAddrKind::V6;

	fn route(ip_type: IpAddrKind) { }

	struct IpAddr {
	kind: IpAddrKind,
	address: String
	}

# 枚举成员嵌套任意类型

	enum IpAddrKind {
	V4(u8, u8, u8, u8),
	V6(String),
	}

	let home = IpAddrKind::V4(127, 0, 0, 1);
	let loopback = IpAddrKind::V6("::1");

# 标准库如何定义 ip 地址？

	struct Ipv4Addr {
	// 省略字段
	}

	struct Ipv6Addr {
	// 省略字段
	}

	enum IpAddr {
	V4(Ipv4Addr),
	V6(Ipv6Addr),
	}

# 枚举还可以定义 impl

	enum Message {
	Quit,
	Move {x: i32, y: i32},
	Write(String),
	ChangeColor(i32, i32, i32),
	}

	// 与 struct 类似
	struct QuitMessage;
	struct MoveMessage {x: i32, y: i32};
	struct WriteMessage(String);
	struct ChangeColorMessage(i32, i32, i32);

	// 还可以使用 impl
	impl Message {
	fn call(&self) {
	// todo
	}
	}

	// m.call();

# Option

	enum Option<T> {
	Some<T>,
	None,
	}

因为常用，所以 Some 和 None 可单独使用。

例如：

	let some_number = Some(5);

	// None 无法推断类型，因此需要指定类型；
	let absent_number: Option<i32> = None;

# match 控制流

	fn main() {
	let coin = Coin::Penny;
	let value = match coin {
	Coin::Penny => {
	println!("Penny");
	1
	},
	Coin::Nickel => 5,
	Coin::Dime => 10,
	Coin::Quarter => 25,
	};
	println!("{}", value);
	}

	enum Coin {
	Penny,
	Nickel,
	Dime,
	Quarter
	}

# 绑定值的形式

	fn main() {
	let coin = Coin::Quarter(UsState::Alaska);
	let value = value_in_cents(coin);
	println!("{}", value);
	}
	fn value_in_cents(coin: Coin) -> u8 {
	match coin {
	Coin::Penny => 1,
	Coin::Nickel => 5,
	Coin::Dime => 10,
	Coin::Quarter(state) => {
	println!("state: {:?}", state);
	25
	}
	}
	}

	#[derive(Debug)]
	enum UsState {
	Alabama,
	Alaska,
	// -- snip --
	}
	enum Coin {
	Penny,
	Nickel,
	Dime,
	Quarter(UsState)
	}

注意事项：

使用时，不要忘记前缀： Coin::
使用时，不要忘记符号： =>
打印时，不要忘记注解和符号： #derive(Debug) 和 {:?}

# 匹配 Option<T>

如何获取 Option 里面的值呢？

	fn plus_one(x: Option<i32>) -> Option<i32> {
	match x {
	None => None,
	Some(i) => Some(i + 1)
	}
	}

# 匹配是穷尽的

match 需要穷尽，如果某个分支没匹配到，就会编译不通过。

# _ 通配符

如果有些不想匹配，则可以用通配符，相当于 default 分支。

	let some_u8_value = 0u8;
	match some_u8_value {
	1 => println!("one"),
	3 => println!("three"),
	5 => println!("five"),
	7 => println!("seven"),
	_ => (),
	}

如果只考虑其中 1 个分支，就啰嗦了，因此有 if let

# if let 简化匹配

	let some_u8_value = Some(3);
	// if let
	if let Some(3) = some_u8_value {
	println!("three");
	}

这样就不用每个分支都要穷尽。

4. 结构体

2023-04-15T10:20:20.000Z

# 定义

	struct User {
	name: String,
	age: usize,
	gender: u8
	}

# 使用

	let mut user = User {
	name: String::from("Cecil"),
	age: 26,
	gender: b'M'
	};

# 简化

	fn build_user(name: String, user: User) -> User {
	User {
	name,
	..user
	}
	}

name 要和字段同名才可以，否则还是得 name: name1

# 元组结构体

	struct Color(i32, i32, i32);
	struct Point(i32, i32, i32);

	let black = Color(0, 0, 0);
	let origin = Point(0, 0, 0);

# 类单元结构体

	struct Unit();

	let unit = Unit();

# 结构体的所有权

结构体内，定义需要自身所有权；例如 String，不能是 &str 的 slice 类型

否则拥有其它对象的引用会编译错误，除非加上生命周期。后面章节讲。

结构体是为了组织代码。面向对象的思想。

但是直接打印，会报错

	fn main() {
	let rectangle = Rectangle {
	width: 10,
	height: 10
	};

	println!("{}", rectangle);
	}

	struct Rectangle {
	width: u32,
	height: u32
	}

改进，需要实现 Display 和 Debug trait

	fn main() {
	let rectangle = Rectangle {
	width: 10,
	height: 10
	};

	println!("{:#?}", rectangle);
	}

	#[derive(Debug)]
	struct Rectangle {
	width: u32,
	height: u32
	}

# 方法与结构体紧密联系

	impl Rectangle {
	fn area(&self) -> u32 {
	self.width * self.height
	}
	}

	// 创建 rectangle
	// rectangle.area();

&self 和 &Retangle 类似，仅仅获取引用，不获取所有权。

如果想修改则使用 &mut self

# -> 运算符去哪了？

其它语言，如果是指针，需要这样用：obj->something ()，或者 (*obj).something ();

Rust 会自动引用和解引用

	p1.something(&p2);

	// 等效
	(&p1).something(&p2);

# 方法不带 &self ?

不带的话，还是称为函数，使用时，使用：：符号，例如：String::from ("");

	fn main() {
	// 类似 Java 的静态方法
	let rectangle = Rectangle::rectangle(10);

	println!("{}", rectangle.area());
	}

	#[derive(Debug)]
	struct Rectangle {
	width: u32,
	height: u32
	}

	impl Rectangle {
	fn area(&self) -> u32 {
	self.width * self.height
	}

	// 不带 &self
	fn rectangle(size: u32) -> Rectangle {
	Rectangle {
	width: size,
	height: size
	}
	}
	}

# 多个 impl 块

支持多个 impl 块定义

	impl Rectangle {
	fn area(&self) -> u32 {
	self.width * self.height
	}
	}

	impl Rectangle {
	fn rectangle(size: u32) -> Rectangle {
	Rectangle {
	width: size,
	height: size
	}
	}
	}

不过还是建议放在一起，除非和 trait 配合使用

3. 所有权

2023-04-14T10:20:20.000Z

# stack vs. heap

stack 速度比 heap 快

所有权解决的问题：

跟踪代码哪些部分正在使用 heap 的哪些数据
最小化 heap 上的重复数据量
清理 heap 上未使用的数据，以避免空间不足

管理 heap 数据是所有权的主要原因

# 所有权规则

每个值都有一个变量，这个变量是该值的所有者
每个值同时只能有一个所有者
当所有者超出作用域（scope）时，该值将被删除。

# 变量作用域

scope 就是程序中一个项目的有效范围

# 所有权举例：String 类型

String 比那些基础标量数据类型更复杂
字符串字面值：程序里手写的那些字符串值。不可变。
String 在 heap 创建

# 创建 String 类型的值

使用 from 函数从字符串字面值创建出 String 类型

let mut s = String::from("Hello");

这类字符串是可以被修改的

内存：

内存不释放就浪费内存
提前释放，变量就非法
释放多次就导致 bug，因此必须一次分配对应一次释放

# 内存和分配

rust 对于某个值来说，当拥有它的变量走出作用范围时，内存就会立即自动交还给操作系统
drop 函数

# 变量和数据交互的方式：移动（move）

多个变量可以与同一个数据使用一种独特的方式来交互

let x = 5;

let y = x;

这 2 个变量的值压入到 stack 中

# 变量和数据交互的方式：移动，String 版本

	fn main() {
	let s1 = String::from("hello");
	let s2 = s1;
	// 这里会报错；
	// 因为 s1 的值所有权已经移动到 s2 了；
	//s1 失效，不能再使用了
	println!("{}", s1); // error.
	}

# 浅拷贝、深拷贝和移动

浅拷贝（shallow copy）和深拷贝（deep copy）是其他语言的概念。

浅拷贝导致内存得不到释放或者多次释放。

rust 不使用浅拷贝这种概念，rust 使用移动（move）概念；
例如上面的 s1 和 s2；s2 = s1 会把 s1 的值移动到 s2；数据的所有权移动到了 s2，且 s1 失效。

rust 也不会创建深拷贝，移动操作都是很廉价、快速的。

# 变量和数据交互的方式：克隆（Clone）

如果真的需要深拷贝，可以使用 clone 方法，这里不使用深拷贝概念。

浅拷贝对应 rust 的移动概念，rust 多了一步失效前一个变量的操作。

深拷贝对应 rust 的克隆概念。

以上移动和克隆都是对 heap 上的数据讨论的。stack 上的数据直接复制就 ok。

	fn main() {
	let s1 = String::from("hello");
	let s2 = s1.clone();
	println!("{} {}", s1, s2);
	}

# stack 上的数据：复制

	fn main() {
	let x = 5;
	let y = x;
	// 不报错，这里不发生移动
	//stack 执行的是复制操作
	//stack 数据都是确定的，所以可以自动计算
	println!("{} {}", x, y);
	}

Copy trait: 可以像整数一样，完全放在 stack 上面的类型。
如果一个类型实现了 Copy 这个接口 (trait，特性)，那么旧的变量在赋值后仍然可以使用。因为发生的是复制 (Copy)，而不是移动。
因此，如果一个类型或者该类型的一部分实现了 Drop trait，那么 rust 不允许再实现 Copy trait。因为复制和移动这 2 个概念是冲突的，因此不能同时实现。

# 一些拥有 Copy trait 的类型

任何简单的标量的组合类型都可以 Copy 的
任何需要分配内存或者某种资源的都不是 Copy 的
一些拥有 Copy trait 的类型：
- 所有整数类型，例如 u32
- bool
- char
- 所有的浮点类型，例如：f64
- Tuple（元组），如果其所有的字段都是 Copy 的：(i32, i32) 是，而 (i32, String) 不是

# 所有权与函数

将值传递给函数和把值赋值给变量是类似的：

将值传递给函数会发生移动或复制

	fn main() {
	let s = String::from("Hello World");

	//s 的值在堆中，值的所有权移动到函数内部了
	// 函数结束后，因为持有所有权，因此就会释放
	// 函数后面就不能再使用 s1 变量了。
	take_ownership(s);

	let x = 5;

	// 因为 x 是标量，值在 stack 中；
	//i32 实现了 Copy trait
	// 传入函数内部发生复制，因此函数后面 x 还能使用
	makes_copy(x);

	println!("{}", x);
	}

	fn take_ownership(some_string: String) {
	//some_string 获得所有权
	println!("{}", some_string);
	} // 函数结束，释放 some_string 堆上的内存

	fn makes_copy(some_number: i32) {
	//some_number 通过复制获得新的拷贝值
	println!("{}", some_number);
	} // 函数结束，some_number 在 stack 内存上自动释放
	// 因为是复制的，不会影响外部的变量

# 返回值与作用域

函数的返回值的过程中同样也会发生所有权的转移

	fn main() {
	// 从函数返回值中获得所有权
	let s1 = gives_ownership();

	let s2 = String::from("hello");

	// 传入 s2 变量，所有权移动到函数内部
	// 函数直接返回，再次将所有权移动到函数外面的 s3
	let s3 = takes_and_gives_back(s2);

	// 后面不能使用 s2 变量，因为所有权移动到 s3 上了
	//s2 -> a_string（函数入参） -> s3
	}

	fn gives_ownership() -> String {
	let some_string = String::from("hello");
	some_string
	} // 返回值移动所有权到函数调用者

	fn takes_and_gives_back(a_string: String) -> String {
	a_string
	} // 传入参数获得所有权，直接返回，返回值移动所有权到函数调用者

# 如何让函数使用某个值，但不获取其所有权？引用

	fn main() {
	let s1 = String::from("hello");

	// 为了获取字符串的长度，需要传入变量
	// 但这样传入发生所有权的移动，而且发生 2 次移动
	// 有点啰嗦和影响性能
	let (s2, len) = calculate_length(s1);

	println!("The length of '{}' is {}.", s2, len);
	}

	fn calculate_length(s: String) -> (String, usize) {
	let length = s.len();
	(s, length)
	}

函数传入参数，又返回此参数；

所有权移动了 2 次，但我们可能只想使用，但不需要获取其所有权，因此引入了引用（Reference）和借用（Borrow）的概念。

需要区分所有权、引用 / 借用的概念，这 2 个概念容易混淆，但不是同一个东西。

引用 / 借用不会改变所有权，函数结束后，也不会释放变量（没所有权）。

# 引用与借用

	fn main() {
	let s = String::from("hello");

	// &s 这里是引用
	let length = calculate_length(&s);

	println!("The length of '{}' is {}.", s, length);
	}

	// 这里 s 是借用；只有借用关系，不会发生所有权的移动
	fn calculate_length(s: &String) -> usize {
	s.len()
	}

引用和借用是同一个东西，只不过发生的位置不同，传入参数就是引用的概念；函数参数定义就是借用的概念。

# 借用

和变量一样，引用默认也是不可变的。

如果借用一个值，需要修改，则需要定义为可变引用，变量也要定义为可变。

	fn main() {
	// 变量需要定义为可变
	let mut s = String::from("hello");

	// 引用需要 &mut 可变引用
	let length = calculate_length(&mut s);

	println!("The length of '{}' is {}.", s, length);
	}

	// 函数参数需要定义为可变借用
	fn calculate_length(s: &mut String) -> usize {
	s.push_str(" World");
	s.len()
	}

# 可变引用

可变引用有一个重要的限制：在特定作用域内，对某一块数据，只能有一个可变的引用。
这样做的好处是可在编译时防止数据竞争。

以下三种行为下（同时存在）会发生数据竞争：

两个或多个指针同时访问同一个数据
至少有一个指针用于写入数据
没有使用任何机制来同步对数据的访问

	fn main() {
	let mut s = String::from("hello");
	let s1 = &mut s;
	let s2 = &mut s;
	//s1 和 s2 会发生数据竞争，因此编译不通过
	println!("{} {}", s1, s2);
	}

可以通过创建新的作用域，来允许非同时的创建多个可变引用

	fn main() {
	let mut s = String::from("hello");
	{
	let s1 = &mut s;
	}
	let s2 = &mut s;
	}

# 另外一个限制

不可以同时拥有一个可变引用和一个不可变引用
多个不变引用是可以的

可变引用会修改数据，如果没有同步操作，不可变引用的值可能被改变导致数据不一致；因此 rust 限制这种情况。

	fn main() {
	let mut s = String::from("hello");
	let r1 = &s;
	let r2 = &s;
	// 不能同时有可变和不可变的引用
	let s1 = &mut s;
	println!("{} {} {}", r1, r2, s1);
	}

# 悬空引用 Dangling References

悬空指针（Dangling Pointer）: 一个指针引用了内存中的某一个地址，而这块内存可能已经释放并分配给其它人使用了。
Rust 中，编译器可以保证引用永远都不是悬空引用。
在 rust 中，只有这种情况可能发生悬空引用：
- 函数内部创建一个对象，然后仅仅返回其引用；然而函数结束后；由于函数内持有所有权，结束会释放内存，但返回引用给调用者；这样就发生悬空引用。
- rust 不会允许这种情况发生，需要指定生命周期，扩大对象的作用域范围。

	fn main() {
	let r = dangle();
	}

	fn dangle() -> &String {
	let s = String::from(hello"");
	&s
	}

# 引用的规则

在任何给定的时刻，只能满足下列条件之一：
1. 只有一个可变的引用
2. 或者只能任意数量的不可变的引用
引用必须一直有效

# 切片

rust 的另外一种不持有所有权的数据类型：切片 (slice)

以下程序可能有什么问题？

	fn main() {
	let mut s = String::from("Hello World");
	let word_index = first_word(&s);
	// 如果 s 的内存被清空了，但还有 index 在；
	// 后面使用 index 从 s 中获取内容，
	// 就导致 bug，例如下面这句；
	s.clear();
	println!("{}", word_index);
	}

	fn first_word(s: &String) -> usize {
	let bytes = s.as_bytes();
	for (i, &item) in bytes.iter().enumerate() {
	if item == b' ' {
	return i;
	}
	}
	s.len()
	}

# 字符串切片

字符串切片是指向字符串中一部分的内容引用

注意需要 & 符号，因为是一个引用，类型是 &str。

形式：& 变量 [开始索引.. 结束索引]，不包含结束索引

注意：字符串切片范围索引要是有效的 utf-8 字符边界内，否则程序会报错退出。

	fn main() {
	let s = String::from("hello world");
	let hello = &s[0..5]; // 语法糖：&s [..5];
	let world = &s[6..11]; // 语法糖：&s [6..]; 或 &s [6..s.len ()];
	let helloworld = &s[..]; // 语法糖
	}

# 使用字符串切片重写例子

	fn main() {
	let mut s = String::from("Hello World");
	let word_index = first_word(&s);
	// 这里由于所有权会报错，因此 rust 机制保证安全，
	// 防止内存释放后，还使用相关内容
	s.clear();
	println!("{}", word_index);
	}

	fn first_word(s: &String) -> &str {
	let bytes = s.as_bytes();
	for (i, &item) in bytes.iter().enumerate() {
	if item == b' ' {
	return &s[..i];
	}
	}
	&s[..]
	}

# 字符串字面值是切片

字符串字面值直接被存储在二进制程序中。
变量 s 的类型是 &str，它是一个指向二进制程序特点位置的切片。
字面值不可变。

	fn main() {
	let s = "Hello World"; // 相当于 &str 类型
	println!("{}", s);
	}

# 将字符串切片作为参数传递

建议函数入参不使用 &String，更通用的做法是使用切片作为入参。

	fn main() {
	let mut s = String::from("Hello World");
	let word_index = first_word(&s[..]);

	println!("{}", word_index);

	// 通用
	let word_index = first_word("Hello World");
	println!("{}", word_index);
	}

	fn first_word(s: &str) -> &str {
	let bytes = s.as_bytes();
	for (i, &item) in bytes.iter().enumerate() {
	if item == b' ' {
	return &s[..i];
	}
	}
	s
	}

# 其它类型的切片

例如数组 i32 的切片，类型是 &[i32]

	fn main() {
	// 类型 &[i32]
	let a = [1, 2, 3, 4, 5];
	let slice = &a[1..3];
	println!("{} {}", slice[0], slice[1]);
	}

2. 通用的编程概念

2023-04-07T10:20:20.000Z

# 变量

# 变量的可变性

声明变量使用 let 关键字
默认情况下，变量是不可变的（immutable）
使用 let mut 声明变量，就可以声明可变的（mutable）变量

# 常量与不可变变量

不可以使用 mut，常量永远不可变的
声明常量使用 const，必须手工指定类型
常量可以在任何作用域内声明，包括全局作用域
常量只可以绑定到常量表达式，无法绑定到函数的调用结果或只能在运行时才能计算出来的值
在程序运行期间，常量在其声明的作用域内一直有效
命名规范，全大写字母，每个单词下划线分开

	// 可在任意作用域定义
	// 10_000 插入 _，为了方便阅读
	const MAX_SIZE : u32 = 10_000;

	fn main() {
	const MAX_SIZE : u32 = 10_000;
	}

# shadowing （隐藏）

可以使用相同的名字定义新的变量，新的变量会隐藏之前声明的同名变量
在后续的代码中，这个变量名就表示新的变量
新的变量类型可以不同

	fn main() {
	// &str
	let spaces = " ";
	// usize
	let spaces = spaces.len();
	}

# 数据类型

rust 能自动推断类型，如果推出多个类型，则需要手工指定类型

# 标量类型

整数
浮点
布尔
字符

# 整数类型

无符号以 u 开头；有符号以 i 开头
有符号范围： $-2^{n-1}$ 到 $2^{n-1} - 1$
无符号范围： $0$ 到 $2^n - 1$
isize 和 usize 由系统架构所决定

Length	Signed	Unsigned
8-bit	i8	u8
16-bit	i16	u16
32-bit	i32	u32
64-bit	i64	u64
128-bit	i128	u128
arch	isize	usize

# 整数字面值

除了 byte 类型外，所有的数值字面值都允许使用类型后缀
例如：57u8
整数默认类型是：i32
i32 整体速度很快，即使在 64 位系统

Number Literals	Example
Decimal	98_222
Hex	0xff
Octal	0o77
Binary	0b1111_0000
Byte (u8 only)	b'A'

# 整数溢出

调试模式下编译，rust 会检查，运行时就会 panic
发布模式编译，rust 不会检查导致的 panic 整数溢出
1. 如果溢出发生，rust 会执行 “环绕” 操作

# 浮点类型

f32，32 位单精度
f64，64 位双精度
使用 IEEE-754 标准表达
默认 f64 类型

# 布尔类型

一个字节大小
符号是 bool

# 字符类型

char 类型
占用 4 个字节大小
使用 Unicode 标量值：多国文字、emoji 表情
范围：U+0000 到 U+D7FF；U+E000 到 U+10FFFF

	fn main() {
	let x = 'z';
	let y: char = 'Ƶ';
	let z = '😂';
	}

# 复合类型

元组（tuple），多个类型的集合，长度固定
数值，同种类型的集合，长度固定

# tuple

	fn main() {
	let tup: (i32, f64, u8) = (500, 6.4, 1);
	// 下标获取元素值
	println!("{}, {}, {}", tup.0, tup.1, tup.2);

	// 模式匹配解构 (destructure) 获取元素值
	let (x, y, z) = tup;
	println!("{}, {}, {}", x, y, z);
	}

# 数组

数组没有 vector 灵活

	fn main() {
	let a = [1, 2, 3, 4, 5];
	}

# 数组的类型

数组的类型以这种形式表示：[类型；长度]

例如： let a: [i32; 5] = [1, 2, 3, 4, 5];

如果数组每个元素值都相同，可以：let a = [3; 5];
它就相当于：let a = [3, 3, 3, 3, 3]

# 访问数组元素

rust 不允许访问数组外的地址内存

# 函数

使用 fn 关键字
使用 snake_case 命名方式

	fn main() {
	another_function(5); // argument
	}

	fn another_function(x: i32) { // parameter
	println!("the value of x is: {}", x);
	}

# 函数体中语句和表达式

函数体由一系列语句组成，可选的由一个表达式结束
rust 是一个基于表达式的语言
语句是执行一些动作的指令
表达式会计算产生一个值
函数的定义也是语句
语句不返回值，所以不可以使用 let 将一个语句赋值给一个变量

	fn main() {
	let x = 5;
	let y = {
	let x = 1;
	// 表达式，产生一个值；这里不能分号结束
	// 分号结束就是一条语句，语句其实也返回一个空 tuple：()
	x + 3
	};

	// 空 tuple () 没有实现 Display
	// 所以 x + 3 加分号，这里就不能打印；
	println!("The value of y is: {}", y);
	}

# 函数的返回值和注释

在 -> 符号后面声明函数返回值类型，但是不可以为返回值命名
在 rust 里面，返回值就是函数体里面最后一个表达式的值
如果要提前返回，需要使用 return 关键字，并指定一个值

	// This is a function
	fn plus_five(x: i32) -> i32 {
	x + 5
	}

	/* multiple line comments
	lalalala */
	fn main() {
	// plus_five
	let x = plus_five(6); // 5 + 6;
	println!("The value of x is: {}", x);
	}

# 控制流

# if 表达式

与条件相关联的代码块叫做分支（arm）
表达式必须是一个 bool 类型的，没有隐式转换

	fn main() {
	let number = 3;

	if number < 5 {
	println!("condition was less than 5.");
	} else if number > 10 {
	println!("condition was greater than 10.");
	} else {
	println!("condition was [5, 10].");
	}
	}

# 如果多个 else if 条件，建议用 match 重构

# 在 let 语句中使用 if

if 是一个表达式，因此可以放在 let 语句中等号右边。

	fn main() {
	let condition = true;
	let number = if condition { 5 } else { 6 };
	println!("The value of number is: {}", number);
	}

# 循环

rust 提供 3 种循环：loop，while 和 for

# loop

	fn main() {
	let mut counter = 0;

	let result = loop {
	counter += 1;

	if counter == 10 {
	break counter * 2;
	}
	};

	println!("The result is: {}", result);
	}

# while

	fn main() {
	let mut counter = 3;
	while counter != 0 {
	println!("{}", counter);
	counter = counter - 1;
	}
	println!("LIFTOFF");
	}

# for

这是最简洁，最安全的数组遍历，因此这种写法最常用

	fn main() {
	let a = [10, 20, 30, 40, 50];
	//element 是 &i32 类型，是引用类型
	for element in a.iter() {
	println!("The value is: {}", element);
	}
	}

# Range

Range 生成左闭右开的范围，rev () 可以倒过来。

	fn main() {
	for number in (1..4).rev() {
	println!("{}", number);
	}
	println!("LIFTOFF");
	}

1. 安装和体验

2023-04-07T07:20:20.000Z

# 安装 rust

官网安装

	# mac 系统安装
	curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs \| sh

# 常用命令

	# 更新
	rustup update

	# 卸载
	rustup self uninstall

	# 安装验证，rustc x.y.z (commit_hash yyyy-mm-dd)
	rustc --version

	# 本地文档
	rustup doc

# 开发工具

vscode，插件：rust-analyzer、另外一个 rust 插件已经弃用了

# hello world

文件后缀： .rs
命名规范：hello_world.rs

	fn main() {
	println!("Hello World!");
	}

# 编译和运行

编译：rustc 文件名.rs
生成 .exe 可执行文件和 .pdb 调试文件
rust 是 ahead-of-time 编译语言：不需要安装 rust 就可以运行执行文件
rustc 适合编译简单的程序

# cargo

cargo 是 rust 构建系统和包管理工具
查看是否安装：cargo --version

	# 查看是否安装、版本号
	cargo --version

	# 创建新项目
	cargo new 项目名称
	# cargo new hello_world
	# --vcs 指定版本控制系统：默认 git; hg, pijul, or fossil, none

# cargo.toml 介绍

[package]

name: 项目名称
version: 项目版本
authors: 项目作者
edition: rust 版本

[dependencies]
rust 里面，代码的包称作 crate

# cargo 构建和运行项目

cargo build: 编译
cargo run: 编译和运行

# cargo check 检查代码

检查代码，确保能通过编译，但是不产生可执行文件
比 build 快的多，编写代码可以连续反复 cargo check 检查代码，提供效率

# 为发布构建

cargo build --release

编译时会进行优化：编译时间久，代码运行快
会在 target/release 目录生成，而不是 target/debug

# 猜一个数：一次猜测

	//prelude 没在预导入里面的，需要手工引入 use
	use std::io; // prelude

	fn main() {
	println!("猜数：");

	println!("猜一个数（1-100）：");

	// 1. 所有变量默认 immutable，如果要修改，则需要用 mut
	// 2. 返回一个 String 对象实例，:: 关联函数
	let mut guess = String::new();

	// 1. stdin 关联函数返回一个 Stdin 的实例
	// 2. 引入默认也是不可变的，因此也需要 mut
	// 3. read_line 返回 io::Result 枚举类型：Ok, Err
	io::stdin().read_line(&mut guess).expect("读取错误!");

	// {} 占位符
	println!("你猜的数是: {}", guess);
	}

# 猜一个数：生成神秘数字

我们创建的项目是二进制 crate（可以独立运行）；我们要引用一个依赖，这个是依赖 crate（不能独立运行）。

在 dependencies 下添加
rand = "0.3.14"

# Cargo.lock

cargo.lock 锁定当前依赖版本，保证每次编译生成相同东西，保证一致性；
如果修改依赖版本，则可以 cargo update 更新这个文件

cargo update

# 生成神秘数字

	// 这是一个 trait，类似接口；rand::thread_rng () 需要
	use rand::Rng; // trait
	use std::io;

	fn main() {
	println!("猜数：");

	let secret_number = rand::thread_rng().gen_range(1..101);

	println!("神秘数字: {}", secret_number);

	println!("猜一个数（1-100）：");

	let mut guess = String::new();

	io::stdin().read_line(&mut guess).expect("读取错误!");

	println!("你猜的数是: {}", guess);
	}

# 猜一个数：比较猜测数字和神秘数字

	// 这是一个 trait，类似接口；rand::thread_rng () 需要
	use rand::Rng; // trait

	use std::cmp::Ordering;
	use std::io;

	fn main() {
	println!("猜数：");

	let secret_number = rand::thread_rng().gen_range(1..101);

	println!("神秘数字: {}", secret_number);

	println!("猜一个数（1-100）：");

	let mut guess = String::new();

	io::stdin().read_line(&mut guess).expect("读取错误!");

	println!("你猜的数是: {}", guess);

	// 1. parse 后，需要指定类型，这里指定 u32；expect 就是异常中断程序处理
	// 2. 原本 secret_number 默认是 i32 类型；
	// 因为后面 guess.cmp 与 secret_number 比较，
	// 编译器自动推断 secret_number 类型也为 u32
	let guess: u32 = guess.trim().parse().expect("Please input a number!");

	//match 匹配，每个分支称为 arm
	match guess.cmp(&secret_number) {
	Ordering::Less => println!("Too small!"),
	Ordering::Greater => println!("Too Big!"),
	Ordering::Equal => println!("You win!"),
	}
	}

# 猜一个数：多次猜测

	use rand::Rng;

	use std::cmp::Ordering;
	use std::io;

	fn main() {
	println!("猜数：");

	let secret_number = rand::thread_rng().gen_range(1..101);

	println!("猜一个数（1-100）：");

	// 多次循环
	loop {
	let mut guess = String::new();

	io::stdin().read_line(&mut guess).expect("读取错误!");

	println!("你猜的数是: {}", guess);

	//expect 导致程序中断，不优雅，因此用 match 处理不同枚举情况
	let guess: u32 = match guess.trim().parse() {
	// 直接返回结果
	Ok(num) => num,
	// 不关心结果，用 _ 表现
	Err(_) => {
	println!("请输入一个数字.");
	// 跳出此次循环，但不停止循环
	continue;
	}
	};

	match guess.cmp(&secret_number) {
	Ordering::Less => println!("Too small!"),
	Ordering::Greater => println!("Too Big!"),
	Ordering::Equal => {
	println!("You win!");
	// 跳出并且停止此循环
	break;
	}
	}
	}
	}

IEEE 754 — 浮点数

2023-01-02T13:05:01.000Z

# bit 构成

sign、exponent、fraction
符号域、指数域、分数域

32 位：1、8、23
64 位：1、11、52

	+------+----------+----------+
	\| sign \| exponent \| fraction \|
	+------+----------+----------+
	\| 1 \| 8 \| 23 \| <-- 32 位
	+------+----------+----------+
	\| 1 \| 11 \| 52 \| <-- 64 位
	+------+----------+----------+

# 表示

$value = sign * exponent * fraction$

# sign

0: +
1: -

# exponent

规约形式、非规约形式、特殊值，含义不一样。

# fraction

规约形式、非规约形式、特殊值，含义不一样。

# 规约形式

规约形式： $1.M * 2^e$

# 二进制的科学计数法

$1.M * 2^e$

1.M：把最高位 “1.” 部分隐藏，不在浮点数中表示，称为隐藏位。
- 因为 “1.” 这部分是固定值，没必要占用空间。
M：保存到 fraction 域中。
- M 是科学计数法的尾数域（mantissa）。
- 因为有隐藏位，为了与尾数域区分，M 叫做有效位（significant）。
e：保存到 exponent 中，需要转换为偏正值。
- $exponent = e + bias$

# exponent

# exponent 范围

$exponent \in (0, 2^e - 2] \cap \mathbb{Z}$ ； $0$ 和 $2^e - 1$ 用于特殊值。

32 位（e=8）： $exponent \in [1, 254] \cap \mathbb{Z}$
64 位（e=11）： $exponent \in [1, 2046] \cap \mathbb{Z}$

# 偏正值

exponent 使用 [偏正值] 表示

exponent = 实际指数 + 指数偏移值

偏正值：引入偏移值，使得 exponent 为正数
作用：简化比较。指数也有符号，且 S 域也表示符号；如果指数用补码表示，则 (S + EXP) 就不能进行简单的比较

# 指数偏移值 (exponent bias)

$2^{e-1} - 1$

32 位（e=8）：+127
64 位（e=11）：+1023

# fraction

保存 1.M 的 M 部分，有效位部分
范围： $1.M \in [1, 2)$

# 非规约形式

非规约形式： $0.M$

使用 0.M 表示
- 表示非常接近 0： $0.M \in (0, 1)$
- exponent = 0
- fraction 保存 M，尾数域（mantissa）
exp = 0, mantissa ≠ 0

# 特殊值

$exp = 0, mantissa = 0$ $e x p = 0, m a n t i s s a = 0$
- $\pm0$ （和符号位有关）
$exp = 2^e -1, mantissa = 0$ $e x p = 2 e - 1, m a n t i s s a = 0$
- $\pm\infty$ $\pm \infty$ （和符号位有关）
  - $\frac{1.0}{0.0} \rightarrow +\infty$
  - $-\frac{1.0}{0.0} \rightarrow -\infty$
$exp = 2^e -1, mantissa \neq 0$ $e x p = 2 e - 1, m a n t i s s a \neq = 0$
- NaN （非数，与符号位无关）
  - $\frac{0.0}{0.0}$
  - $\infty * 0.0, -\infty * 0.0$
  - $\sqrt{\smash[b]{-1}}$
  - 传递性：任何数字与 NaN 的算术运算，结果都是 NaN，除了 $NaN^0 = 1$
  - 反自反性： $v != v$ （与自身比较不相等）

# Java 中的浮点数特殊值

浮点数与整数不同，除 0 不会异常。

	public static void main(String[] args) {
	float infinity = 1.0f / 0.0f;
	float minusInfinity = -1.0f / 0.0f;
	float NaN = 0.0f / 0.0f;

	System.out.println(infinity); // Infinity
	System.out.println(minusInfinity); // - Infinity
	System.out.println(NaN); // NaN
	System.out.println();

	System.out.println(infinity == infinity); // true
	System.out.println(minusInfinity == minusInfinity); // true
	System.out.println(NaN == NaN); // false
	System.out.println();

	System.out.println(infinity > minusInfinity); // true
	System.out.println(infinity < minusInfinity); // false
	System.out.println(NaN > 1); // false
	System.out.println(NaN < 1); // false
	}

B⁺树

2022-10-08T11:13:20.000Z

# 简介

# 适合范围

大量数据存储在外部存储器（磁盘等），例如：文件系统，MySQL 索引等。
因为外部存储器 I／O 速度比较慢，如果使用二叉搜索树算法，其树的深度又比较高，则增加了读取数据的次数，从而增加了执行的时间。

# 局部性原理

访问磁盘中的数据，其附近的数据也将会被访问。
因为程序中的数据一般是集中存放的，所以通过预先读取数据，一般为按页读取，这样就减少读取磁盘的次数，从而减少执行的时间。

# B⁺ 树的特点

非叶子节点只存放 router（相当于 key，与叶子节点 key 区分），叶子节点存放 key 和数据。
叶子节点 x 的 nextNode 引用下一个叶子节点，把所有叶子节点通过链表连接起来。
key 的个数与度（degree）的关系: $n_k = degree - 1$ 。
从根节点到叶节点的每条路径的树高都一样。
除了根节点，其余所有节点包含 key 的数量至少满一半。

# B⁺ 树结构

非叶子节点 x 的字段：

x.n 当前存放 router 的个数；
x.routers 按升序存放： $x.router_1 < x.router_2 < \; ... \; < x.router_n$ ；
x.leaf = false，表明该节点是非叶子节点；
x.children，n + 1 个孩子节点的指针： $x.c_1, x.c_2, ... , x.c_n$ 。

叶子节点 x 的字段：

x.n 当前存放 key 的个数；
x.keys 按升序存放： $x.key_1 < x.key_2 < \; ... \; < x.key_n$ ；
x.leaf = true，表明该节点是叶子节点。

非叶子节点的 routers 和孩子节点的 key 关系：

$key_1 \leq x.router_1 < key_2 \leq x.router_2 < key_3 \; ... \; < key_n \leq x.router_n < key_{n + 1}$

# 搜索

从根节点开始搜索：

如果 x 是非叶子节点，则 key 与第一个 $x.router_i$ 比较，如果 $key \leq x.router_i$ ，则从 $x.c_i$ 孩子节点中搜索；
如果所有的 router 都比 key 小，则从最后一个孩子节点中搜索；
如果 x 是叶子节点，就从 x.keys 里面查询是否存在该元素。

下面是 java 部分关键代码：

	public D search(K key) {
	return search(root, key);
	}

	private D search(Node<K, D> node, K key) {
	if (node == null) {
	return null;
	}

	// find position
	int pos = getLocation(node, key);

	// search in leaf node
	if (node.isLeaf) {
	if (key.compareTo(node.keys[pos]) == 0) {
	return node.dataList[pos];
	}
	// not found
	return null;
	}

	// search in non-leaf node
	return search(node.children[pos], key);
	}

	private int getLocation(Node<K, D> node, K key) {
	int pos = 0;
	while (pos < node.keyLength && key.compareTo(node.keys[pos]) > 0) {
	pos++;
	}
	return pos;
	}

# 时间复杂度

$O(t \cdot log_tn)$

# 插入

从根节点开始搜索，直到找到适合的叶子节点 y，先搜索 key 在叶子节点的位置，在叶子节点中插入：
如果叶子节点 y 还有剩余位置，则在对应位置直接插入 key 和对应的数据，操作完成。
否则，如果叶子节点 y 已经满了，则需要分裂该节点：

分配新的节点 z；
将节点 y 的前面一半保留在节点 y；
将节点 y 的后面一半移到新节点 z；
key 的插入，看 key 的大小，再决定插在 y 还是 z；
y 节点的 nextNode 指针指向 z 节点；选取 y 节点的最后一个 $y.key_{last}$ 和新节点 z，插入父节点 x，x 节点是 y 和 z 的父节点；设置 z 节点的父节点；
如果父节点也不够空间，则继续分裂，最坏的情况就是，叶子节点到根节点的路径上所有节点都需要分裂。

在非叶子节点的分裂，因为 router 的个数比孩子节点少 1 个，所以节点分裂时，就多出一个 router，因此，把这个多余的 router 和新节点插入到父节点上：

将多余的 router 直接移除，添加到父节点上；非叶子节点分离时，children 也会被分离，需要更新移到右边的 children 的 parent；children 比 router 移动多 1 个。

⚠️ 非叶子节点分裂时，children 的 parent 发生变化，children 的 parent 需要更新。

# 时间复杂度

$O(t \cdot log_tn)$

# 删除

先搜索到叶节点，在叶节点中删除命中的元素。

在叶子节点中删除 key，如果删除后，key 的数量没有少于一半，则删除步骤结束。
如果删除 key 后，key 的数量少于一半，则需要将树重新平衡。

# 参考

B⁺ - trees, Kerttu Pollari-Malmi

2-3-4树

2022-10-05T09:13:20.000Z

# 定义

2-3-4 树是多路搜索树；4 阶的 B 树；所有结点有序
是一棵自平衡树；每个叶子结点的深度一样、完美平衡。
叶子结点除外，内部结点只能是：2 结点、3 结点、4 结点

# 结点类型

2 结点：1 个元素，2 个子结点

3 结点：2 个元素，3 个子结点

4 结点：3 个元素，4 个子结点

# 插入

插入操作都是在叶子结点进行合并或分裂。

# 插入情形

2 - 结点、3 - 结点：直接合并（nodeMerge）
4 - 结点：分裂（nodeSplit）
a. 4 - 结点先分裂，插入结点再和左、右子结点合并
b. 分裂后的结点继续向上合并或再分裂

# 代码实现

# 类结构

TwoFourTree 对象结构：

	@SuppressWarnings({ "unchecked", "rawtypes", "hiding" })
	public class TwoFourTree<K extends Comparable<K>, V> {
	// 2-3-4 树是阶为 4 的 B 树
	private static final int ORDER = 4;

	// 结点最多元素个数
	private static final int MAX_SIZE = 3;

	private Node<K, V> root;

	private int size = 0;

	// 创建 key 数组的类型，泛型数组创建需要通过反射机制
	private Class<?> keyclass;
	// 创建 value 数组的类型，泛型数组创建需要通过反射机制
	private Class<?> valueclass;

	public TwoFourTree(Class<?> keyClass, Class<?> valueClass) {
	this.keyclass = keyClass;
	this.valueclass = valueClass;
	}

	// ......
	}

Node 对象结构：

	private class Node<K extends Comparable<K>, V> {
	// 父结点
	Node parent;
	// 结点的子树
	Node[] children = new Node[ORDER];

	// 结点的元素（key，value），以及元素个数
	K[] keys = (K[]) Array.newInstance(keyclass, MAX_SIZE);
	V[] values = (V[]) Array.newInstance(valueclass, MAX_SIZE);
	int size;

	private Node(Node parent, K key, V value) {
	this.parent = parent;
	size = 1;
	keys[0] = key;
	values[0] = value;
	}

	// for gc, unbind connected obj
	private void delete() {
	parent = null;
	children = null;
	keys = null;
	values = null;
	size = 0;
	}
	}

# 结点合并

	private Node nodeMerge(Node node, Node insertNode, int instIdx) {
	if (instIdx < node.size) {
	// 数组元素往后移动 1 格，腾出插入空间
	moveElement(node, instIdx, node, instIdx + 1, node.size - instIdx);
	//instIdx 位置的子结点被替换；instIdx+1 位置需要插入新的子结点
	moveChild(node, instIdx + 1, node, instIdx + 2, node.size - instIdx);
	}

	// 插入元素
	moveElement(insertNode, 0, node, instIdx);
	// 插入 2 个新的子结点
	moveChild(insertNode, 0, node, instIdx, 2);
	// 结点元素个数 + 1
	node.size++;

	// 删除插入结点
	insertNode.delete();
	return node;
	}

# 结点分裂

	private Node nodeSplit(Node node, Node insertNode, int instIdx) {
	// 分裂 4 - 结点：中间元素成为父结点，两边元素成为（左 / 右）子结点
	Node split2Parent, split2Left, split2Right;
	// 分裂出父结点
	split2Parent = new Node(node.parent, node.keys[1], node.values[1]);

	// 分裂出右子结点
	split2Right = new Node(split2Parent, node.keys[2], node.values[2]);
	moveChild(node, 2, split2Right, 0, 2);

	// 分裂出左子结点
	split2Left = node;
	split2Left.size = 1;
	split2Left.parent = split2Parent;

	// 设置分裂父结点的 2 个子结点
	split2Parent.children[0] = split2Left;
	split2Parent.children[1] = split2Right;

	// 插入结点再与左右子结点合并
	if (instIdx < 2) {
	// instIdx = 0, 1 [0-left or 1-right]
	nodeMerge(split2Left, insertNode, instIdx);
	} else {
	// instIdx = 2, 3 [0-left or 1-right]
	// instIdx - 2 = 0, 1
	nodeMerge(split2Right, insertNode, instIdx - 2);
	}

	return split2Parent;
	}

# 元素迁移，孩子结点迁移

	private void moveElement(Node oldNode, int oldIdx, Node newNode, int newIdx) {
	System.arraycopy(oldNode.keys, oldIdx, newNode.keys, newIdx, 1);
	System.arraycopy(oldNode.values, oldIdx, newNode.values, newIdx, 1);
	}

	private void moveElement(Node oldNode, int oldIdx, Node newNode, int newIdx, int size) {
	System.arraycopy(oldNode.keys, oldIdx, newNode.keys, newIdx, size);
	System.arraycopy(oldNode.values, oldIdx, newNode.values, newIdx, size);
	}

	private void moveChild(Node oldParent, int oldChildIdx, Node newParent, int newChildIdx) {
	// jvm: -ea
	assert oldChildIdx < ORDER && newChildIdx < ORDER
	: "child's position out-of-bounds. " + oldChildIdx + ", " + newChildIdx;

	System.arraycopy(oldParent.children, oldChildIdx, newParent.children, newChildIdx, 1);

	// update child's parent
	if (newParent.children[newChildIdx] != null) {
	newParent.children[newChildIdx].parent = newParent;
	}
	}

	private void moveChild(Node oldParent, int oldChildIdx, Node newParent, int newChildIdx, int size) {
	// jvm: -ea
	assert oldChildIdx < ORDER && newChildIdx < ORDER
	: "child's position out-of-bounds. " + oldChildIdx + ", " + newChildIdx;

	System.arraycopy(oldParent.children, oldChildIdx, newParent.children, newChildIdx, size);

	for (int i = 0; i < size; i++) {
	// update child's parent
	if (newParent.children[newChildIdx + i] != null) {
	newParent.children[newChildIdx + i].parent = newParent;
	}
	}
	}

# 插入

	public V put(K key, V value) {
	if (key == null) {
	throw new IllegalArgumentException("key can not be null.");
	}

	// 查找插入的结点，以及结点的插入位置
	Node node = null;
	int i = 0;
	Node p = root;
	while (p != null) {
	i = 0;
	node = p;
	for (i = 0; i < p.size; i++) {
	int cmp = key.compareTo((K) p.keys[i]);
	if (cmp < 0) {
	p = p.children[i];
	break;
	} else if (cmp > 0 && i == p.size - 1) {
	i++;
	p = p.children[i];
	break;
	} else if (cmp == 0) { // updated
	V oldValue = (V) p.values[i];
	p.values[i] = value;
	return oldValue;
	}
	}
	}

	// 0. 根结点
	if (node == null) {
	root = new Node<K, V>(null, key, value);
	size++;
	return null;
	}

	Node insertNode = new Node(node.parent, key, value);
	// 1. 4 - 结点分裂
	while (node.size == MAX_SIZE) {
	// 结点分裂
	node = nodeSplit(node, insertNode, i);

	// 1_1. 根结点分裂，更新 root
	if (node.parent == null) {
	root = node;
	size++;
	return null;
	}

	// 分裂的结点递归向上合并或再分裂
	insertNode = node;
	node = insertNode.parent;

	// 找出向上合并或再分裂的插入位置
	for (i = 0; i < node.size; i++) {
	int cmp = insertNode.keys[0].compareTo(node.keys[i]);
	if (cmp < 0) {
	break;
	} else if (cmp > 0 && i == node.size - 1) {
	i++;
	break;
	}
	}
	// 结点分裂新的结点，需要更新新的结点
	node.children[i] = insertNode;
	}

	// 2. 2 - 结点、3 - 结点直接合并
	nodeMerge(node, insertNode, i);
	size++;
	return null;
	}

# 删除

都是在叶子结点中删除（非叶子结点转化为叶子结点情形）
叶子结点元素多，则直接删除；不够则向兄弟借，兄弟不够向父辈借
树的高度降低只发生在：根结点为 2 - 结点，且孩子结点均为 2 - 结点时，合并结点导致的

# 删除情形

# 内部结点（非叶子结点）

找前驱或后继元素，转化为删除叶子结点。

# 叶子结点

富有 / 只有一个根结点：直接删除元素
贫穷但兄弟结点富有：向兄弟借元素
贫穷且兄弟结点也贫穷，但父结点富有：合并（fuse）
贫穷且兄弟结点、父结点都贫穷，均为 2 - 结点：
a. 合并然后递归向上再合并（直到根结点结束）

b. 合并然后向上向借元素

# 代码实现

# borrow

	private void borrow(Node node, int childIdx) {
	Node parent = node.parent;
	if (childIdx == 0) {
	Node rightSiblings = parent.children[childIdx + 1];
	moveElement(parent, 0, node, 0);
	moveChild(rightSiblings, 0, node, 1);
	node.size = 1;
	moveElement(rightSiblings, 0, parent, 0);
	moveElement(rightSiblings, 1, rightSiblings, 0, rightSiblings.size - 1);
	moveChild(rightSiblings, 1, rightSiblings, 0, rightSiblings.size);
	rightSiblings.size--;
	} else {
	Node leftSiblings = parent.children[childIdx - 1];
	moveElement(parent, childIdx - 1, node, 0);
	moveChild(node, 0, node, 1);
	moveChild(leftSiblings, leftSiblings.size, node, 0);
	node.size = 1;
	moveElement(leftSiblings, leftSiblings.size - 1, parent, childIdx - 1);
	leftSiblings.size--;
	}
	}

# fuse

	private void fuse(Node node, int childIdx) {
	Node parent = node.parent;
	if (childIdx == 0) {
	Node rightSiblings = parent.children[childIdx + 1];
	moveElement(parent, 0, node, 0);
	moveElement(rightSiblings, 0, node, 1);
	moveChild(rightSiblings, 0, node, 1, rightSiblings.size + 1);
	node.size = 2;

	parent.children[childIdx + 1] = null;
	if (parent.size > 1) {
	moveElement(parent, 1, parent, 0, parent.size - 1);
	moveChild(parent, 2, parent, 1, parent.size - 1);
	}

	parent.size--;
	rightSiblings.delete();
	} else {
	Node leftSiblings = parent.children[childIdx - 1];
	moveElement(parent, childIdx - 1, leftSiblings, leftSiblings.size);
	moveChild(node, 0, leftSiblings, leftSiblings.size + 1);
	leftSiblings.size = 2;

	parent.children[childIdx] = null;
	if (childIdx < parent.size) {
	moveElement(parent, childIdx, parent, childIdx - 1, parent.size - childIdx);
	moveChild(parent, childIdx + 1, parent, childIdx, parent.size - childIdx);
	}

	node.delete();
	parent.size--;
	}
	}

# isLeaf

	private boolean isLeaf(Node node) {
	if (node == null \|\| node.size == 0) {
	return true;
	}

	return node.children[0] == null;
	}

# getIndexInParent

Node 对象的方法：获取结点 node 在父结点 children 数组的下标。例如：node.getIndexInParent ()。用于删除结点操作中，需要根据 node 的位置进行调整。

	private int getIndexInParent() {
	for (int index = 0; index < parent.size + 1; index++) {
	if (parent.children[index] == this) {
	return index;
	}
	}
	// should not reach here.
	return -1;
	}

# underflow

结点元素不富有，需要借元素时，称为下溢出（underflow）。

下溢出的处理包括：删除情形③、④、⑤，即：向兄弟借、与父结点合并、向上合并 / 向上借元素。

	private void underflow(Node node) {
	while (true) {
	Node parent = node.parent;
	int childIdx = node.getIndexInParent();

	// 兄弟有的借
	if (childIdx == 0 && parent.children[childIdx + 1].size > 1) {
	borrow(node, childIdx);
	return;
	} else if (childIdx > 0 && parent.children[childIdx - 1].size > 1) {
	borrow(node, childIdx);
	return;
	}
	// 兄弟没得借但父亲有的借：合并
	if (parent.size > 1) {
	fuse(node, childIdx);
	return;
	}
	// 兄弟父亲都没得借：合并，然后向上递归
	// parent.size == 1
	fuse(node, childIdx);
	// cascade up the tree
	node = parent;

	// 根结点降低树高
	if (node == root) {
	root = node.children[0];
	root.parent = null;
	node.delete();
	return;
	}
	}
	}

# remove

getNode 方法参见：查找

	public V remove(K key) {
	if (key == null) { // key invalid
	throw new IllegalArgumentException("key can not be null.");
	}

	Pair<Integer, Node> pair = getNode(key);
	if (pair == null) { // key not found
	return null;
	}

	Node delElemInNode = pair.value;
	int delElemIdx = pair.key;

	V returnValue = (V) delElemInNode.values[delElemIdx];

	// 1. 非叶子结点情形
	if (!isLeaf(delElemInNode)) {
	// 获取后驱结点：右兄弟结点的最左子树
	Node successor = delElemInNode.children[delElemIdx + 1];
	// 沿着最左子树遍历
	while (!isLeaf(successor)) { // successor.children[0] != null
	successor = successor.children[0];
	}

	// swap
	moveElement(successor, 0, delElemInNode, delElemIdx);
	// 转化为删除叶子结点情形
	delElemInNode = successor;
	delElemIdx = 0;
	}

	//------------ 叶子结点情形 ------------

	// 2. 结点富有 [2 - 结点、3 - 结点] 或仅有根结点一个结点：直接移除元素
	if (delElemInNode.size > 1 \|\| delElemInNode == root) {
	// 删除元素
	moveElement(delElemInNode, delElemIdx + 1, delElemInNode, delElemIdx,
	delElemInNode.size - delElemIdx - 1);
	delElemInNode.size--;
	// tree empty
	if (delElemInNode.size == 0) {
	root = null;
	delElemInNode.delete();
	}
	size--;
	return returnValue;
	}

	// 3. 结点贫穷：借元素或合并结点
	underflow(delElemInNode);

	size--;
	return returnValue;
	}

# 查找

	// 用于 return 返回 2 个值时的包装，
	// 例如：因为结点包含多个元素、子结点，需要获取元素值、以及下标位置
	private static class Pair<K, V> {
	K key;
	V value;

	public Pair(K key, V value) {
	this.key = key;
	this.value = value;
	}
	}

	// 根据 key 获取值
	public V get(K key) {
	if (key == null) {
	throw new IllegalArgumentException("key can not be null.");
	}

	// 元素下标，结点
	Pair<Integer, Node> pair = getNode(key);
	return pair == null ? null : (V) pair.value.values[pair.key];
	}

	// 返回结点，以及元素在结点内的下标
	private Pair<Integer, Node> getNode(K key) {
	Node p = root;
	// 查找
	while (p != null) {
	for (int i = 0; i < p.size; i++) {
	int cmp = key.compareTo((K) p.keys[i]);
	if (cmp < 0) {
	p = p.children[i];
	break;
	} else if (cmp > 0 && i == p.size - 1) {
	p = p.children[i + 1];
	break;
	} else if (cmp == 0) {
	// 返回结点，以及元素在结点内的下标
	return new Pair<>(i, p);
	}
	}
	}
	// not found
	return null;
	}

# 空间复杂度

平均、最差： $O(n)$

# 时间复杂度

搜索、插入、删除，平均和最差都是： $O(\log n)$

# 缺点

代码实现复杂，需要考虑：结点的数据结构、操作结点时需要考虑数组的下标位置、元素和结点在数组中移动等。
需要使用多种数据结构：结点之间的关系 [链表 + 数组]、结点内的元素 [数组]。

二叉搜索树（Binary Search Tree）

2022-10-02T12:19:20.000Z

# 定义

是一棵二叉树；每个结点都有一个可比较的键，以及关联的值。
任何结点中的键大于该结点左子树中所有结点中的键，且小于该结点右子树中所有结点的键（有序性）

# 遍历

主要讨论的是深度遍历，根据根结点的访问优先级，又可以分为：前（先）、中、后序遍历。

获取结点的前驱后继时，需要用到这部分知识点，而且平衡树的调整操作中也涉及到。

# 前序遍历

前（先）序遍历（Pre-Order Traversal）：先根结点，再左右子树。

# 中序遍历

中序遍历（In-Order Traversal）：先左子树，再根结点，最后右子树。

# 后序遍历

后序遍历（Post-Order Traversal）：先左右子树，再根结点。

# 代码实现：递归

# 前序遍历

	public void preOrderTraversalRecursion(Node node, List<K> result) {
	if (node == null) {
	return;
	}
	// 先根结点
	result.add((K) node.key);
	// 再左右子树
	if (node.left != null) {
	preOrderTraversalRecursion(node.left, result);
	}
	if (node.right != null) {
	preOrderTraversalRecursion(node.right, result);
	}
	}

# 中序遍历

	public void inOrderTraversalRecursion(Node node, List<K> result) {
	if (node == null) {
	return;
	}
	// 先左子树
	if (node.left != null) {
	inOrderTraversalRecursion(node.left, result);
	}
	// 再根结点
	result.add((K) node.key);
	// 后右子树
	if (node.right != null) {
	inOrderTraversalRecursion(node.right, result);
	}
	}

# 后序遍历

	public void postOrderTraversalRecursion(Node node, List<K> result) {
	if (node == null) {
	return;
	}
	// 先左子树
	if (node.left != null) {
	postOrderTraversalRecursion(node.left, result);
	}
	// 再右子树
	if (node.right != null) {
	postOrderTraversalRecursion(node.right, result);
	}
	// 后根结点
	result.add((K) node.key);
	}

# 代码实现：非递归

# 前序遍历

实现关键：

使用栈结构，根结点入栈；循环条件：栈非空。
出栈访问结点，右、左子树入栈

	public void preOrderTraversalCirculation(Node root, List<K> result) {
	if (root == null) {
	return;
	}

	Deque<Node> stack = new ArrayDeque<>();

	// 1. 根结点入栈
	stack.push(root);
	// 2. 循环条件：栈非空
	while (!stack.isEmpty()) {
	// 3. 出栈访问根结点
	Node p = stack.pop();
	// 先访问根结点
	result.add((K) p.key);

	// 4. 再把右结点入栈：先进后出
	if (p.right != null) {
	stack.push(p.right);
	}
	// 5. 最后把左结点入栈：后进先出
	if (p.left != null) {
	stack.push(p.left);
	}
	}
	}

# 中序遍历

实现关键：

使用栈结构，p 指向根结点
循环条件栈或 p 非空；遍历 p 左子树，遍历期间 p 入栈；出栈访问结点，p 指向右子树

	public void inOrderTraversalCirculation(Node root, List<K> result) {
	if (root == null) {
	return;
	}

	Deque<Node> stack = new ArrayDeque<>();
	Node p = root;

	// 1. p 用于循环遍历左子树
	// 2. stack 用于回溯，记录 p 指针经过的结点
	while (!stack.isEmpty() \|\| p != null) {
	// 访问最左边的左结点，栈记录经过的结点，用于回溯
	while (p != null) {
	stack.push(p);
	p = p.left;
	}

	// 出栈的结点，左子树都是已访问的
	p = stack.pop();
	// 访问中间结点
	result.add((K) p.key);

	// 循环访问右结点
	p = p.right;
	}
	}

# 后序遍历

# 双栈实现

实现关键：

双栈结构，根结点入栈 1
循环条件栈 1 非空，栈 1 出栈入栈 2，左、右子树入栈 1
栈 2 依次出栈访问结点

	public void postOrderTraversalCirculation1(Node root, List<K> result) {
	if (root == null) {
	return;
	}

	Deque<Node> stack1 = new ArrayDeque<>();
	Deque<Node> stack2 = new ArrayDeque<>();

	stack1.push(root);
	while (!stack1.isEmpty()) {
	Node node = stack1.pop();
	stack2.push(node);

	if (node.left != null) {
	stack1.push(node.left);
	}
	if (node.right != null) {
	stack1.push(node.right);
	}
	}

	while (!stack2.isEmpty()) {
	result.add((K) stack2.pop().key);
	}
	}

# 单栈实现

实现关键：

栈结构，p 指向 root，p 入栈
循环条件栈非空；查看栈顶结点

	public void postOrderTraversalCirculation2(Node root, List<K> result) {
	if (root == null) {
	return;
	}

	Deque<Node> stack = new ArrayDeque<>();
	Node p = root;
	stack.push(p);
	while (!stack.isEmpty()) {
	Node node = stack.peek();

	// 因为先访问底层，再访问上一层，所以直接判断左右子树是否等于 p
	boolean finishedSubtrees = (node.right == p \|\| node.left == p);
	boolean isLeaf = (node.left == null && node.right == null);

	// 如果左右子树已经访问，或是叶子结点，直接访问
	if (finishedSubtrees \|\| isLeaf) {
	stack.pop();
	result.add((K) node.key);
	p = node;
	} else { // 否则把右左子树入栈
	if (node.right != null) {
	stack.push(node.right);
	}
	if (node.left != null) {
	stack.push(node.left);
	}
	}
	}
	}

# 前驱后继

# 定义

# 前驱

比该结点的键小且最大的结点。

该结点有左子树：沿着左结点的右子树；循环到结点没有右子树，则该结点是前驱结点（左结点最右子树）。
该结点没有左子树：沿着祖先结点往上查；循环到祖先结点的右结点等于上一轮循环的结点（查祖辈且出现拐角）。

# 后继

比该结点的键大且最小的结点。

该结点有右子树：沿着右结点的左子树；循环到结点没有左子树，则该结点是前驱结点（右结点最左子树）。
该结点没有右子树：沿着父结点往上查；循环到祖先结点的左结点等于上一轮循环的结点（查祖辈且出现拐角）。

# 代码实现

# 前驱

Node 对象没有定义 parent 指针，无法向上遍历，因此需要借助栈记录祖先结点，然后通过栈回溯祖先结点。

如果 Node 定义 parent 属性，则很容易向上遍历，不需要借助栈回溯。

	public Node predecessor(K key) {
	if (key == null) {
	throw new IllegalArgumentException("key can not be null.");
	}

	// 栈用于辅助回溯祖先结点；查找结点位置时，记录经过的祖先结点
	// 如果 Node 对象有 parent 指针时，则不需要额外的栈来向上查询祖先结点
	Deque<Node> stack = new ArrayDeque<>();
	Node p = root;
	// 找到结点位置
	while (p != null) {
	int cmp = key.compareTo((K) p.key);
	if (cmp < 0) {
	// 记录父结点
	stack.push(p);
	p = p.left;
	} else if (cmp > 0) {
	// 记录父结点
	stack.push(p);
	p = p.right;
	} else {
	// 找到结点
	break;
	}
	}
	// 0. 没找到结点
	if (p == null) {
	return null;
	}
	// 1. 有左子树：前驱结点在左结点的最右子树下
	if (p.left != null) {
	p = p.left;
	while (p.right != null) {
	p = p.right;
	}
	return p;
	}
	// 2. 没有左子树：借助栈回溯祖先结点；因为 Node 没有 parent 指针，无法向上遍历父结点
	while (!stack.isEmpty()) {
	// 回溯祖先结点
	Node q = stack.pop();
	/* q -> 6
	* \
	* 9 <- p
	* /
	* 8 key
	*/
	if (q.right == p) {
	return q;
	} else {
	p = q;
	}
	}
	// 3. 没有前驱结点
	return null;
	}

# 后继

借助栈记录祖先结点，然后通过栈回溯祖先结点。

	public Node successor(K key) {
	if (key == null) {
	throw new IllegalArgumentException("key can not be null.");
	}
	// 栈用于辅助回溯祖先结点；查找结点位置时，记录经过的祖先结点
	// 如果 Node 对象有 parent 指针时，则不需要额外的栈来向上查询祖先结点
	Deque<Node> stack = new ArrayDeque<>();
	Node p = root;
	// 找到结点位置
	while (p != null) {
	int cmp = key.compareTo((K) p.key);
	if (cmp < 0) {
	// 记录父结点
	stack.push(p);
	p = p.left;
	} else if (cmp > 0) {
	// 记录父结点
	stack.push(p);
	p = p.right;
	} else {
	// 找到结点
	break;
	}
	}
	// 0. 没找到结点
	if (p == null) {
	return null;
	}
	// 1. 有右子树：后继结点在右结点的最左子树下
	if (p.right != null) {
	p = p.right;
	while (p.left != null) {
	p = p.left;
	}
	return p;
	}
	// 2. 没有右子树：借助栈回溯祖先结点；因为 Node 没有 parent 指针，无法向上遍历父结点
	while (!stack.isEmpty()) {
	// 回溯祖先结点
	Node q = stack.pop();
	/* q -> 8
	* /
	* 5 <- p
	* \
	* 6 key
	*/
	if (q.left == p) {
	return q;
	} else {
	p = q;
	}
	}
	// 3. 没有后继结点
	return null;
	}

# 插入

# 插入情形

根结点为 null，未初始化：创建新结点，直接赋值给 root。
在左 / 右结点为 null 的位置插入。

# 代码实现

	public V put(K key, V value) {
	if (key == null) {
	throw new IllegalArgumentException("key can not be null.");
	}

	//p 指针用于遍历，寻找插入位置
	Node p = root;
	//parent 指针用于记录插入位置的父结点
	Node parent = null;
	while (p != null) {
	int cmp = key.compareTo((K) p.key);
	if (cmp < 0) {
	parent = p;
	p = p.left;
	} else if (cmp > 0) {
	parent = p;
	p = p.right;
	} else { // 更新
	V oldValue = (V) p.value;
	p.value = value;
	// 返回旧值
	return oldValue;
	}
	}

	// 1. 根结点初始化（第一次插入）：parent 为空
	if (parent == null) {
	root = new Node(key, value);
	return null;
	}
	// 2. 在左 / 右结点插入：
	if (key.compareTo((K) parent.key) < 0) {
	parent.left = new Node(key, value);
	} else {
	parent.right = new Node(key, value);
	}
	return null;
	}

# 删除

# 删除情形

删除结点有左 + 右子树：转化为后 2 种情形。
删除叶子结点：直接删除。
删除只有一个子树的结点：删除结点的子树挂到父结点下。

# 代码实现

	public V remove(K key) {
	if (key == null) {
	throw new IllegalArgumentException("key can not be null.");
	}

	//parent 指针记录删除结点的父结点
	Node parent = null;
	//p 指针查询删除结点位置
	Node p = root;
	while (p != null) {
	int cmp = key.compareTo((K) p.key);
	if (cmp < 0) {
	parent = p;
	p = p.left;
	} else if (cmp > 0) {
	parent = p;
	p = p.right;
	} else {
	break;
	}
	}

	// 0. 没找到结点
	if (p == null) {
	return null;
	}

	// 删除结点后返回旧值
	V oldValue = (V) p.value;

	// 1. 有 2 个子树的结点：找到后继结点替换，然后删除后继结点
	// 转化为：a. 删除叶子结点；b. 只有一个子树的结点
	if (p.left != null && p.right != null) {
	Node q = p.right; // 在右子树下查找后继结点
	parent = p;
	while (q.left != null) {
	parent = q;
	q = q.left;
	}

	// 用后继结点替换删除结点
	p.key = q.key;
	p.value = q.value;

	// 转化为删除后继结点；后继结点：1. 只有一个子树；2. 没有子树（叶子结点）
	p = q;
	}

	// 2. 叶子结点：直接删除
	if (p.left == null && p.right == null) {
	// 2_1. 删除根结点，且只有一个结点
	if (parent == null) {
	root = null;
	return oldValue;
	}
	// 2_2. 叶子结点直接从父结点中移除，得判断是在左还是右结点
	if (parent.left == p) { //p 是删除结点
	parent.left = null;
	} else if (parent.right == p) {
	parent.right = null;
	}
	return oldValue;
	}

	// 3. 只有 1 个子树的结点：删除结点的子树挂到父结点下
	// 3_1. 删除的是根结点，但有一个子结点：子结点直接作为根结点
	if (parent == null) {
	root = p.left == null ? p.right : p.left;
	// for gc
	p.left = p.right = null;
	return oldValue;
	}
	// 3_2. 删除的是非根结点：子树直接移到父结点的左 / 右孩子下
	if (parent.left == p) { //p 是删除结点
	parent.left = p.left != null ? p.left : p.right;
	} else {
	parent.right = p.left != null ? p.left : p.right;
	}
	// for gc
	p.left = p.right = null;
	return oldValue;
	}

# 查找

	public V get(K key) {
	if (key == null) {
	throw new IllegalArgumentException("key can not be null.");
	}

	Node node = getNode(key);
	return node == null ? null : (V) node.value;
	}

	public Node getNode(K key) {
	Node p = root;
	while (p != null) {
	int cmp = key.compareTo((K) p.key);
	if (cmp < 0) {
	p = p.left;
	} else if (cmp > 0) {
	p = p.right;
	} else {
	return p;
	}
	}
	return null;
	}

# 空间复杂度

平均、最差： $O(n)$

# 时间复杂度

搜索、插入、删除，平均： $O(\log n)$
搜索、插入、删除，最差： $O(n)$

# 缺点

数据倾斜，退化为链表，时间复杂度最差： $O(n)$

SHA256 [RFC-4634]

2021-08-01T11:50:45.000Z

# 基础

输入最大消息长度： $2^{64}$ bits
输出：256 bits
大端 (Big endian) 为主
word = 32 bits;
block = 512 bit, 16 words;

# 位操作符号

w = length of word.

SHR 右移
ROTR 循环右移
ROTL 循环左移

	SHR^n(x) = x>>n

	ROTR^n(x) = (x>>n) OR (x<<(w-n))

	ROTL^n(x) = (x<<n) OR (x>>(w-n))

	ROTL^n(x) = ROTR^(w-n)(x)

	ROTR^n(x) = ROTL^(w-n)(x)

# 填充

原长度 L
填充 1
填充 K 个 0：L + 1 + K = 448 (mod 512)
结尾 64 bits 作为原长度的二进制表示。因此决定输入消息的长度。

# 函数

	CH( x, y, z) = (x AND y) XOR ( (NOT x) AND z)

	MAJ( x, y, z) = (x AND y) XOR (x AND z) XOR (y AND z)

	BSIG0(x) = ROTR^2(x) XOR ROTR^13(x) XOR ROTR^22(x)

	BSIG1(x) = ROTR^6(x) XOR ROTR^11(x) XOR ROTR^25(x)

	SSIG0(x) = ROTR^7(x) XOR ROTR^18(x) XOR SHR^3(x)

	SSIG1(x) = ROTR^17(x) XOR ROTR^19(x) XOR SHR^10(x)

# 常量

64 个 32 位常量： $K0, K1, ..., K63$

前 64 个素数的立方根的双精度浮点数小数部分的前 32 位的 16 进制

例如：

cube root(2) = 1.25992104989
双精度浮点数，符号位（1）+ 指数（11）+ 小数（52）

	0 01111111111
	0100 0010 1000 1010 0010 1111 1001 1000
	11010001110011010000

前 32 位的 16 进制表达

	0100 0010 1000 1010 0010 1111 1001 1000

	4 2 8 a 2 f 9 8

	428a2f98 71374491 b5c0fbcf e9b5dba5
	3956c25b 59f111f1 923f82a4 ab1c5ed5
	d807aa98 12835b01 243185be 550c7dc3
	72be5d74 80deb1fe 9bdc06a7 c19bf174
	e49b69c1 efbe4786 0fc19dc6 240ca1cc
	2de92c6f 4a7484aa 5cb0a9dc 76f988da
	983e5152 a831c66d b00327c8 bf597fc7
	c6e00bf3 d5a79147 06ca6351 14292967
	27b70a85 2e1b2138 4d2c6dfc 53380d13
	650a7354 766a0abb 81c2c92e 92722c85
	a2bfe8a1 a81a664b c24b8b70 c76c51a3
	d192e819 d6990624 f40e3585 106aa070
	19a4c116 1e376c08 2748774c 34b0bcb5
	391c0cb3 4ed8aa4a 5b9cca4f 682e6ff3
	748f82ee 78a5636f 84c87814 8cc70208
	90befffa a4506ceb bef9a3f7 c67178f2

# 最终输出

+ 为字符串拼接

H(N) = H(N)0 + H(N)1 + ... + H(N)7

# 初始化

前 8 个素数的平方根的双精度浮点数小数部分的前 32 位的 16 进制

和前面类似，不过是平方根。
例如：

square root(2) = 1.41421356237
二进制

	0 01111111111
	0110 1010 0000 1001 1110 0110 0110 0111
	11110000010101011010

十六进制

	0110 1010 0000 1001 1110 0110 0110 0111
	6 a 0 9 e 6 6 7

	H(0)0 = 6a09e667
	H(0)1 = bb67ae85
	H(0)2 = 3c6ef372
	H(0)3 = a54ff53a
	H(0)4 = 510e527f
	H(0)5 = 9b05688c
	H(0)6 = 1f83d9ab
	H(0)7 = 5be0cd19

# 处理

	For i = 1 to N
	1. Prepare the message schedule W:
	For t = 0 to 15
	Wt = M(i)t
	For t = 16 to 63
	Wt = SSIG1(W(t-2)) + W(t-7) + SSIG0(t-15) + W(t-16)
	2. Initialize the working variables:
	a = H(i-1)0
	b = H(i-1)1
	c = H(i-1)2
	d = H(i-1)3
	e = H(i-1)4
	f = H(i-1)5
	g = H(i-1)6
	h = H(i-1)7
	3. Perform the main hash computation:
	For t = 0 to 63
	T1 = h + BSIG1(e) + CH(e,f,g) + Kt + Wt
	T2 = BSIG0(a) + MAJ(a,b,c)
	h = g
	g = f
	f = e
	e = d + T1
	d = c
	c = b
	b = a
	a = T1 + T2
	4. Compute the intermediate hash value H(i):
	H(i)0 = a + H(i-1)0
	H(i)1 = b + H(i-1)1
	H(i)2 = c + H(i-1)2
	H(i)3 = d + H(i-1)3
	H(i)4 = e + H(i-1)4
	H(i)5 = f + H(i-1)5
	H(i)6 = g + H(i-1)6
	H(i)7 = h + H(i-1)7

	最后输出 H(N)，i -> N 轮

Java 7 Concurrency Cookbook

2020-04-13T06:09:29.000Z

# 线程的管理

# 线程的创建和运行

继承 Thread，重写 run 方法并执行 start 方法。
实现 Runnable 接口的 run 方法，并传递给 Thread 实例并执行 start 方法。

	// File1: 继承 Thread
	public class MyThread1 extends Thread {

	@Override
	public void run() {
	// do something!
	}

	public static void main(String[] args) {
	new MyThread1().start();
	}

	}

	// File2: 继承 Thread，匿名子类
	public class MyThread2 {

	public static void main(String[] args) {
	new Thread() {

	@Override
	public void run() {
	// do something!
	}

	}.start();
	}

	}

	// File3: 实现 Runnable
	public class MyRunnable1 implements Runnable {

	public void run() {
	// do something!
	}

	public static void main(String[] args) {
	Runnable r = new MyRunnable1();
	new Thread(r).start();
	}

	}

	// File4: 实现 Runnable，匿名子类
	public class MyRunnable2 {

	public static void main(String[] args) {
	Runnable r = new Runnable() {

	public void run() {
	// do something!
	}

	};
	new Thread(r).start();
	}

	}

# 获取和设置线程信息

ID：每个线程的独特标识；
Name：线程的名称；
Priority：线程对象的优先级。优先级别从低到高为 1-10 之间。设置后，不建议改变它们的优先级。
Status：线程的状态。在 Java 中，只有这 6 种：new，runnable，blocked，waiting，time waiting，terminated。

前提：Thread t = new Thread ();

t.getId() : long;
Name 的设置与获取
- new Thread(String name);
- new Thread(Thread t, String name);
- new Thread(Runnable r, String name);
- t.setName(String name);
- t.getName() : String;
设置与获取 Priority
- Thread.MAX_PRIORITY;
- Thread.MIN_PRIORITY;
- t.setPriority(int i);
- t.getPriority() : int;
State 是一个枚举类型，如：Thread.State.TIMED_WAITING
- t.getState() : Thread.State;

# 线程的中断

Thread t = new Thread();

检测是否中断：t.isInterrupted () : boolean;
任务中断：t.interrupt () : void;

	public class Interrupt implements Runnable {

	public void run() {
	while (true) {
	if (Thread.currentThread().isInterrupted()) {
	System.out.println("interrupted.");
	return;
	}
	System.out.println("It's not interrupted.");

	try {
	Thread.sleep(800L);
	} catch (InterruptedException e) {
	System.out.println("interrupted while this thread is sleep.");
	return;
	}
	}

	}

	public static void main(String[] args) {
	Runnable r = new Interrupt();
	Thread t = new Thread(r);
	t.start();

	try {
	Thread.sleep(5000L);
	t.interrupt();
	} catch (InterruptedException e) {
	e.printStackTrace();
	}
	}

	}

# 操作线程的中断机制

检测线程是否中断，如果中断，则可以抛出异常 InterruptedException，并捕获处理。Thread.sleep 操作就需要自己捕获异常并处理，参考上面的线程的中断代码里的 run。

# 线程的睡眠与唤醒

当你需要线程在一段时间后才执行，则可以让线程进入睡眠，睡眠这段时间消耗资源比较少。

Thread.sleep(long milliseconds);
TimeUnit.SECONDS.sleep (long seconds); 还有其它的时间单位。

# 等待线程的终结

Thread t = new Thread();

当前线程调用另外一个线程 t.join () 时，则当前线程会暂停，直到 t 线程完成了，才会继续运行。

join 还有另外几个方法：

t.join(long milliseconds);
- 等待线程 t 结束后，调用 join 的线程继续运行；
- 线程 t 还没结束，等待 milliseconds 后，调用 join 的线程直接继续运行。
t.join(long milliseconds, long nanos);
- 跟第一个一样，只不过可以精确到纳秒。

# 守护线程的创建与运行

线程分用户线程与守护线程，GC 就是一个守护线程；
守护线程优先级非常低，所以守护线程不能处理重要的任务；
用户线程都结束时，守护线程自动结束；
守护线程的设置 setDaemon 只能在 start 方法前调用，否则抛 IllegalThreadStateException 异常；
与其它线程一样，只不过是在 start 方法前调用 setDaemon (true)。

Thread t = new Thread();

t.setDaemon(boolean daemon);
t.isDaemon() : boolean;

# 在线程中处理不受控制的异常

Java 里有 2 种异常：

检查异常（Checked exceptions）: 这些异常必须强制捕获它们或在一个方法里的 throws 子句中。例如， IOException 或者 ClassNotFoundException。
未检查异常（Unchecked exceptions）: 这些异常不用强制捕获它们。例如， NumberFormatException, RuntimeException。

不用担心线程的检查异常，因为 run 不能 throws 异常，所以只能在 run 内部捕获并处理；

但 run 内部出现未检查异常，则需要进行下面处理：

实现 Thread.UncaughtExceptionHandler 的 uncaughtException 方法；
设置线程的未捕获异常处理器，setUncaughtExceptionHandler。

Thread 对未检查异常处理的顺序是：

检查线程是否有设置 handler；
如果没设置，则检查线程组有没有设置 handler；
如果没设置，则检查 Thread 有没有设置 setDefaultUncaughtExceptionHandler 全局默认 handler；
如果没有就将 stack trace 输出到控制台。

	// GlobalExceptionHandler.java
	public class GlobalExceptionHandler implements Thread.UncaughtExceptionHandler {

	public void uncaughtException(Thread thread, Throwable throwable) {
	// do something!
	}

	}

	// Test.java
	public class Test {

	public static void main(String[] args) {
	Thread t = new Thread() {
	@Override
	public void run() {
	// do something!
	}
	};
	// 设置未捕获异常处理器
	t.setUncaughtExceptionHandler(new GlobalExceptionHandler());
	t.start();
	}

	}

# 使用本地线程变量

# ThreadLocal

多线程共享同一个对象时，就会出现相互影响。可以使用本地线程变量，每个线程都会储存各自的副本。

	ThreadLocal<String> local = new ThreadLocal<String>() {
	@Override
	protected String initialValue() {
	return "initial value";
	}
	};

local.get() : <T>;
local.set(<T> value);
local.remove();

如果线程 A 里面创建线程 B，则线程 B 调用 local.get () 得到的是初始值，即没有继承线程 A 的本地线程变量。

# InheritableThreadLocal

使用 InheritableThreadLocal 可以继承本地线程变量，InheritableThreadLocal 是 ThreadLocal 的子类；

	InheritableThreadLocal<String> local = new InheritableThreadLocal<String>() {
	@Override
	protected String childValue(String s) {
	return super.childValue(s); // 得到父线程的值，以父线程的值做初始化
	}

	@Override
	protected String initialValue() {
	return "initial value";
	}
	};

与 ThreadLocal 的唯一区别是：InheritableThreadLocal 多了 childValue 方法。

线程 A 创建子线程 B 时，则会为子线程 B 初始化 childValue 方法，该方法可以设置其它的值。

# 使用线程组

# 创建分组与设置

为了方便管理多个线程，可以为线程分组，统一管理。

根线程组为 system，默认线程组为 main。

system
- main
  - group1（自定义）
    - thread1
    - thread2
    - subGroup1
  - group2（自定义）

	ThreadGroup group = new ThreadGroup("worker");
	ThreadGroup subGroup = new ThreadGroup(group, "subWorker");

	Runnable r = new Runnable() {
	@Override
	public void run() {
	// do something!
	}
	};

	Thread w1 = new Thread(group, "worker1");
	Thread w2 = new Thread(group, r);
	Thread w3 = new Thread(group, r, "worker3");

# 获取 Group 的信息与管理

获取信息：
- group.activeCount () : int; 返回活动线程的估计数。
- group.activeGroupCount () : int; 返回活动线程组的估计数。
- group.getName () : String; 返回该线程组名称。
- grou. getMaxPriority () : int; 返回该线程组下最大的优先级。
- group.getParent () : ThreadGroup; 返回该线程组的父线程组。
- group.list () : void; 打印线程组信息。
- group.checkAccess () : void; 确定当前运行的线程是否有权修改此线程组。
判断信息：
- group.isDaemon () : boolean; 返回该线程组是否是守护线程。
- group.isDestroyed () : boolean; 返回该线程组是否被销毁。
- group.parentOf (ThreadGroup parent) : boolean; 判断指定线程组是否是该线程组的父级。
管理线程：
- group.destroy (); 销毁线程。
- group.interrupt (); 中断线程。
- group.setDaemon (boolean b); 设置是否是守护线程组。
- group.setMaxPriority (int max); 设置最大优先级。
- group.uncaughtException (Thread t, Throwable throwable); 设置全局未捕获异常处理器。

# 处理线程组内的不受控制异常

继承 ThreadGroup 并重写 uncaughtException 方法。

	public class MyThreadGroup extends ThreadGroup {

	public MyThreadGroup(String s) {
	super(s);
	}

	@Override
	public void uncaughtException(Thread thread, Throwable throwable) {
	super.uncaughtException(thread, throwable);
	}
	}

# 用线程工厂创建线程

实现 ThreadFactory 接口的 newThread 方法。

	public class MyThreadFactory implements ThreadFactory {

	@Override
	public Thread newThread(Runnable runnable) {
	// do something!
	return null;
	}

	}

# 基本线程同步

临界区：访问一个共享资源在同一时间不能超过一个线程执行的代码块。

# 同步方法

使用 synchronized 关键字控制并发线程。

# 根据修饰对象分类

修饰代码块
- synchronized(this | object) {}
- synchronized (类.class) {}
修饰方法
- 修饰普通方法
- 修饰静态方法

# 根据获取的锁分类

获取对象锁
- synchronized(this | object) {}
- 修饰普通方法
获取类锁
- synchronized (类.class) {}
- 修饰静态方法（静态方法内的 synchronized 块必须是类锁）

# 补充

synchronized 关键字不能继承。
定义接口方法时，不能使用 synchronized 关键字。
构造方法不能使用 synchronized 关键字，但里面的代码块可以。
类锁和对象锁是互不干扰的。
synchronized 消耗资源比较大，而且导致死锁发生，所以不是临界区的就不使用，尽量避免同步。

# 在同步的类里安排独立属性

你也可以在同步的类里面创建对象，使用该对象作为对象锁，而不必使用 this。

	public class ShareClass {

	// 用于对象锁
	private final Object object = new Object();

	private long val;

	public ShareClass(long val) {
	this.val = val;
	}

	public void addVal(long val) {
	//object 锁
	synchronized (object) {
	this.val += val;
	}
	}
	}

# 在同步代码中使用条件

缓冲区是一个共享的数据结构，我们必须采用同步机制，比如 synchronized 关键字来控制对它的访问。但是我们有更多的限制因素，如果缓冲区是满的，生产者不能存储数据，如果缓冲区是空的，消费者不能取出数据。

对于这些类型的情况，Java 在 Object 对象中提供 wait ()，notify ()，和 notifyAll () 方法的实现，这三个方法是 Object 里的，所以所有对象都有这三个方法。

在 synchronized 外部调用 wait () 会抛 IllegalMonitorStateException 异常，并且调用 wait () 方法后，JVM 会休眠，并释放 synchronized 锁。使用 notify ()，和 notifyAll () 唤醒。

	public class ShareClass {

	private final Object object = new Object();

	// 是否已经通知过了
	private boolean wasSignaled = false;

	private long val = 0;

	public void addVal(long val) {
	synchronized (object) {
	//while 防止丢失信号，假唤醒
	//wasSignaled 是否已经通知过了，如果通知过了，则不执行 wait ();
	while (!wasSignaled && /* other condition */) {
	try {
	object.wait();
	} catch (InterruptedException e) {
	e.printStackTrace();
	}
	}

	// do something!
	}
	}

	public void notify() {
	// 已经通知过了
	wasSignaled = true;
	object.notify();
	}
	}

使用时，要注意丢失信号和假唤醒

丢失信号：使用标记，如果通知过了，就不再执行 wait () 方法。
假唤醒：使用 while 来判断条件，而不是 if。

# 使用 Lock 来同步代码块

Java 提供另外的机制用来同步代码块。它比 synchronized 关键字更加强大，灵活和更好的性能。

Lock 接口：

void lock();
void unlock();
boolean tryLock();
boolean tryLock(long waitTime, TimeUnit unit) throws InterruptedException;
Condition newCondition();
void lockInterruptibly() throws InterruptedException;

Lock 接口的实现类：

ReentrantLock
ReentrantReadWriteLock.ReadLock
ReentrantReadWriteLock.WriteLock

Lock 接口下的锁是手动释放的，所以建议在 try 块的 finally 下释放，防止异常导致锁没被释放。

# 使用读 / 写锁同步数据访问

如果有读操作，则有新的写操作时，写操作的线程就会阻塞；
如果有写操作，则有新的读操作或写操作，新的线程就会阻塞。

# 修改 Lock 的公平性

在 ReentrantLock 类和 ReentrantReadWriteLock 类的构造器中，允许一个名为 fair 的 boolean 类型参数，它允许你来控制这些类的行为。默认值为 false，这将启用非公平模式。

公平锁：排队，每个线程都有机会分到 CPU 时间片；
非公平锁：该线程会尝试获取锁，没有获取到就重新在队尾排队。

由于 tryLock () 方法并不会使线程进入睡眠，即使 Lock 接口正在被使用，这个公平属性并不会影响它的功能。

# 在 Lock 中使用多个条件

	Lock lock = new Reentrant.....;
	Condition c = lock.newCondition();

c.await() : void throws InterruptedException;
c.await(long time, TimeUnit unit) :boolean throws InterruptedException;
c.awaitUntil(Date date) : boolean throws InterruptedException;
c.awaitNanos(long nanos) : long throws InterruptedException;
c.awaitUninterruptibly() : void;
c.signal() : void;
c.signalAll() : void;

# 线程同步工具

高级的机制来达到多线程的同步:

Semaphores: 控制访问多个共享资源的计数器。此机制是并发编程的最基本的工具之一，而且大部分编程语言都会提供此机制。
CountDownLatch: CountDownLatch 类是 Java 语言提供的一个机制，它允许线程等待多个操作的完结。
CyclicBarrier: CyclicBarrier 类是又一个 java 语言提供的机制，它允许多个线程在同一个点同步。
Phaser: Phaser 类是又一个 java 语言提供的机制，它控制并发任务分成段落来执行。全部的线程在继续执行下一个段之前必须等到之前的段执行结束。这是 Java 7 API 的一个新特性。
Exchanger: Exchanger 类也是 java 语言提供的又一个机制，它提供 2 个线程间的数据交换点。

# 控制并发访问资源 (Semaphores)

创建信号量：资源的数量

	// 默认非公平锁
	Semaphore s = new Semaphore(1);

	// 公平锁
	Semaphore s = new Semaphore(1, true);

# 获取信号量

一直阻塞直到获取 n 个信号量成功或线程终止。

s.acquire():void throws InterruptedException;
s.acquire(int permits):void throws InterruptedException;

一直阻塞直到获取 n 个信号量成功，不会被打断。

s.acquireUninterruptibly();
s.acquireUninterruptibly(int permits);

# 释放信号量

释放 n 个信号量。

s.release();
s.release(int permits);

# 尝试获取信号量

尝试获取 n 个信号量，如果没有则返回 false，该方法不阻塞，可以用在 if 上。

s.tryAcquire();
s.tryAcquire(int permits);
s.tryAcquire(long timeout, TimeUnit unit);
s.tryAcquire(int permits, long timeout, TimeUnit unit);

如果获取到，则处理完毕，需要 s.release 释放。

# 其它信息或控制

s.drainPermits () : int 立即返回剩余的信号量，并置 0;
s.availablePermits () : int 获取剩余的信号量个数；
s.getQueueLength () : int 获取排队中等待 acquire 的线程数目；
s.hasQueuedThreads () : boolean 判断是否还有在排队的线程；
s.isFair () : boolean ：判断是否是公平锁；

# 等待多个并发事件完成

Java 并发 API 提供这样的类，它允许 1 个或者多个线程一直等待，直到一组操作执行完成。这个类就是 CountDownLatch 类。它初始一个整数值，此值是线程将要等待的操作数。当某个线程为了想要执行这些操作而等待时，它要使用 await () 方法。此方法让线程进入休眠直到操作完成。当某个操作结束，它使用 countDown () 方法来减少 CountDownLatch 类的内部计数器。当计数器到达 0 时，这个类会唤醒全部使用 await () 方法休眠的线程们。

	// 等待操作数
	CountDownLatch c = new CountDownLatch(10);

当计时器为 0，全部唤醒后，就失效了，计时器不能增加，所以得新建对象才能重新使用。

# 一个或多个线程等待

c.await () : void throws InterruptedException 等待直到计数器为 0，才被唤醒并运行；
c.await (long timeout, Timeout unit) : void throws InterruptedException 等待直到计数器为 0 或超时，才被唤醒并运行；

# 减少计时器

c.countDown () : 计时器 --，当计时器 == 0 时，会唤醒所有调过 await 的线程；

# 获取计时器的值

c.getCount () : long 计时器的值；

# 在同一个点同步任务

CyclicBarrier 也叫同步屏障，在 JDK1.5 被引入，可以让一组线程达到一个屏障时被阻塞，直到最后一个线程达到屏障时，所以被阻塞的线程才能继续执行。

	# 线程屏障
	线程1 -----> \|
	线程2 ---> \| 全部到达屏障后，才能通过--->
	线程3 ----> \|

	Runnable r = new Runnable() {
	@Override
	public void run() {
	// do something!
	}
	};

	# 5个线程
	CyclicBarrier c = new CyclicBarrier(5);

	# 5个线程结束后，执行r线程
	CyclicBarrier c = new CyclicBarrier(5, r);

# 到达同步点后，等待

c.await () : int throws InterruptedException, BrokenBarrierException 等待，直到所有的线程都调用 await，才唤醒；
c.await (int timeout, TimeUnit unit) : int throws InterruptedException, BrokenBarrierException 等待，直到所有的线程都调用 await 或超时，才唤醒；

# 重置

与 CountDownLatch 不同的是，CyclicBarrier 可以重置回到原来的状态。

c.reset() : void;

调用 reset 后，之前调用 await 的线程会抛出 broken 异常。

# 其它信息

c.getNumberWaiting () : int 返回已经调用 await 方法的线程数；
c.getParties () : int 返回剩余还没调用 await 方法的线程数；
c.isBroken () : boolean 当其中一个线程被中止了，则其它线程也会收到 broken 异常，且该 barrier 的状态就变成 broken 状态。

# 运行阶段性并发任务

# 创建

	Phaser p = new Phaser();
	Phaser p = new Phaser(int parties);
	Phaser p = new Phaser(Phaser parent);
	Phaser p = new Phaser(Phaser parent, int parties);

# 注册

p.register() : int;
p.bulkRegister(int parties) : int;

自动内存管理机制

2020-04-10T10:01:20.000Z

# 运行时数据区域

# 程序计数器

是一块较小的内存空间，当前线程所执行的字节码的行号指示器。

仅概念模型，各 JVM 实现不一样。
字节码解释器读／写该计数器。
各线程独立储存计数器，称 “线程私有” 内存。
线程正执行 Java 方法，计数器记录的是正在执行的虚拟机字节码指令地址。
线程正执行 Native 方法，计数器值为空（Undefined）；
此内存区域是唯一一个在 Java 虚拟机规范中未规定任何 OutOfMemoryError 情况的区域。

# Java 虚拟机栈

是 Java 方法执行的内存模型；每个方法在执行的同时都创建一个栈帧（Stack Frame）；栈帧用于储存局部变量表、操作数栈、动态链接、方法出口等信息。每一个方法从调用直至执行完成的过程，就对应着一个栈帧在虚拟机栈中入栈到出栈的过程：

方法：调用 -------> 执行完成
栈帧：虚拟机栈 (入栈 -------> 出栈)

线程私有。
生命周期与线程相同。
局部变量表存放编译期基本数据类型（8 类）、对象引用和 returnAddress 类型（字节码指令地址）
64 位 long 和 double 类型数据占用 2 个局部变量空间（Slot），其余类型占 1 个。
局部变量表所需内存空间大小在编译期间决定，运行期间不会改变；进入方法时，在帧中分配已确定大小的局部变量空间。
该区域定义两种异常：线程请求的栈深度大于虚拟机所允许的深度，将抛出 StackOverflowError 异常；如果虚拟机可以动态扩展，并扩展时无法申请到足够的内存，就会抛出 OutOfMemoryError 异常。

# 本地方法栈

与虚拟机栈发挥的作用非常相似，区别是虚拟机栈为虚拟机执行 Java 方法（字节码）服务，而本地方法栈为虚拟机使用 Native 方法服务。

该区域没规范，所以具体虚拟机可以自由实现它，Sun HotSpot 虚拟机把本地方法栈和虚拟机栈合二为一。

本地方法栈区域也会抛出 StackOverflowError 和 OutOfMemeryError 异常。

# Java 堆

是 Java 虚拟机管理的内存中最大的一块，是被所有线程共享的一块内存区域，在虚拟机启动时创建。

此内存区域存放对象实例以及数组。
是垃圾收集器管理的主要区域，又称 GC 堆（Garbage Collected Heap）。
内存回收角度：新生代和老年代；细分 Eden 空间、From Survivor 空间、To Survivor 空间；
内存分配角度：可能划分出多个线程私有的分配缓冲区（Thread Local Allocation Buffer，TLAB）。
可以不需要连续的内存。
-Xmx -Xms 控制是否可扩展；如果没有内存完成实例分配，并且堆也无法再扩展，则将抛出 OutOfMemoryError。

# 方法区

是各个线程共享的内存区域，用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

别名 Non-Heap（非堆），是堆的一个逻辑部分。
HotSpot 虚拟机的 GC 扩展至方法区，又称 “永久代”（Permanent Generation），受 -XX:MaxPermSize 上限限制，后期可能移除永久代。
JDK 1.7 HotSpot 已经从永久代中移除字符串常量池。
无法满足内存分配需求时，将抛出 OutOfMemoryError 异常。

# 运行时常量池

是方法区的一部分。Class 文件中有一项信息是常量池（Constant Pool Table），用于存放编译期生成的各种字面量和符号引用。

运行期间也可以将新的常量放入池中，比如 String.intern () 方法。
内存无法申请时，将抛出 OutOfMemoryError 异常。

# 直接内存

直接内存（Direct Memory），Native 函数库直接分配堆外内存，然后由 Java 堆中的对象引用该内存。以此避免 Java 堆与 Native 堆中来回复制数据。

JDK 1.4 新加入 NIO，DirectByteBuffer 对象直接引用 Native 分配的堆外内存。
受本机总内存（RAM+SWAP 区 / 分页文件）大小以及处理器寻址空间限制。内存超出会抛出 OutOfMemoryError 异常。

# HotSpot 虚拟机对象探秘

# 对象的创建

# new 指令的处理

检查指令的参数能否在常量池中定位到类的符号引用；并检查这个符号引用代表的类是否被加载、解析和初始化过。
如果没有，那必须先执行相应的类加载过程。
加载检查通过后，为新生对象分配确定大小的内存。
将分配到的内存空间都初始化为零值（不包括对象头），保证实例字段不初始化就可以使用对应的零值。
设置对象头，记录各种信息：GC 分代年龄、对象的哈希码、元数据信息等。
至此，对象已经产生。执行 new 指令之后，接着执行 <init> 方法（由 invokespecial 指令决定）。

# 内存分配方式

指针碰撞（Bump the Pointer）：用过的内存放在一边，空闲的内存放在另外一边，中间放置分界点的指示器；通过移动指示器来分配内存。Serial、ParNew 等 Compact 过程收集器采用该算法。
空闲列表（Free List）：虚拟机维护一个列表，记录哪些内存块是可用的，从中分配足够的内存空间给对象实例，并更新记录。CMS 收集器基于 Mark-Sweep 算法，采用该方式。

分配内存比较频繁，仅改变一个指针移动，在并发情况下不是线性安全的，解决方法：

虚拟机采用 CAS 同步，并配上失败重试的方式保证更新操作的原子性。
每个线程在 Java 堆中预先分配一小块内存，称为本地线程分配缓冲（Thread Local Allocation Buffer，TLAB），当 TLAB 用完并分配新 TLAB 时，才需同步锁定。由 -XX:+/-UseTLAB 参数决定。

# 对象的内存布局

对象在内存中存储的布局可以分为 3 块区域：对象头、实例数据、对齐填充。

下面以 32 位 JVM 为例。

# 对象头

普通对象：

	+-----------------------------------------------------------------+
	\| Object Header: 64-bits \|
	+--------------------------------+--------------------------------+
	\| Mark Word: 32-bits \| Klass Word: 32-bits \|
	+--------------------------------+--------------------------------+

数组对象：

	+--------------------------------------------------------------------------------------+
	\| Object Header: 96-bits \|
	+----------------------------+----------------------------+----------------------------+
	\| Mark Word: 32-bits \| Klass Word: 32-bits \| array length: 32-bits \|
	+----------------------------+----------------------------+----------------------------+

# Mark Word

标记字：记录哈希码，GC 分代年龄、锁状态标志、线程持有的锁、偏向时间戳等，数据长度为 32bit（32 位）或 64bit（64 位），它会根据对象状态复用该存储空间。比如：HotSpot 32 位，未锁定时，25bit 用于对象哈希码，4bit 用于分代年龄，2bit 锁标志位，1bit 固定为 0。

32 位的标记字结构如下：

	+-----------------------------------------------------------+--------------------+
	\| Mark Word: 32-bits \| State \|
	+-----------------------+--------+----------------+---------+--------------------+
	\| identity_hashcode: 25 \| age: 4 \| biased_lock: 1 \| lock: 2 \| Normal \|
	+------------+----------+--------+----------------+---------+--------------------+
	\| thread: 23 \| epoch: 2 \| age: 4 \| biased_lock: 1 \| lock: 2 \| Biased \|
	+------------+----------+--------+----------------+---------+--------------------+
	\| ptr_to_lock_record: 30 \| lock: 2 \| Lightweight Locked \|
	+-------------------------------------------------+---------+--------------------+
	\| ptr_to_heavyweight_monitor: 30 \| lock: 2 \| Heavyweight Locked \|
	+-------------------------------------------------+---------+--------------------+
	\| \| lock: 2 \| Marked for GC \|
	+-------------------------------------------------+---------+--------------------+

biased lock	lock	状态	存储内容
0	01	未锁定	对象哈希码、对象分代年龄
1	01	可偏向	偏向线程 ID、偏向时间戳、对象分代年龄
0	00	轻量级锁	指向锁记录的指针
0	10	重量级锁（膨胀）	指向重量级锁的指针
0	11	GC 标记	空，不需要记录信息

biased_lock: 对象是否启用偏向锁标记：0 - 关闭；1 - 启用
age: 对象年龄，最大值为 15。在 GC 中，如果对象在 Survivor 区复制一次，年龄增加 1。当对象达到设定的阈值（ -XX:MaxTenuringThreshold ）时，将会晋升到老年代。默认情况下，并行 GC 的阈值为 15，并发 GC 的阈值为 6。
identity_hashcode: 哈希码，采用延迟加载技术。调用方法 System.identityHashCode() 计算，并会将结果写到该对象头中。当对象被锁定时，该值会移动到管程 Monitor 中。而且计算哈希码后，则不能开启偏向锁。
thread: 持有偏向锁的线程 ID。
epoch: 偏向时间戳。
ptr_to_lock_record: 指向栈中锁记录的指针。
ptr_to_heavyweight_monitor 指向管程 Monitor 的指针。

64 位的标记字结构如下：

	+------------------------------------------------------------------------------------+--------------------+
	\| Mark Word: 64-bits \| State \|
	+------------+------------+----------+-----------+--------+----------------+---------+--------------------+
	\| unused: 25 \| identity_hashcode: 31 \| unused: 1 \| age: 4 \| biased_lock: 1 \| lock: 2 \| Normal \|
	+------------+------------+----------+-----------+--------+----------------+---------+--------------------+
	\| thread: 54 \| epoch: 2 \| unused: 1 \| age: 4 \| biased_lock: 1 \| lock: 2 \| Biased \|
	+-------------------------+----------+-----------+--------+----------------+---------+--------------------+
	\| ptr_to_lock_record: 62 \| lock: 2 \| Lightweight Locked \|
	+--------------------------------------------------------------------------+---------+--------------------+
	\| ptr_to_heavyweight_monitor: 62 \| lock: 2 \| Heavyweight Locked \|
	+--------------------------------------------------------------------------+---------+--------------------+
	\| \| lock: 2 \| Marked for GC \|
	+--------------------------------------------------------------------------+---------+--------------------+

# Klass Word

类型指针：指向它的类元数据的指针，JVM 通过这个确定该对象是哪个类的实例。

并不是所有 JVM 实现都必须在对象数据上保留该类型指针，可通过其它途径获取类元数据信息，参考句柄访问。

如果对象是一个 Java 数组，那对象头中还必需记录数组长度。

# 实例数据（Instance Data）

存储父类继承下来的与子类定义的字段内容。

这部分存储顺序受虚拟机分配策略参数（FieldsAllocationStyle）和字段在 Java 源码中定义顺序的影响。

HotSpot 虚拟机默认分配策略：longs/doubles、ints、shorts/chars、bytes/booleans、oops (Ordinary Object Pointers)，从中看出，相同宽度的字段放在一起。

父类中定义的变量出现在子类之前。如果 CompactFields 参数值为 true（默认），那么子类之中较窄的变量也可能会插入到父类变量的空隙中。

# 对齐填充（Padding）

HotSpot VM 的自动管理系统要求对象起始地址必须是 8 字节的整数倍，因此实例数据部分未对齐，则需要通过对齐填充来补全。

# 对象的访问定位

通过栈上的 reference 数据来操作堆上的具体对象，访问堆中的对象的具体位置，决定虚拟机的实现方式。目前流行的访问方式有使用句柄和直接指针两种。

# 句柄访问

Java 堆中将会划分出一块内存作为句柄池，reference 存储的是对象的句柄地址（指针的指针）。

优点：
在对象被移动时（GC 时移动对象是非常普遍的行为），只会改变句柄中的实例数据指针，而 reference 本身不需要修改。

# 直接指针

reference 直接存储对象的地址，对象的头部需要存储对象类型数据的地址。

优点：速度更快，节省一次指针定位的时间开销；对象访问在 Java 中非常频繁。Sun HotSpot 采用这种方式进行对象访问。

# 实战：OOM 异常

显示运行时详细的 gc 记录

JVM Args: -verbose:gc -Xms20M -Xmx20M -Xmn10M -XX:+PrintGCDetails -XX:SurvivorRatio=8

# Java 堆溢出

	/**
	* JVM Args: -Xms20M -Xmx20M -XX:+HeapDumpOnOutOfMemoryError
	*/
	public class HeapOOM {

	static class OOMObject {
	}

	public static void main(String[] args) {
	List<OOMObject> list = new ArrayList<>();
	while (true) {
	list.add(new OOMObject());
	}
	}

	}

异常：
java.lang.OutOfMemoryError: Java heap space

排查：

检查是否是内存泄露，通过工具查看泄露对象到 GC Roots 的引链。
如果不存在泄露，检查虚拟机参数（-Xmx 与 - Xms）；
从代码上检查是否存在某些对象生命周期过长、持有状态时间过长的情况。

# 虚拟机栈和本地方法栈溢出

如果线程请求的栈深度大于虚拟机所允许的最大深度，将抛出 StackOverflowError 异常。
如果虚拟机在扩展时无法申请到足够的内存空间，则抛出 OutOfMemoryError 异常。

实验：

使用 - Xss 参数减少栈内存容量。结果抛出 StackOverflowError 异常，异常出现时输出的堆栈深度相应缩小。

	/**
	* VM Args: -Xss228k
	*/
	public class JavaVMStackSOF {

	private int stackLength = 1;

	public void stackLeak() {
	stackLength++;
	stackLeak();
	}

	public static void main(String[] args) {
	JavaVMStackSOF oom = new JavaVMStackSOF();
	try {
	oom.stackLeak();
	} catch (Throwable e) {
	System.out.println("stack length: " + oom.stackLength);
	throw e;
	}
	}
	}

分配的栈内存越大，可创建的线程数就越少。

	/**
	* VM Args: -Xss2M
	*/
	public class JavaVMStackOOM {

	private void dontStop() {
	while (true) {
	}
	}

	public void stackLeakByThread() {
	while (true) {
	Thread thread = new Thread(new Runnable() {
	@Override
	public void run() {
	dontStop();
	}
	});
	thread.start();
	}
	}

	public static void main(String[] args) throws Throwable {
	JavaVMStackOOM oom = new JavaVMStackOOM();
	oom.stackLeakByThread();
	}

	}

如果出现 StackOverflowError 异常时，可参考堆栈。虚拟机默认参数，栈深度在大多数情况下达到 1000～2000 完全没问题，正常方法调用（包括递归）完全够用。
如果是建立过多线程导致的内存溢出，在不能减少线程数或者更换 64 位虚拟机的情况下，就只能通过减少最大堆和减少栈容量来换取更多的线程。

# 方法区和运行时常量池溢出

# 运行时常量溢出

以下在 JDK 1.6 之前有效，1.7 到 1.8 已经将常量池从方法区移除

	/**
	* VM Args: -XX:PermSize=10M -XX:MaxPermSize=10M
	*/
	public class RuntimeConstantPoolOOM {

	public static void main(String[] args) {
	// 使用 List 保持常量池引用，避免 Full GC 回收常量池行为
	List<String> list = new ArrayList<>();
	int i = 0;
	while(true) {
	list.add(String.valueOf(i++).intern());
	}
	}
	}

JDK 1.7 以上：

	public class RuntimeConstantPoolOOM {

	public static void main(String[] args) {

	String str1 = new StringBuilder("计算机").append("软件").toString();
	//true, 首次出现
	System.out.println(str1.intern() == str1);

	// 字面量，编译后放在常量池，出现过；Java 1.7 将常量池移到堆中。
	String str = "java";
	String str2 = new StringBuilder("ja").append("va").toString();
	//false, 非首次出现
	System.out.println(str2.intern() == str2);
	}
	}

# 方法区溢出

需要引入 cglib 库

	<dependency>
	<groupId>cglib</groupId>
	<artifactId>cglib-nodep</artifactId>
	<version>3.2.4</version>
	</dependency>

	/**
	* VM Args: -XX:PermSize=10M -XX:MaxPermSize=10M
	*/
	public class JavaMethodAreaOOM {
	public static void main(String[] args) {
	while(true) {
	Enhancer enhancer = new Enhancer();
	enhancer.setSuperclass(OOMObject.class);
	enhancer.setUseCache(false);
	enhancer.setCallback(new MethodInterceptor() {
	@Override
	public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
	return methodProxy.invokeSuper(o, objects);
	}
	});
	enhancer.create();
	}
	}

	static class OOMObject {}
	}

# 本机直接内存溢出

DirectMemory 容量可通过 -XX:MaxDirectMemorySize 指定，默认与 Java 堆最大值（-Xmx）一样。

	/**
	* VM Args: -Xmx20M -XX:MaxDirectMemorySize=10M
	*/
	public class DirectMemoryOOM {
	private static final int _1MB = 1024 * 1024;

	public static void main(String[] args) throws Exception {
	Field unsafeField = Unsafe.class.getDeclaredFields()[0];
	unsafeField.setAccessible(true);
	Unsafe unsafe = (Unsafe) unsafeField.get(null);
	while (true) {
	unsafe.allocateMemory(_1MB);
	}
	}
	}

由于 DirectMemory 导致的内存溢出，一个明显的特征是在 Heap Dump 文件中不会看到明显的异常。

如果发现 OOM 之后的 Dump 文件很小，而程序又直接或间接使用 NIO，则可能是这个原因。

计算机网络试题

2020-04-08T06:09:29.000Z

# 知识点

OSI 七层模型分别对应着五层模型的哪一部分
1. OSI 七层模型： 物理层、数据链路层、网络层、传输层、会话层、表示层、应用层
2. TCP/IP 四层模型： 网络接口层（链接层）、网络互联层（网际层）、传输层、应用层
3. 五层模式： 将 OSI 模型和 TCP/IP 模型对比，因此其实还是 TCP/IP 的四层，只不过将网络接口层拆分为物理层和数据链路层。
- 物理层： 在局部局域网上传送数据帧，针脚、电压、线缆、集线器、中继器、网卡、接口卡等。
- 数据链路层： 网络寻址、错误侦测和改错，逻辑链路控制（LLC）子层、介质访问控制（MAC）子层
- 网络层： 数据的路径选择和转寄。互联网协议（IP）、ICMP
- 传输层： TCP、UDP
- 会话层： 保持双方的连接，对话；RPC，Sockets
- 表示层： 数据的表现形式，例如压缩等，MIME，SSL，TLS
- 应用层： WebSocket、HTTP
数据链路层三大法宝
1. 封装成帧： 在数据的前后添加首部、尾部。
2. 透明传输： 避免传输的数据中包含帧定界符，通过转义。
3. 差错检测： 防止接收到传输过程中发生错误的数据。
  - FCS 生成： 传输数据 / 除数 = 商... 余数（FCS）
  - CRC 校验： （传输数据 + 余数） / 除数 = 商...0
商丢弃，用不到，余数作为 FCS；CRC 校验，余数为 0 则正确。
除数都是约定的，不同标准有不同的约定。
流量控制
TCP 流量控制
1. 连续 ARQ 机制
2. 滑动窗口机制
3. 累计确认
4. 动态调整 ACK 号的等待时间
5. ACK 和窗口的合并
连续 ARQ （Automatic Repeat reQuest）机制： 不采用停止等待协议，即一问一答的线性方式，效率低下。而是采用连续发送多个分组，然后再等待确认。持有对方的窗口大小，根据窗口大小连续发送。

滑动窗口： 接收方通过握手阶段，以及 ACK 应答包，通知发送方，自己缓冲区空闲的容量。发送方就可以根据这个容量，进行连续 ARQ 发送。

累计确认： 接收方不用立即应答 ACK，而是等待一段时间，在这段时间可以处理多个分组，然后才应答最新的 ACK 号给对方。

动态调整 ACK 号的等待时间： 发送方在连续 ARQ 发送后，等待对方的 ACK 包到达时间，如果网络拥堵，则 ACK 包到达的就很慢，超时时间就提高；如果网络减少拥堵了，则 ACK 包就到达的很快，相应的，超时时间就降低。超时时间就是等待时间，如果超过这个超时时间，就认为对方没收到，因此重新发送上次的一批分组。

ACK 和窗口的合并： 接收方发送应答包 ACK 时，也可以在 ACK 包上面携带新的窗口大小，这样每次都可以减少一个包的发送。
TCP 滑动窗口
1. 窗口： 指的是接收方的空闲缓存区，处理能力的一个容量大小
2. 滑动： 窗口动态变化，接收方处理能力实时变化，而且是根据接收分组序号的顺序滑动的。
流量控制： 参考流量控制，以及还有一点，死锁的发生。

接收方 B 发送一个窗口为 0 的大小，发送方 A 就开始等待；等待接收方 B 处理完缓冲区数据后，返回 ACK 包。然而，如果发送方 A 没收到 ACK 包，双方就一直等待，进入死锁状态。

这种情况下，发送方 A 接收到 B 的 0 窗口 ACK 包后，进入等待的同时，持续计时器也同时开始工作，时间一到，就主动发送 1 字节或不包含数据的试探包，序号使用旧的序号，这样不会浪费序号；如果对方返回还是零窗口，则重置计时器，重新等待。直到窗口不为 0。会使用退避算法尝试。

拥堵控制

滑动窗口： 解决的是接收方处理速度跟不上发送方发送速度的解决方案。

拥堵控制： 解决的是阻止传输路径上拥堵的手段。

发送方会根据滑动窗口和拥堵窗口来发送。

控制发送量，慢慢接近网络的承载量。
- RTO (Retransmission TimeOut)： 重传的超时时间，即等待 ACK 应答的时间。
- RTT (Round Trip Time)： 单次握手的往返时间。
1. TCP 为每条连接维护一个 “拥堵窗口”，拥堵窗口初始化为 1 个 MSS。
2. 每次接收对方的 ACK，拥堵窗口就成倍增加；
3. 直到到达一个 “慢启动阈值”，到达后，每次接收对方的 ACK，拥堵窗口就增加 1，线性增加。
4. 如果等待 ACK 发生超时，慢启动阈值就降为超时前拥堵窗口的一半大小，拥堵窗口重置为 1，重新回到慢启动阶段。
这里调优，可以控制拥堵窗口的增加量，以及窗口最大限值。
对于报文丢失的处理，有不同的算法，区别是在重复确认：
1. TCP Tahoe： 丢失时，进入 “快速重传”，慢启动阈值设为之前的拥堵窗口值的一半，拥堵窗口值降为初始值，重新进入慢启动阶段。
2. TCP Reno： 快速恢复，慢启动阈值设置为之前拥堵窗口值的一半，但是，新的拥堵窗口值也为前拥堵窗口值的一半，跳过了慢启动阶段；如果继续遇到超时，则才进入慢启动阶段。
超时或者重复确认，认为是网络拥堵或网络质量差导致的丢包。

重复确认即收到相同的 ACK 号，例如阈值是 3 次，即第 4 次收到相同确认号，那说明有包丢失了。

对于 RTO 即超时，两个算法都是将拥堵窗口降为 1 个 MSS，然后进入慢启动阶段。
TCP 为什么可靠？
1. 确认 / 重传： 发送方发送后，需要接收方发回确认包，如果没收到接收方的确认，则会进行重传。
2. 分组序号： 每个分组都有序列号，而且是排序的，能检测数据是否完整。
3. 流量控制
4. 拥堵控制
5. CRC 校验和，当然 UDP 也有，因此不是特有的。
TCP 重传
1. 超时重传
2. 重复确认重传
重传有个问题，是全部重传呢？还是部分重传呢？

因此，引入 SACK 机制。

还有 D-SACK
TCP 拆包 / 黏包机器解决办法
TCP 是流协议，即没有界限的一串数据。TCP 不了解上层业务数据的具体含义，因此一个完整的包可能出现划分，或者多个小包封装成一个大的数据包。

产生原因：
1. write 写入的字节大于发送缓冲区的大小，因此进行拆分；
2. 进行 MSS 大小的 TCP 分段；
3. 以太网帧的 payload 大于 MTU 进行 IP 分片。
解决策略：
1. 消息定长，例如每个报文固定为 200 字节，不够就空位补空格。
2. 在包尾部增加回车换行符，进行分割，例如 FTP 协议；
3. 将消息分为消息头和消息体，消息头包含消息总长度的消息 / 或消息体的长度；一般设计是，消息头第一个字段使用 int32 来表示消息的总长度。
4. 更复杂的应用层协议。
TCP 详解：重传、流量控制、拥塞控制

无.
TCP 拥塞算法
早期的 Tahoe

现代的：Reno、HSTCP、BIC、Vegas、Westwood
1. 基于丢包反馈的 TCP 协议（Tahoe、Reno、New Reno、SACK）
2. 基于延时反馈的 TCP 协议（Vegas、Westwood）
3. 无线传输中的 Westwood 算法
4. 基于丢包反馈的高速带宽算法（HSTCP、STCP、BIC-TCP、CUBIC）
TCP 为什么采用三次握手，而不是两次握手或四次握手？
1. TCP 协议提供可靠的面向连接服务。
2. 因此发送时，需要对方应答，才能知道对方有没收到。（这样就需要 2 次握手）
3. 再由于 TCP 协议是全双工的，双方都可以发送和接收数据。
4. 因此，双方都需要知道对方是否接收成功，因此，双方都要应答。（假设双方都发送连接请求、以及应答请求，这样就 4 次了）。
5. 然而，一方的应答和请求可以同时发起，即合并在一起，因此至少要 3 次握手，以及握手次数越少越好，因此就是 3 次了。
连接还有一个重点是：连接是为了初始化双方的一些设置，例如：序号、窗口值、以及选项（例如：SACK 是否支持）；这就是为什么需要双方都连接。

SACK - Selective Acknowledgment
TCP 三次握手数据丢失会发生什么？

有超时重传，重传指定次数都失败后，就断开连接。例如：第三次握手丢失，接收方会重传 SYN + ACK。
RST 产生的情况
1. 目标端口未监听，不存在
2. 目的主机或者网络中防火墙拦截
3. 向已经关闭的 socket 发送数据
4. 向已关闭的连接发送 FIN
对已经收到 RST 的连接进行 IO 操作，会产生 SIGPIPE 信号，broken pipe。
TCP/UDP 报最大长度

UDP 的是 65535 - 头部 8 字节 = 65527

TCP 由 MSS 决定的，一般是 1460，以太网是 1500 - IP 头部（20） - TCP 头部（20） = 1460，当然还有可选字段，以及 MSS 双方可以协商。

MSS 协商，可以在 TCP 头部可选字段携带。
TCP/UDP 报文格式
TCP 头部结构：
1. 发送方端口号（2 字节）、接收方端口号（2 字节）
2. 序号（4 字节）
3. ACK（4 字节）
4. 数据偏移量（4 位）、保留（6 位）、控制位（6 位）、窗口（2 字节）
5. 校验和（2 字节）、紧急指针（2 字节）
6. 可选字段（可变长度，可有可无）
UDP 头部结构：
1. 发送方端口（2 字节）、接收方端口（2 字节）
2. 数据长度（2 字节）、校验和（2 字节）
TCP/UDP 优缺点以及区别
TCP：
1. 优点：可靠，稳定。三次握手、确认、窗口、重传、拥堵控制，传完后断开连接。
2. 缺点：慢，效率低，占用系统资源高，易被攻击。
UDP：
1. 优点：快，比 TCP 稍安全。没有握手、确认、窗口、重传、拥堵控制等机制，无状态协议，传递数据快。
2. 缺点：不可靠，不稳定
TCP 只能点到点；UDP 支持一对一，一对多，多对一和多对多的交互通信。
HTTP 与 TCP 的区别和联系
- 区别：HTTP 是应用层的协议，TCP 是传输层的协议。
- 联系：HTTP 基于 TCP 协议传输内容。
http 和 https 的区别与联系？
- 区别：http 是明文传输的；https 是加密后传输的。端口不同
- 联系：http + SSL = https；https 是在 http 的基础上，加上安全机制，通过证书，
为什么说 Http 是无状态的协议？
1. 请求完成后，就释放连接，尽快将资源释放给其它客户。无连接
2. 无状态是指协议对于事务处理没有记忆能力，服务器不知道客户端的状态。请求完成后就断开，不保存状态。
Http 的 Http basic authentication
1. 客户端发起 http 请求；
2. 服务器验证此用户是否已经登陆，如果没有，就返回 401 给客户端，以及头部携带 WWW-Authenticate 字段，此字段提示客户端授权方式。例如：Basic
3. 客户端输入账号、密码后，使用 base64 将账号和密码编码，然后将编码值放在头部的 Authorization 字段。
4. 服务器从头部获取 Authorization 字段，然后解码，以及验证用户身份，验证通过后，就生成 session id，以及保存 session 相关信息，session id 通过 cookie 返回给客户端。
HTTP 请求的 GET 与 POST 方式的区别
1. 参数的位置不同
2. 是否跨域
3. GET 可以回退，而 POST 会再次提交请求
4. GET 可以被 bookmark，而 POST 不可以
5. GET 可以被浏览器缓存，而 POST 不会，除非手动设置
6. GET 只能进行 url 编码，而 POST 支持多种编码方式
7. GET 请求参数会被完整保留在历史记录中，而 POST 不行
8. GET URL 有长度限制、只能 ASCII 字符，而 POST 没限制
9. post 会先发送 options 试探跨域，然后再发送数据；而 GET 不会
Http1.0、Http1.1、Http2.0 的区别
1.0 和 1.1 比较：
1. 1.0 需要通过 keep-alive 告知服务器要建立长连接；而 1.1 默认
2. 缓存：1.0 有 If-Modified-Since, Expires 作为判断；而 1.1 引入过多控制策略：Entity tag，If-Unmodified-Since，If-Match，If-None-Match 等
3. 状态码：1.1 新增 24 个错误状态码，如 409（Conflict），410（Gone）
4. 1.1 支持只发送 header 信息而不带任何 body 信息，例如：OPTINOS 和 POST；服务器认为有权限，就返回 100 状态码，否则就是 401。客户收到 100 后，才发送数据。这样不用因为 401 就发送数据，节约带宽。
5. HOST：1.0 认为每台服务器只绑定一个唯一的 IP 地址，因此请求消息中 URL 并没有主机名。但虚拟主机技术的发展，一台物理服务器上可存在多个虚拟主机，并且共享一个 IP 地址。因此请求和响应消息都支持 Host 域，且请求消息如果没有 Host 域就报 400 错误。
1.1 和 2.0 比较：
1. 多路复用：浏览器客户端在同一时间段针对同一域名的请求有一定数据限制，超过限制数目就会被阻塞。2.0 使用多路复用技术，同一连接并发处理多个请求，且并发数量比 1.1 大了好几个数量级。
2. 首部压缩：1.1 不支持。2.0 使用 HPACK 算法对 header 的数据进行压缩。
3. 服务器推送：2.0 支持把客户端需要的资源一起推送到客户端，免得客户端再次创建连接发送请求到服务器端获取。这种方式非常适合加载静态资源。
Http 安全性
1. 内容加密：看不到内容具体意义
2. 身份认证：确认网站的真实性
3. 数据完整性：防止内容被第三方冒充或者篡改。
从输入 URL 到页面加载发生了什么？
1. DNS 解析
2. TCP 连接
3. 发送 HTTP 请求
4. 服务器处理请求并返回 HTTP 报文
5. 浏览器解析渲染页面
6. 连接结束。
Http 和 Socket 优劣比较？
Http 优点：基于应用层的接口，使用方便

Http 缺点：
1. 传输速度慢、数据包大。
2. 实现实时交互，服务器性能压力大。
3. 数据传输安全性差，服务器不会自动给客户端发送数据，除了 2.0 版本。
Socket 优点：
1. 传输数据为字节级，传输数据可自定义，数据量少
2. 传输数据时间短，性能高
3. 适合客户端和服务器之间信息实时交互
Socket 缺点：
1. 需要对传输的数据进行解析，转化为应用层的数据
2. 对开发人员的开发水平较高
3. 相对于 Http 协议传输，增加了开发量。
如何实现可靠的 UDP

可以按照 TCP 的可靠特性，在应用层处理相应的机制，例如：分片、确认、重发、拥堵控制等。这就变成 TCP 了。
网络协议是什么？
1. 计算机双方通信时必须共同遵从的一组约定。如何建立连接，如何识别对方等。
为什么要对网络协议分层？
1. 在制定标准之前，各个厂商对以太网的实现都不太统一，因此由国际标准组织统一标准，制定了 OSI 标准模型。
2. 分层是为了将职责划分，这样比较直观、容易描述和理解复杂的系统，以及方便管理。因此采用分层的方式制定规范。计算机很多系统都是以分层思想来设计的。
应用层
1. 应用层位于 OSI 的最上层。
2. 应用层直接和应用程序接口结合，并提供常见的服务。
3. 例子：HTTP、DNS、DHCP、FTP、SMTP、Telnet、SSH、POP3 等。
传输层
1. 为应用提供端到端的通信服务。
2. 例如：TCP、UDP 协议
网络层
1. 提供路由和寻址功能。
2. 使用 IP 地址来唯一标识互联网上的设备。依靠 IP 地址进行相互通信。
3. 在网络内部，是不需要网络层设备的，仅仅靠数据链路层就可以进行通信。对于不同网络的互联，就需要借助路由器等第三层设备。不同网络相互通信因此形成互联网。
数据链路层

构成数据单元（数据帧），并对帧定界、同步、收发顺序的控制，以及差错校验等。

导线的端到端数据传输。
物理层
1. 为数据端设备提供传送数据通路。
2. 传输数据。
TCP/IP 协议族
1. 是一个网络通信模型，为网际网络的基础通信架构。
2. TCP 和 IP 是该协议族的最初核心协议，因此称为 TCP/IP 协议族。
3. TCP/IP 提供了应用的端到端通信的机制，将数据应该如何封装、定址、传输、路由以及在目的地如何接收，都加以标准化。
TCP 报文的头部结构
TCP 头部结构：
1. 发送方端口号（2 字节）、接收方端口号（2 字节）
2. 序号（4 字节）
3. ACK（4 字节）
4. 数据偏移量（4 位）、保留（6 位）、控制位（6 位）、窗口（2 字节）
5. 校验和（2 字节）、紧急指针（2 字节）
6. 可选字段（可变长度，可有可无）
数据偏移量的单位，4 字节；因此， $(2^4 - 1) * 4 = 15 * 4 = 60$ 字节。头部长度。
三次握手
连接阶段：
1. 发送方发送：SYN、【初始的序号 x】、【窗口大小】
2. 接收方发送：【ACK：x+1】、【窗口大小】、SYN、【初始的序号 y】
3. 发送方发送：【ACK：y+1】
连接：为了同步序号、窗口大小。以及其它选项的配置。
四次挥手
1. 发送方：FIN
2. 接收方：【ACK 号】
3. 接收方：FIN
4. 发送方：【ACK 号】
5. 双方删除套接字
为什么 TCP 连接的时候是 3 次？2 次不可以吗？
1. TCP 协议提供可靠的面向连接服务，因此需要确认机制，这样就 2 次握手了。
2. TCP 提供全双工工作模式，双方可同时进行收发工作，以及双方都需要连接进行初始化，因此就 4 次了。
3. 有一端在确认的同时，可以合并连接操作，因此 3 次就行。
为什么 TCP 连接的时候是 3 次，关闭的时候却是 4 次？
1. TCP 协议提供可靠的面向连接服务，因此需要确认机制，这样就 2 次握手了。
2. 双方都需要断开，然后才能安全的删除套接字，因此，需要 4 次。
3. 以及断开操作和确认不能合并，是因为，一方断开是表明不再发送数据，但可能还有数据没接收完成；以及另外一端可能数据也还没发送完成。因此，另外一方在确认的同时，为了数据的完整，不能同时断开操作。等待另外一方发送完成后，才发送断开操作，因此双方断开操作不是同时的。
为什么客户端发出第四次挥手的确认报文后要等 2MSL 的时间才能释放 TCP 连接？
1. 2 倍的 MSL，即报文的等待超时时间（Maximum Segment Lifetime）。
2. 客户端发出 ACK 后，考虑到如果 ACK 由于网络拥堵等原因，丢失了，服务器会重新发送 FIN；此时客户端如果经过 1MSL 关闭后，就会导致接收不到 FIN 了。这样是为了确保网络拥堵情况下，服务器重发 FIN 可以收到 FIN，然后再次发送 ACK。
3. 延长 1 个 MSL 是，确保服务器真正收到 ACK 包，不会因为没收到而重新发送 FIN，客户端关闭了，导致服务器错误。
如果已经建立了连接，但是客户端突然出现故障了怎么办？
1. 服务器无法感知客户端是否故障，只不过是这段时间没有客户端的数据而已。
2. 但有 KeepAlive 机制，这不是 TCP 规范中的，但很多操作系统都实现了此机制。
3. tcp_keepalive_time：默认 2 小时，空闲时长
4. tcp_keepalive_intvl：探测包，间隔 75 s，在，空闲时长超时后，进行探测
5. tcp_keepalive_probes：探测次数，默认 9 次，如果 9 次都没应答，就认为客户端已经遇到故障了。
Linux 系统默认是不开启的，需要配置。
cat /proc/sys/net/ipv4/tcp_keepalive_time
cat /proc/sys/net/ipv4/tcp_keepalive_intvl
cat /proc/sys/net/ipv4/tcp_keepalive_probes
/etc/sysctl.conf 的全局配置，修改后，执行：sysctl -p 生效。
net.ipv4.tcp_keepalive_time=7200
net.ipv4.tcp_keepalive_intvl=75
net.ipv4.tcp_keepalive_probes=9
应用也可以开启，Tomcat，Netty 等。

如果不开启 KeepAlive，请求完成就断开操作了。
TCP 和 Http 中 Keep-Alive 的关系
1. HTTP 协议的 Keep-Alive 意图在于连接复用，同一个连接上串行方式传递请求 - 响应数据。
2. TCP 的 Keep-Alive 机制意图在于存活、心跳，检测连接错误
3. http 的 Keep-Alive 是在同一个 TCP 连接下，传输多个 http 请求，主要目的是为了连接复用。
4. TCP 的 Keep-Alive 更纯粹，为了检测对方是否还存活。
5. 以及 Http 的 Keep-Alive 还有一个超时，超时后，服务器就断开 Keep-Alive DDOS 攻击。
什么是 HTTP，HTTP 与 HTTPS 的区别
1. HTTP 是应用层的协议，使用 TCP 协议传输 HTTP 报文。
2. HTTP 传输的内容是明文，因此数据不安全；因此引入了安全机制，即结合 SSL 形成 HTTPS 协议，这样有了安全机制，传输的数据加密了，这样就保证了数据的安全。以及 SSL 需要向权威机构申请证书，这样就能保证站点的信任。
3. 以及防止篡改数据，保证数据的完整性。
- 数据安全性
- 站点信任
- 防止篡改数据。
常用 HTTP 状态码
1. 1xxx 开头：消息，临时响应，即服务器已经接收，需要客户端进一步处理。
2. 2xxx 开头：成功，代表服务器已经接收请求。
3. 3xxx 开头：重定向，重定向在 Location 指定。
4. 4xxx 开头：客户端错误
5. 5xxx 开头：服务器错误
- 101 Switch Protocols，Upgrade 头通知客户端使用新协议，例如切换新版本 2.0、WebSocket
- 204 No Content，没有内容，例如 OPTIONS
- 301 Moved Permanently，资源永久移动位置
- 500 Internal Server Error
- 502 Bad Gateway
- 503 Service Unavailable
什么是对称加密与非对称加密
- 对称加密：加密速度快，取决于密钥长度；加密 / 解密使用的都是同一个密钥。
- 非对称加密：加密稍慢，加密使用公开的钥匙。解密使用私有的钥匙。私钥不公开，因此比较安全。
什么是 HTTP2
1. http 有几个版本：1.0，1.1， 2.0
2. 2.0 版本新增：
- 多路复用：同一连接，可以并发发送多个请求
- 首部压缩：HPACK 算法对 header 的数据进行压缩。
- 服务端推送：支持把客户端需要的资源一起推送到客户端。
Session、Cookie 和 Token 的主要区别
1. Session 保存在服务器
2. Cookie 保存在客户端
3. Token 是用户身份的标识，token 可以由：uid（用户身份）+ 时间戳 + sign（由服务器签名，因此解决信任问题）
session，如果用户访问量很大，session 需要储存，导致服务器压力很大。
Servlet 是线程安全的吗

Servlet 不是线程安全的。

tomcat 模型：
用户发起请求，tomcat 从线程池中取出线程，然后找到请求对应的 Servlet 对象，进行初始化，然后调用 service 方法。

Servlet 是单例，因此，如果多个线程都调用同一个 Servlet 对象，就可能会导致线程问题。

Servlet 接口中有哪些方法及 Servlet 生命周期探秘

方法：
package javax.servlet;
import java.io.IOException;
public interface Servlet {
    void init(ServletConfig var1) throws ServletException;
    ServletConfig getServletConfig();
    void service(ServletRequest var1, ServletResponse var2) throws ServletException, IOException;
    String getServletInfo();
    void destroy();
}
生命周期：

容器调用 init 初始化 Servlet 对象。

请求到达后，执行 service，然后根据请求方法，执行 doGet 或 doPost

服务器关闭后或项目卸载后，服务器调用 destroy 销毁对象。

如果客户端禁止 cookie 能实现 session 还能用吗？
1. session 实现的前提是，客户端有储存 sessionId 的能力；
2. 客户端如何携带 sessionId。
3. 客户端禁用 cookie，那 localStorage 和 sessionStorage 可以储存。
4. 携带方式，可以是 url，头部。因此可以通过 url，或者自定义一个头部字段

# 试题

网络协议主要要素为语法、语义、同步。
一座大楼内的一个计算机网络系统，属于 LAN（Local area network）局域网。
随着电信和信息技术的发展，国际上出现了所谓 “三网融合” 的趋势，下列属于三网之一的是：
- 传统电信网
- 计算机网
- 有线电视网
- 卫星通信网
通信系统必须具备的三个基本要素是
- 终端、电缆、计算机
- 信号发生器、通信线路、信号接收设备
- 信源、通信媒体、信宿
- 终端、通信设施、接收设备
计算机网络通信系统是
- 电信号传输系统
- 文字通信系统
- 信号通信系统
- 数据通信系统
常用的传输介质中，带宽最宽、信号传输衰减最小、抗干扰能力最强的一类传输介质是
- 光纤
- 双绞线
- 同轴电缆
- 无线信道
在 OSI 七层结构模型中，处于数据链路层与运输层之间的是
- 物理层
- 网络层
- 会话层
- 表示层
数据解封装的过程是
- 段 — 包 — 帧 — 流 — 数据
- 流 — 帧 — 包 — 段 — 数据
- 数据 — 包 — 段 — 帧 — 流
- 数据 — 段 — 包 — 帧 — 流
信号流 --> 数据流 --> 数据帧 --> IP 包 --> TCP 分组 --> 数据
完成路径选择功能是在 OSI 模型的
- 物理层
- 数据链路层
- 网络层
- 运输层
在 OSI 中，完成整个网络系统内连接工作，为上一层提供整个网络范围内两个终端用户之间数据传输通路工作的是
- 物理层
- 数据链路层
- 网络层
- 运输层
注意：为上一层提供整个网络范围内两个终端用户之间数据传输通路，题目不是问这个，而是前半段；因此不是运输层。
在 OSI 中，为实现有效、可靠数据传输，必须对传输操作进行严格的控制和管理，完成这项工作的层次是
- 物理层
- 数据链路层
- 网络层
- 运输层
T1 载波的数据传输率为
- 1Mbps
- 10Mbps
- 2.048Mbps
- 1.544Mbps
人的话音信道在 4Mhz 之内，根据奈奎斯特采样定理按照 2 倍 8MHz 采样，并 128 级量化，即 $2^7$ ，用 7 个二进制 (7bit) 来表示一个采样（一个语音帧），每秒钟的产生的二进制数据量为 56kb, 计算公式：
$\frac{1s}{7bit * 8MHz} = 56Kbps$

在实际编码中每一个采样中还会加入一个信令位，即 8bit 组成一个通信信道。但通信介质（电话线）的带宽远大于一个信道，所以采用多路复用技术，将 24 个话音信道组成一组，即 T1 信道，最后加入一个帧同步，这样每一帧则变成了 193bit，计算公式：
$8bit * 24 + 1bit = 193bit$

由取样频率 8MHz 可知，取样周期为 125us，则可知 T1 信道的比特率为：
$\frac{193bit}{125us} = 1.544 Mbps$

T1 载波是专用电话连接、时分多路数字传输设施
T1 载波的数据速率是 1.544Mbps，
E1 载波的数据速率是 2.048Mbps，
E2 载波数据速率为 8.448Mbps，
E3 载波数据速率为 34.368Mbps，
E4 载波数据速率为 139.24Mbps，
E5 载波数据速率为 565.148Mbps。
若网络形状是由站点和连接站点的链路组成的一个闭合环，则称这种拓扑结构为
- 星形拓扑
- 总线拓扑
- 环形拓扑
- 树形拓扑
在计算机网络中，所有的计算机均连接到一条通信传输线路上，在线路两端连有防止信号反射的装置。这种连接结构被称为
- 总线结构
- 环型结构
- 星型结构
- 网状结构
报文交换技术说法不正确的是
- 报文交换采用的传送方式是 “存储一转发” 方式
- 报文交换方式中数据传输的数据块其长度不限且可变
- 报文交换可以把一个报文发送到多个目的地
- 报文交换方式适用于语音连接或交互式终端到计算机的连接
C - 可通过广播地址，发送多个目的地
1. 电路交换：适用于电话语音等交互性强的，但不适合数据通信业务
2. 报文交换：在节点采用储存转发方式
3. 分组交换：在节点采用储存转发方式
市话网在数据传输期间，在源节点与目的节点之间有一条利用中间节点构成的物理连接线路。这种市话网采用____技术
- 报文交换
- 电路交换
- 分组交换
- 数据交换
世界上很多国家都相继组建了自己国家的公用数据网，现有的公用数据网大多采用
- 分组交换方式
- 报文交换方式
- 电路交换方式
- 空分交换方式
在计算机网络中，一般局域网的数据传输速率要比广域网的数据传输速率
- 高
- 低
- 相同
- 不确定
电路交换是实现数据交换的一种技术，其特点是
- 无呼叫损失
- 不同速率的用户之间可以进行数据交换
- 信息延时短，且固定不变
- 可以把一个报文发送到多个目的节点中
因特网在通信子网内实现数据报操作方式对端系统
- 只提供数据报服务
- 只提供虚电路服务
- 提供数据报和虚电路服务
- 不提供服务
虚拟电路：即节点和节点之间的连接，形成的通信通道，就类似电路一样；因此把这个通道形象地称为虚电路。
以下各项中，不是数据报操作特点的是
- 每个分组自身携带有足够的信息，它的传送是被单独处理的
- 在整个传送过程中，不需建立虚电路
- 使所有分组按顺序到达目的端系统
- 网络节点要为每个分组做出路由选择
1. 虚电路是分组技术中的；数据报使用真正的电路信号。
2. 分组交换，分组不一定按顺序到达目的端系统。
在 OSI 中，物理层存在四个特性。其中，通信接口所用接线器的形状和尺寸属于
- 机械特性
- 电气特性
- 功能特性
- 过程特性
对于 CSMA/CD 而言，为了确保发送站点在传输时能检测到可能存在的冲突，数据帧的传输时延至少要等于信号传播时延的
- 1 倍
- 2 倍
- 4 倍
- 2.5 倍
在同一个信道上的同一时刻，能够进行双向数据传送的通信方式是
- 单工
- 半双工
- 全双工
- 上述三种均不是
采用全双工通信方式，数据传输的方向性结构为
- 可以在两个方向上同时传输
- 出只能在一个方向上传输
- 可以在两个方向上传输，但不能同时进位
- 以上均不对
令牌总线的媒体访问控制方法是由___定义的。
- IEEE 802.2
- IEEE 802.3
- IEEE 802.4
- IEEE 802.5
在中继系统中，中继器处于
- 物理层
- 数据链路层
- 网络层
- 高层
中继系统，如集线器，更多的是信号中继，不像交换机等，有进行拆包，检测；集线器更多的是电路技术。
下列只能简单再生信号的设备是
- 网卡
- 网桥
- 中继器
- 路由器
互联网主要由一系列的组件和技术构成，其网络协议核心是
- ISP
- PPP
- TCP/IP
- HTTP
在数字通信中广泛采用 CRC 循环冗余码的原因是 CRC 可以
- 检测出一位差错
- 检测并纠正一位差错
- 检测出多位突发性差错
- 检测并纠正多位突发性差错
在计算机网络通信系统中，一般要求误码率低于
- 10-4
- 10-5
- 10-6
- 10-7
在 10 Base T 的以太网中，使用双绞线作为传输介质，最大的网段长度是
- 2000m
- 500m
- 185m
- 100m
同轴电缆与双绞线相比，同轴电缆的抗干扰能力
- 弱
- 一样
- 强
- 不能确定
IEEE802.3 标准是
- 逻辑链路控制
- CSMA/CD 访问方法和物理层规范
- 令牌总线访问方法和物理层规范
- 令牌环网访问方法和物理层规范
局域网具有的几种典型的拓扑结构中，一般不含
- 星型
- 环型
- 总线型
- 全连接网型
为采用拨号方式联入 Internet 网络，____是不必要的
- 电话线
- 一个 MODEM
- 一个 Internet 账号
- 一台打印机
计算机网络中，分层和协议的集合称为计算机网络的____。目前应用最广泛的是____。
- 组成结构
- 参考模型
- 体系结构
- 基本功能
- SNA
- MAP/TOP
- TCP/IP
- X.25
- ISO／OSI
在 OSI 的七层参考模型中，工作在第三层以上的网间连接设备是
- 集线器
- 网关
- 网桥
- 中继器
从通信协议的角度来看，路由器是在哪个层次上实现网络互联
- 物理层
- 链路层
- 网络层
- 传输层
Internet 的网络层含有四个重要的协议，分别为
- IP，ICMP，ARP，UDP
- TCP，ICMP，UDP，ARP
- IP，ICMP，ARP，RARP
- UDP，IP，ICMP，RARP
IP 协议是无连接的，其信息传输方式是
- 点对点
- 数据报
- 广播
- 虚电路
TCP/IP 体系结构中的 TCP 和 IP 所提供的服务分别为
- 链路层服务和网络层服务
- 网络层服务和运输层服务
- 运输层服务和应用层服务
- 运输层服务和网络层服务
IP 地址是一个 32 位的二进制，它通常采用点分
- 二进制数表示
- 八进制数表示
- 十进制数表示
- 十六进制数表示
在 IP 地址方案中，159.226.181.1 是一个
- A 类地址
- B 类地址
- C 类地址
- D 类地址
把网络 202.112.78.0 划分为多个子网（子网掩码是 255.255.255.192），则每个子网中可用的主机地址数是
- 254
- 128
- 124
- 62
TCP/IP 网络中常用的距离矢量路由协议是
- ARP
- ICMP
- OSPF
- RIP
在 TCP/IP 协议簇中，TCP、UDP 协议工作在
- 应用层
- 传输层
- 网络互联层
- 网络接口层
在 OSI 网络结构中，HTTP\DHCP 协议工作在
- 应用层
- 传输层
- 网络互联层
- 网络接口层
下面协议中，用于 WWW 传输控制的是
- URL
- SMTP
- HTTP
- HTML
域名服务器上存放有 Internet 主机的
- 域名
- IP 地址
- 域名和 IP 地址
- E-mail 地址
在 Internet 域名体系中，域的下面可以划分子域，各级域名用圆点分开，按照
- 从左到右越来越小的方式分 4 层排列
- 从左到右越来越小的方式分多层排列
- 从右到左越来越小的方式分 4 层排列
- 从右到左越来越小的方式分多层排列
在 Internet/Intranet 中，不需要为用户设置帐号和口令的服务是
- WWW
- FTP
- E-mail
- DNS
下面协议中，用于电子邮件 Email 传输控制的是
- SNMP
- SMTP
- HTTP
- HTML
世界最早投入运行的计算机网络是 ARPANET
计算机网络的体系结构是一种分层结构
OSI 参考模型采用了 7 层的体系结构
串行数据通信的方向性结构有三种，即单工、半双工和全双工。
因特网提供服务所采用的模式是客户端 / 服务器
按照实际的数据传送技术，交换网络又可分为电路交换网、报文交换网和分组交换网。
两种最常使用的多路复用技术是：频分多路复用和时分多路复用。
当数据报在物理网络中进行传输时，IP 地址被转换成物理地址。
用电路交换技术完成的数据传输要经历电路建立、数据传输和电路拆除过程。
局域网中所使用的双绞线分成两类，即屏蔽双绞线和非屏蔽双绞线。
计算机网络中常用的三种有线媒体是同轴电缆、双绞线和光纤。
在 IEEE802 局域网体系结构中，数据链路层被细化成 LLC 逻辑链路控制子层和 MAC 介质访问控制子层两层。
T1 系统的传输速率为 1.544Mbps，E1 系统的数据传输速率为 2.048Mbps。
曼彻斯特编码是一种同步方式为自同步的编码方案。
在计算机的通信子网中，其操作方式有两种，它们是面向连接的虚电路和无连接的数据报。
运输层的运输服务有两大类：面向连接的服务和无连接的服务。
TCP 在 IP 的基础上，提供端到端的面向连接的可靠传输。
子网掩码的作用是判断两台主机是否在同一子网中。
标准的 B 类 IP 地址使用 16 位二进制数表示网络号。
在 TCP/IP 层次模型的网络层中包括的协议主要有 IP、ICMP、ARP 及 RARP。
32 位全为 1 (255.255.255.255) 的 IP 地址叫做有限广播地址，用于本网广播。
如果路由表发生错误，数据报可能进入循环路径，无休止地在网络中流动。利用 IP 报头中的生存周期 / TTL 可以防止这一情况的发生。
在 TCP/IP 层次模型中运输层相对应的主要协议有 TCP（传输控制协议）和 UDP（用户数据报协议）。
到达通信子网中某一部分的分组数量过多，使得该部分乃至整个网络性能下降的现象，称为拥堵现象。
域名系统 DNS 是一个分布式数据库系统。
WWW 上的每一个网页都有一个独立的地址，这些地址称为统一资源定位器。
在 WWW 中，使用统一资源定位器 URL 来唯一地标识和定位因特网中的资源，它由三部分组成：协议、主机地址（域名）、文件路径名。
支持在电子邮件中传输汉字信息的协议是 MIME。

网络是怎样连接的-其二

2020-03-31T06:09:29.000Z

# 电信号传输 TCP/IP 数据

# 协议栈

TCP、UDP、ICMP
IP、ARP

一般来说，浏览器、邮件等应用程序使用 TCP 协议；DNS 查询这种收发较短的控制数据的时候则使用 UDP。

ICMP 用于告知网络包传送过程中产生的错误和各种控制信息
ARP 用于根据 IP 地址查询 MAC 地址

# 套接字的实体

套接字是抽象概念，那它的实体代表什么呢？

在协议栈内部，有一块存放控制信息的内存空间，记录了用于通信操作的控制信息。例如：对象的 IP 地址、端口号、通信操作的进行状态等。

# 查看套接字信息

Windows 下：

netstat -ano

	Proto Local Address Foreign Address State PID
	TCP 0.0.0.0:135 0.0.0.0:0 LISTENING 984
	TCP 10.10.1.16:1031 10.10.1.80:139 ESTABLISHED 4

使用协议、本地 IP 和端口、对方的 IP 和端口、通信状态、进程编号

LISTENING 表明是在等待被连接，因此 Foreign Address 还不知道。本地的 IP 也还不知道。

ESTABLISHED 表明已经建立连接，可以进行通信了。

# 连接的意义

将本身的 IP 和端口告诉对方，这样才相互知道双方的 IP，才能建立通道，进行通信。

并不像网线的连接概念；网线是一直连接的，并没有断开。

# 负责保存控制信息的头部

每次通信都需要这些控制信息，因此进行通信时，这些控制信息都放在网络包的开头。

TCP 头部结构：

发送方端口号（2 字节）、接收方端口号（2 字节）
序号（4 字节）
ACK（4 字节）
数据偏移量（4 位）、保留（6 位）、控制位（6 位）、窗口（2 字节）
校验和（2 字节）、紧急指针（2 字节）
可选字段（可变长度，可有可无）

解释：

序号：发送数据的顺序编号
ACK：接收数据的顺序编号
数据偏移量：数据部分的起始位置，因为头部占用一定空间，也就是头部的长度。
控制位：URG、ACK、PSH、RST、SYN、FIN
窗口：接收方告知发送方窗口大小
紧急指针：应急处理的数据位置
可选字段，一般连接阶段使用，平时很少使用

除了可选字段，前面已经占用 20 字节；而且头部最多可用 60 字节；因此：可选字段，最多只有 40 字节，而且是 4 的整数倍。

# 收发数据

数据不会立即被发送出去的，有一个缓冲区。根据不同策略发送。

立即发送可能会导致出现很多小的网络包，效率不高。

立即发送，由应用层控制。
缓冲区长度达到 MSS 或接近，才发送。
计时器，达到一定时间后，发出去。

浏览器这种会话类型的应用，需要立即发送，这样交互时间才降低。

如果交互频率很低，缓冲区导致延时时间发送，因此需要计时器，到达时间，即使缓冲区没满，也需要发出了。

# MTU、MSS

MTU：最大传输单元（Maximum Transmission Unit），一个网络包允许的最大长度，以太网中是 1500 字节。

MSS：最大分段大小（Maximum Segment Siz），去掉头部，剩余真正的数据的长度。

# 拆分

如果传输的数据很长，就需要按 MSS 进行拆分。每个分段，都加上 TCP 头部。

# ACK 确认网络包收到

网络包组装好，就开始发送了，发送之后，还没有结束，还有一个确认的过程。

确认原理
拆分的数据，会有一个序号。好处

数据不会乱，有序，接收方能知道是否遗漏。
能确认每个分段都收到。

接收方收到一个网络包后，就将此序号，写入 TCP，以及 ACK 确认，然后发送给发送方。

序号不是从 1 开始的，而是连接的时候，初始化阶段，是随机的一个值，从这个值开始累计。

这样可以防止通信过程可预测，防止被攻击。

# 连接阶段

因为是双向通信的，因此双方都有初始的序号，需要通知对方。

连接阶段：

发送方：发送，【初始的序号 x】、SYN
接收方：发送，ACK、【ACK：x+1】、SYN、【初始的序号 y】
发送方：发送，ACK、【ACK：y+1】

这样，就能知道双方的初始的序号了。

SYN + 初始的序号
ACK + 确认序号

# 动态调整 ACK 号的等待时间

当网络传输繁忙时就会发生拥堵，ACK 号返回就变慢。这时候就要延长等待 ACK 的时间了。否则会认为丢失了该网络包而重新传送。

本来网络传输已经繁忙了，这时候出现不必要的重传，那加重网络的拥堵。

ACK 号的返回，时间可能随机的，因此不能固定一个等待时间，需要动态的调整。

监测 ACK 号的返回时间，如果返回变慢了，则相应延长等待时间；相反地，如果返回时间变快了，则相应缩短等待时间。

# 使用窗口有效管理 ACK 号

每发送一个包就等待一个 ACK 号的方式是最简单的，但在等待这段时间什么也做不了，就很浪费了。

因此引入滑动窗口。

滑动窗口：发送一个包后，不等待 ACK 号返回，而是直接发送后续一系列包。这样就可以有效利用这段等待时间了。

但不断发送一系列包，可能导致接收方处理不过来。

首先，接收方要告诉发送方，自己最多能接收多少数据。
发送方根据这个值，对数据进行发送操作。
发送方发完了这个值的数量，就等待发送。
接收方接收后，就确认 ACK 的时候，告知对方，自己目前新的、可用的大小。
发送方接收到 ACK 后，得到对方的窗口大小，就可以继续根据窗口大小发送网络包。

TCP 调优的一个参数：窗口大小。

# ACK 和窗口的合并

如果每次 ACK 都发送，以及窗口需要更新，也独立发送网络包，这样就增加的网络包的数量。

因此，接收方，并不马上发送 ACK 包，而是等待一段时间发送 ACK 包，可以连续处理多个包，然后发送最后一个 ACK 的包；因此可以减少网络包的数量。

以及，窗口需要更新时，也可以在 ACK 包中携带，因此又可以减少因窗口更新而导致的网络包增加。

这就是 ACK 和窗口更新的控制数据的合并。

# 断开连接

数据发送完毕后，就可以断开连接了。

协议栈允许任何一方先发起断开过程，因此断开顺序取决于应用本身。

Web 服务器返回响应信息后，服务器先发起断开。

服务器发送：FIN
客户端发送：ACK
客户端发送：FIN
服务器发送：ACK

这里为什么客户端发送 ACK 和 FIN 分开呢？

因为服务器需要关闭，因此通知客户端；而客户端可能并不打算立即就断开本身，因此先发 ACK 确认自己收到对方的断开操作。然后根据本身再发送 FIN 通知对方，等待对方的确认。

客户端可能这时候还没处理缓冲区的数据，因此不会在 ACK 的同时，立即断开，等待处理完成缓冲区的数据后，再发送 FIN 断开。

# 删除套接字

套接字要在双方都发送 FIN 和确认 ACK 后，才删除套接字；这样可以防止误操作。

如果对方提早删除套接字，则可能对方没收到 FIN 包，因此可能会重复发送 FIN 包。

# 总结

连接阶段：

发送方发送：SYN、【初始的序号 x】、【窗口大小】
接收方发送：【ACK：x+1】、【窗口大小】、SYN、【初始的序号 y】
发送方发送：【ACK：y+1】

通信阶段：

发送方：【序号】【数据】
接收方：【ACK 号】【窗口】

断开阶段：

发送方：FIN
接收方：【ACK 号】
接收方：FIN
发送方：【ACK 号】
双方删除套接字

TCP 模块需要底层的 IP 模块

IP 模块负责添加如下两个头部：

MAC 头部：以太网的头部，包含 MAC 地址
IP 头部：IP 用的头部，包含 IP 地址。

# IP 模块

无论要收发的包是控制包，还是数据包，IP 对各种类型的包的收发操作都是相同的。

# IP 头部

版本号（4b）、头部长度（4b）、服务类型（1B）、总长度（2B）
ID 号（2B）、标志（3b）、分片偏移量（13b）
生存时间（1B）、协议号（1B）、头部校验和（2B）
发送方 IP 地址（4B）
接收方 IP 地址（4B）
可选字段：可变长度

解释：

版本号：4，IPv4
服务类型：包传输优先级，该字段比较模糊，DiffServ 规格重新定义
总长度：IP 消息总长度
ID 号：包的序列号，如果分片，则所有分片都有相同的 ID
标志：仅 2 比特有效，即是否允许分片，以及当前是否为分片包
分片偏移量：当前数据是第几个字节开始的
生存时间：每经过一个路由器就减 1 ，直到 0 丢弃
协议号：0x06 - TCP；0x11 - UDP；0x01 - ICMP
校验和：现在不用了

# 网卡的选择

接收方 IP 地址直接是对方的 IP 地址，但发送方如果有多个网卡，有多个 IP 地址，那应该选哪个呢？

根据系统配置的路由表，匹配是否有相同子网下的 IP，因此使用此 IP，如果没有则使用默认的路由表

# 添加 MAC 头部

接收方 MAC 地址（6 字节）
发送方 MAC 地址（6 字节）
以太类型（2 字节）

类型：

0000-05DC：IEEE 802.3
0800：IP 协议
0806：ARP 协议
86DD：IPv6

一般使用 0800 和 0806

发送方，通过 IP 就可以知道是哪快网卡，因此可以直接知道 MAC 地址；

而接收方，知道 IP 地址，但还未知对方的 MAC 地址；

因此需要通过对方 IP 地址，查询对方的 MAC 地址。

# ARP 查询目标路由器的 MAC 地址

ARP 利用广播，询问目标主机的 MAC 地址。

查询到的目标主机的 MAC 地址，会缓存起来；下次查询时，可以直接获取。

ARP 缓存删除比较简单粗暴，一般经过几分钟，所有缓存都清空。

# 为什么以太网的包，需要 IP 模块来组装？

以太网的结构，应该由以太网来封装，但为什么由上层来封装呢？

因为由上层来封装，则可以实现各种类型的协议，IP 协议、ARP 协议等等；这样就不需要以太网层来考虑类型了，直接发送网络包即可。

# 以太网基础知识

# 以太网结构的演变

10BASE5（以太网原型）
- 信号通过网线流过整个网络
10BASE-T
- 信号通过中继式集线器扩散到整个网络。使用双绞线，以及使用中继式集线器替换骨干网线。因此，结构改变，但性质不变。
交换式集线器
- 交换式集线器会根据接收方的 MAC 地址，将包发送到指定的目的地。因此，信号只会到达指定设备。
- 交换式集线器和中继式集线器结构一样，但信号发送方式不同。

以上三种的变迁，但以太网封装是不变的。

# IP 包转换成电 / 光信号传输

# 网卡

不同厂商的网卡，需要不同的驱动，这集成于操作系统中了，因此可以直接使用。

网卡结构
包含：MAC、缓冲区、ROM、PHY（MAU）、RJ-45 接口等

ROM 储存全球唯一的 MAC 地址，代表此网卡的地址，厂商生产时，烧录进去的。

网卡中的 MAC 地址由驱动读取，然后分配给 MAC 模块

# 网卡添加控制数据

MAC 模块从网卡缓冲区中取出帧，然后头部添加报头和起始帧分界符，尾部添加帧校验序列（FCS），用于错误校验。

头部添加的是 1 和 0 的交替，56 bit。

这用于确定读取的时机：1 和 0 的交替，可以测量 1 到 0 这段时间，作为读取数据的间隔。

起始帧分隔符是以 11 结尾的。

报头（56 bit，1 和 0 交替）
起始帧分隔符（8 bit，结尾是 11）：1010 1011

起始帧分隔符（SFD）用于测量帧的起始位置

电信号通过电压高低来确定 1 或 0，但如果是连续的电压，变化不大，那么从哪里划分数据呢？

因此需要时钟信号。

合并数据信号和时钟信号，合并的信号，容易读取数据。

合并规则：

高 + 高 = 低
低 + 低 = 低
高 + 低 = 高
低 + 高 = 高

如果单独发送数据信号和时钟信号，网线较长时，导致传输数据信号和时钟信号产生时间差，时钟就会发生偏移。

因此数据信号需要叠加时钟信号，然后发送叠加的信号。

因此，如果能知道发送方的时钟信号的周期，就能读取叠加信号。

通过统计一段时间，可以知道发送方时钟信号的周期，因此，报头的作用就是提供给接收方统计用的，统计出发送方的时钟周期，进而读取叠加信号的数据。

末尾的 FCS 也是用于检验因噪声导致信号紊乱导致的数据错误。

# 向集线器发送信号

集线器是半双工的；交换机是全双工的。

集线器可能会发生信号冲突，因此发送前，需要检测网线是否有其它设备发送。

MAC 模块将数据转成通用的电信号，然后由 PHY 或 MAU 模块发送出去。

转换成电信号的速率，即为传输速率。

PHY 会将电信号转成不同网线规格的信号。网线传输情况很复杂。有很多编码，这些不同编码导致发送的速率不同。

举例：4B/5B、曼彻斯特编码...

PHY 还要检测线路是否已经有其它设备发送信号了。

如果发生冲突，则通信终止，然后发送一段时间阻塞，即等待一段时间，然后再发送，如果再有冲突，则延长一倍等待时间，如果重试 10 次都冲突，就报告通信错误。

全双工就不会发生信号冲突，也因此简单很多。

# 接收信号

集线器半双工模式，设备发送的信号，连接同一个集线器的都接收到信号，因此所有设备都接收集线器上的信号。

PHY 模块将解码电信号（取决于网线，以及编码），转成通用的电信号
MAC 模块处理电信号，转成数字信息，然后放到缓冲区。到达 FCS 结尾，还要校验数据是否错误。错误就丢弃。
FCS 校验没问题，就检查头部 MAC 接收地址，是否为本网卡的 MAC 地址，如果不匹配，则不是发给此网卡的，则抛弃。
MAC 地址一致时，才返回到协议层，然后到应用层。

网卡驱动程序也不是一直监控网卡的活动，因此网卡通过中断机制通知网卡驱动程序。

网卡通过扩展总线的中断线路发送中断信号。中断线路连接 CPU，CPU 暂时挂起其它任务，然后切换到操作系统的中断程序。中断程序调用网卡驱动，然后通知到了网卡驱动，驱动程序就开始读取网卡数据。

中断信号都有一个编号的。网卡安装时，就设置了一个中断编号，网卡的中断号和驱动程序中断号绑定起来。

现代设备都是可以通过即插即用的方式，自动设置中断号，就不用手动设置了。

# IP 模块到 TCP 模块

网卡驱动将数据交给协议栈处理。

先由 IP 模块处理，如果接收方 IP 不匹配，则抛弃数据，客户端不做转发功能，以及，返回 ICMP 通知错误。

ICMP 错误消息有很多种类。

ICMP 包含在 IP 报文中

以及增加 ICMP 头部信息

类型（1 字节）、代码（1 字节）、校验和（2 字节）
内容

ping 使用 ICMP 协议类型的：8，0

traceroute 使用 ICMP 协议

# UDP 协议的收发

# 不需要重发的 UDP 更高效

TCP 复杂是由于要确保可靠，需要确保对方收到，没收到就要重发。

但有些简单的包，没有分片，就只有一个包，因此，就算对方没收到，也只需重发此包即可。

# UDP 协议头部

像 DNS 这种查询的只需要 1 个包就能解决。

UDP 没有确认机制、窗口等，因此不需要建立、连接；只需要获取对方端口信息，就可以直接发送了。

遇到错误的包，丢包，也不用处理。UDP 只管发送。

发送方端口（2 字节）、接收方端口（2 字节）
数据长度（2 字节）、校验和（2 字节）

# UDP 的使用场景

音频和视频

因为音频和视频要求时效性，如果掉帧了，播放就卡掉。但这时候再重传，也挽回不了画面卡掉的情况。因此就放弃了重传。

产生少量的失真和卡顿，也是可以接受的；如果存在大量的这种情况，那即使重传也解决不了问题，而是要提高传输速率。

网络是怎样连接的-其一

2020-03-30T06:09:29.000Z

# 浏览器访问资源

# URL

统一资源定位符（Uniform Resource Locator）

# 格式

# HTTP 协议

http://user:password@www.example.com:80/dir/file1.htm

协议
用户名、密码，可省略
web 服务器域名
端口，可省略
文件路径名

# FTP 协议

ftp://user:password@ftp.example.com:21/dir/file1.htm

协议
用户名、密码，可省略
FTP 服务器域名
端口，可省略
文件路径名

# 本地文件

file://localhost/c:/path/file1.zip

协议
计算机名，可省略
文件的路径名

# 电子邮件

mailto:toUser@example.com

# 新闻

news:comp.protocols.tcp-ip

# 生成 HTTP 请求消息

请求信息

	<方法><空格><URI><空格><HTTP版本>
	<字段名>:<字段值>
	...
	...
	<空行>
	<消息体>

# HTTP 响应信息

响应信息

	<HTTP版本><空格><状态码><空格><响应描述>
	<字段名>:<字段值>
	...
	...
	<空行>
	<消息体>

# DNS 查询服务器 IP 地址

# IP

# 表示方式

# 点分十进制

每 8 bit 用。分隔。

10.11.12.13

# 子网掩码

10.11.12.13/255.255.255.0

# 比特数的子网掩码

10.11.12.13/24

前 24 位全为 1，剩余为 0，表示主机数。

IP 可以得出网络号
除了网络号，剩余的位数，继续用子网掩码划分
子网掩码 + 网络号，得出子网号，剩余的才是这个子网的主机号。

# 代表整个子网

10.11.12.0/24

# 子网内广播

10.11.12.255/24

# DNS 解析

DNS（Domain Name System）查询 IP 地址的操作，称为域名解析，负责执行此操作的为解析器。

# 查询条件

域名
Class：目前只固定 IN
记录类型：A - 地址；MX - Mail eXchange

	域名 Class 记录类型响应数据
	www.lab.glasscom.com IN A 192.0.2.226
	glasscom.com IN MX 10 mail.glasscom.com
	mail.glasscom.com IN A 192.0.2.227

邮箱还有一个优先级

# 域名分层

使用英文句点来划分，靠右层级越高。

例如： www.lab.glasscom.com

一级域名：com
二级域名：glasscom
三级、四级：lab、www

# 根域服务器

它没有名字，如果要表示，就在域名最右边添加句点，例如：

www.lab.glasscom.com.

全球目前只有 13 台根域服务器，这些都配置在主机中的。

当然还有成千上万台镜像 DNS 服务器，会定时更新根域服务器的数据。

# 查找过程

www.lab.glasscom.com. 域名的查找过程

从主机配置的 DNS 服务器查找；配置是系统 TCP/IP 自动配置好的，或者手动配置。
查找不到了，再从最高级别查起，即根域或其镜像 DNS 服务器查找
没有再从 com 的 DNS 服务器查找
然后一级一级的查询，直到查询或到达最低级域名 DNS 为止。

当然，DNS 服务器可能包含多级的域名注册信息，因此不用查询多次。以及 DNS 服务器有缓存。

低级的域名都会注册到高级的域名服务器中。

例如：一级域名 com、cn 等的域名都注册到根域服务器中。

# DNS 使用 TCP 还是 UDP？

两者都使用：

在局域网中使用 UDP
在跨越较远的根服务器、一级等，用 TCP

# 委托协议栈发送信息

得到对方的 IP 后，就可以委托系统的 Socket 库来收发数据。

Socket 建立两者之间的通道，数据在通道中流动。

流程：

双方创建套接字（创建阶段）
客户端连接服务器的套接字上（连接阶段）
收发数据（通信阶段）
断开管道并删除套接字（断开阶段）

应用程序

	// DNS
	<内存地址> = gethostbyname("www.lab.glasscom.com");

	// 创建阶段
	<描述符> = socket(<IPv4>, <流模式>, ...);

	// 连接阶段
	connect(<描述符>, <服务器的 IP 地址和端口>, ...);

	// 通信阶段
	write(<描述符>, <发送数据>, <数据长度>);

	<接收数据长度> = read(<描述符>, <接收缓冲区>, ...);

	// 断开阶段
	close(<描述符>);

# Socket、socket、套接字区别：

Socket 代表库，包含多种组件
socket 指的是创建套接字的 socket 程序组件
套接字：指的是双方创建的通道

# 创建阶段

使用 socket 组件，创建套接字，协议栈会返回描述符号。

描述符储存在内存中，就类似一个 ID，用于区分是哪个套接字。

# 连接阶段

使用 connect 组件；需要指定描述符、服务器 IP 地址、端口号。

IP 能识别到某台主机，但不知道对方的哪个套接字，因此需要端口号。

端口号能识别到对方的某个套接字

因此连接阶段，通过 IP 和端口号，能连接到对方主机的套接字，完成套接字的连接，形成通道。

# 为什么不使用套接字的描述符代表端口呢？

因为描述符代表的是本机的套接字，是本机识别本机的套接字的；而对方的套接字无法知道。

因此，使用双方约定好的端口号，作为对方的套接字的识别。

# 通信阶段：传递消息

通过 write 和 read 来读写消息，实现传递消息。

例如，HTTP，生成 HTTP 请求报文，然后调用 write 写入通道中，服务器通过 read 读取通道的数据。

# 断开阶段

使用 close 组件，断开和删除套接字，通道关闭。

HTTP 协议规定，web 服务器发送完响应消息后，先断开；然后浏览器知道断开后，也会调用 close 断开。

不同协议，客户端和服务器端哪一方先执行 close 都有可能。

Feign原理简述

2020-03-27T06:09:29.000Z

# Feign 原理简述

@EnableFeignClients 开启扫描，扫描包下的所有 @FeignClient，然后注入到 IOC 容器中。
调用 feign 接口，通过 JDK 动态代理生成 RequestTemplate。
RequestTemplate 是模版，包含请求所有信息，然后生成 Request，Request 交给 client 处理，client 默认是 JDK 的 HTTPUrlConnection，也可以是 OKHttp、Apache 的 HTTPClient 等。
client 封装成 LoadBalanceClient，结合 ribbon 负载均衡发起调用。
调用失败，还有 hystrix 熔断。

Feign、hystrix 与 retry 的关系请参考 https://xli1224.github.io/2017/09/22/configure-feign/

# @EnableXxxx 原理

@EnableXxxx 注解都包含一个 @Import 注解，指定配置类。 [嵌套多一层是为了隐藏细节（配置类，这个使用者不用关注），方便使用者使用，使用者直接一个注解即可，不用任何配置]
@Import 注解的配置类，需要实现接口 ImportSelector，以及实现方法 selectImports，入参是注解元数据，出参是需要导入的类 String []

	cat /proc/sys/net/ipv4/tcp_keepalive_time
	cat /proc/sys/net/ipv4/tcp_keepalive_intvl
	cat /proc/sys/net/ipv4/tcp_keepalive_probes

	net.ipv4.tcp_keepalive_time=7200
	net.ipv4.tcp_keepalive_intvl=75
	net.ipv4.tcp_keepalive_probes=9

	package javax.servlet;

	import java.io.IOException;

	public interface Servlet {
	void init(ServletConfig var1) throws ServletException;

	ServletConfig getServletConfig();

	void service(ServletRequest var1, ServletResponse var2) throws ServletException, IOException;

	String getServletInfo();

	void destroy();
	}