C++问题汇总（一）

野性酷女 2022-04-14 04:35 1161阅读 0赞

### 1.TCP/IP close\_wait状态和time\_wait状态。 ###

TIME\_WAIT 表示主动关闭，CLOSE\_WAIT 表示被动关闭。

CLOSE\_WAIT状态的生成原因  
首先我们知道，如果我们的服务器程序APACHE处于CLOSE\_WAIT状态的话，说明套接字是被动关闭的！

因为如果是CLIENT端主动断掉当前连接的话，那么双方关闭这个TCP连接共需要四个packet：

Client --->  FIN  --->  Server

Client <---  ACK  <---  Server

这时候Client端处于FIN\_WAIT\_2状态；而Server 程序处于CLOSE\_WAIT状态。

Client <---  FIN  <---  Server

这时Server 发送FIN给Client，Server 就置为LAST\_ACK状态。

Client --->  ACK  --->  Server

Client回应了ACK，那么Server 的套接字才会真正置为CLOSED状态。

Server 程序处于CLOSE\_WAIT状态，而不是LAST\_ACK状态，说明还没有发FIN给Client，那么可能是在关闭连接之前还有许多数据要发送或者其他事要做，导致没有发这个FIN packet。

客户端主动关闭时，发出FIN包，收到服务器的ACK，客户端停留在FIN\_WAIT2状态。而服务端收到FIN，发出ACK后，停留在COLSE\_WAIT状态。  
    这个CLOSE\_WAIT状态非常讨厌，它持续的时间非常长，服务器端如果积攒大量的COLSE\_WAIT状态的socket，有可能将服务器资源(套接字描述符耗尽)耗尽，进而无法提供服务。  
    那么，服务器上是怎么产生大量的失去控制的COLSE\_WAIT状态的socket呢？我们来追踪一下。  
    一个很浅显的原因是，服务器没有继续发FIN包给客户端。  
    服务器为什么不发FIN，可能是业务实现上的需要，现在不是发送FIN的时机，因为服务器还有数据要发往客户端，发送完了自然就要通过系统调用发FIN了，这个场景并不是上面我们提到的持续的COLSE\_WAIT状态，这个在受控范围之内。  
    那么究竟是什么原因呢，咱们引入两个系统调用close(sockfd)和shutdown(sockfd,how)接着往下分析。  
    在这儿，需要明确的一个概念---- 一个进程打开一个socket，然后此进程再派生子进程的时候，此socket的sockfd会被继承。socket是系统级的对象，现在的结果是，此socket被两个进程打开，此socket的引用计数会变成2。  
   
    继续说上述两个系统调用对socket的关闭情况。  
    调用close(sockfd)时，内核检查此fd对应的socket上的引用计数。如果引用计数大于1，那么将这个引用计数减1，然后返回。如果引用计数等于1，那么内核会真正通过发FIN来关闭TCP连接。  
    调用shutdown(sockfd，SHUT\_RDWR)时,内核不会检查此fd对应的socket上的引用计数，直接通过发FIN来关闭TCP连接。  
   
     现在应该真相大白了，可能是服务器的实现有点问题，父进程打开了socket，然后用派生子进程来处理业务，父进程继续对网络请求进行监听，永远不会终止。客户端发FIN过来的时候，处理业务的子进程的read返回0，子进程发现对端已经关闭了，直接调用close()对本端进行关闭。实际上，仅仅使socket的引用计数减1，socket并没关闭。从而导致系统中又多了一个CLOSE\_WAIT的socket

# 2.用extern声明外部变量 #

全局变量(外部变量)是在函数的外部定义的，它的作用域为从变量的定义处开始，到本程序文件的末尾。在此作用域内，全局变量可以为本文件中各个函数所引用。编译时将全局变量分配在静态存储区。  
有时需要用extern来声明全局变量，以扩展全局变量的作用域。  
   
1. 在一个文件内声明全局变量  
如果外部变量不在文件的开头定义，其有效的作用范围只限于定义处到文件终了。如果在定义点之前的函数想引用该全局变量，则应该在引用之前用关键字extern对该变量作外部变量声明，表示该变量是一个将在下面定义的全局变量。有了此声明，就可以从声明处起，合法地引用该全局变量，这种声明称为提前引用声明。  
   
例4.14 用extern对外部变量作提前引用声明，以扩展程序文件中的作用域。  
\#include <iostream>  
using namespace std;  
int max(int,int);              //函数声明  
void main( )  
 \{extern int a,b;               //对全局变量a,b作提前引用声明  
  cout<<max(a,b)<<endl;  
 \}  
int a=15,b=-7;                  //定义全局变量a,b  
int max(int x,int y)  
 \{int z;  
  z=x>y?x：y;  
  return z;  
 \}  
   
运行结果如下：  
15  
在main后面定义了全局变量a，b，但由于全局变量定义的位置在函数main之后，因此如果没有程序的第5行，在main函数中是不能引用全局变量a和b的。现在我们在main函数第2行用extern对a和b作了提前引用声明，表示a和b是将在后面定义的变量。这样在main函数中就可以合法地使用全局变量a和b了。如果不作extern声明，编译时会出错，系统认为a和b未经定义。一般都把全局变量的定义放在引用它的所有函数之前，这样可以避免在函数中多加一个extern声明。  
   
2. 在多文件的程序中声明外部变量  
如果一个程序包含两个文件，在两个文件中都要用到同一个外部变量num，不能分别在两个文件中各自定义一个外部变量num。正确的做法是：在任一个文件中定义外部变量num，而在另一文件中用extern对num作外部变量声明。即  
extern int num;  
编译系统由此知道num是一个已在别处定义的外部变量，它先在本文件中找有无外部变量num，如果有，则将其作用域扩展到本行开始(如上节所述)，如果本文件中无此外部变量，则在程序连接时从其他文件中找有无外部变量num，如果有，则把在另一文件中定义的外部变量num的作用域扩展到本文件，在本文件中可以合法地引用该外部变量num。  
   
分析下例：  
file1.cpp                                             file2.cpp  
extern int a,b;                                   int a=3,b=4;  
int main( )                                         ┆  
\{cout<<a<<″,″<<b<<endl;    
 return 0;  
\}  
用extern扩展全局变量的作用域，虽然能为程序设计带来方便，但应十分慎重，因为在执行一个文件中的函数时，可能会改变了该全局变量的值，从而会影响到另一文件中的函数执行结果。

# 3.[extern用法总结][extern] #

在C语言中，修饰符extern用在变量或者函数的声明前，用来说明“此变量/函数是在别处定义的，要在此处引用”。  
  
**1. extern修饰变量的声明。**

如果文件a.c需要引用b.c中变量int v，就可以在a.c中声明extern int v，然后就可以引用变量v。

这里需要注意的是，被引用的变量v的**链接属性**必须是**外链接（external）的**，也就是说a.c要引用到v，不只是取决于在a.c中声明extern int v，还取决于变量v**本身是能够被引用到**的。

这涉及到c语言的另外一个话题－－变量的作用域。能够被其他模块以extern修饰符引用到的变量通常是**全局变量**。

**还有很重要的一点是，extern int v可以放在a.c中的任何地方**，比如你可以在a.c中的函数fun定义的开头处声明extern int v，然后就可以引用到变量v了，只不过这样只能在函数fun作用域中引用v罢了，这还是变量作用域的问题。对于这一点来说，很多人使用的时候都心存顾虑。好像extern声明只能用于文件作用域似的。  
  
**2. extern修饰函数声明。**

从本质上来讲，变量和函数没有区别。函数名是指向函数二进制块开头处的指针。

如果文件a.c需要引用b.c中的函数，比如在b.c中原型是int fun(int mu)，那么就可以在a.c中声明extern int fun（int mu），然后就能使用fun来做任何事情。

就像变量的声明一样，extern int fun（int mu）可以放在a.c中任何地方，而不一定非要放在a.c的文件作用域的范围中。

对其他模块中函数的引用，最常用的方法是包含这些函数声明的头文件。**使用extern和包含头文件来引用函数有什么区别呢？**extern的引用方式比包含头文件要简洁得多！extern的使用方法是直接了当的，想引用哪个函数就用extern声明哪个函数。

这样做的一个明显的好处是，会加速程序的编译（确切的说是预处理）的过程，节省时间。在大型C程序编译过程中，这种差异是非常明显的。  
  
**3. 此外，extern修饰符可用于指示C或者C＋＋函数的调用规范。**

比如在C＋＋中调用C库函数，就需要在C＋＋程序中用extern “C”声明要引用的函数。

这是给链接器用的，告诉链接器在链接的时候用C函数规范来链接。主要原因是C＋＋和C程序编译完成后在目标代码中命名规则不同。

**extern "C"的主要作用就是为了能够正确实现C++代码调用其他C语言代码。加上extern "C"后，会指示编译器这部分代码按C语言的进行编译，而不是C++的。由于C++支持函数重载，因此编译器编译函数的过程中会将函数的参数类型也加到编译后的代码中，而不仅仅是函数名；而C语言并不支持函数重载，因此编译C语言代码的函数时不会带上函数的参数类型，一般之包括函数名。**  
比如说你用C 开发了一个DLL 库，为了能够让C ++语言也能够调用你的DLL输出(Export)的函数，你需要用extern "C"来强制编译器不要修改你的函数名。

### extern "C"的含义 ###

extern "C" 包含双重含义，从字面上即可得到：首先，被它修饰的目标是“extern”的；其次，被它修饰的目标是“C”的。  
被extern "C"限定的函数或变量是extern类型的；  
**1、extern关键字**  
extern是C/C++语言中表明函数和全局变量作用范围（可见性）的关键字，该关键字告诉编译器，其声明的函数和变量可以在本模块或其它模块中使用。  
通常，在模块的头文件中对本模块提供给其它模块引用的函数和全局变量以关键字extern声明。例如，如果模块B欲引用该模块A中定义的全局变量和函数时只需包含模块A的头文件即可。这样，模块B中调用模块A中的函数时，在编译阶段，模块B虽然找不到该函数，但是并不会报错；它会在**链接阶段**中从模块A编译生成的目标代码中找到此函数。  
与extern对应的关键字是static，被它修饰的全局变量和函数只能在本模块中使用。因此，一个函数或变量只可能被本模块使用时，其不可能被extern “C”修饰。

**2、被extern "C"修饰的变量和函数是按照C语言方式编译和链接的**  
首先看看C++中对类似C的函数是怎样编译的。  
作为一种面向对象的语言，C++支持函数重载，而过程式语言C则不支持。函数被C++编译后在符号库中的名字与C语言的不同。例如，假设某个函数的原型为：  
void foo( int x, int y );  
该函数被C编译器编译后在符号库中的名字为\_foo，而C++编译器则会产生像\_foo\_int\_int之类的名字（不同的编译器可能生成的名字不同，但是都采用了相同的机制，生成的新名字称为“mangled name”）。  
\*\* \_foo\_int\_int这样的名字包含了函数名、函数参数数量及类型信息，C++就是靠这种机制来实现函数重载的。\*\* 例如，在C++中，函数void foo( int x, int y )与void foo( int x, float y )编译生成的符号是不相同的，后者为\_foo\_int\_float。  
同样地，C++中的变量除支持局部变量外，还支持类成员变量和全局变量。用户所编写程序的类成员变量可能与全局变量同名，我们以"."来区分。而本质上，编译器在进行编译时，与函数的处理相似，也为类中的变量取了一个独一无二的名字，这个名字与用户程序中同名的全局变量名字不同。

[https://www.jianshu.com/p/5d2eeeb93590][https_www.jianshu.com_p_5d2eeeb93590]

[**static关键字作用**][static]

1.  static修饰局部变量？

**1. 1. static全局变量与普通的全局变量有什么区别 ?**

**　**　全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。

全局变量本身就是静态存储方式， 静态全局变量当然也是静态存储方式。 这两者在存储方式上并无不同。

这两者的区别在于非静态全局变量的作用域是整个源程序， 当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。 而静态全局变量则限制了其作用域， 即只在定义该变量的源文件内有效， 在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用，因此可以避免在其它源文件中引起错误。

**　　**static全局变量只初使化一次，防止在其他文件单元中被引用;

**1.2.  static局部变量和普通局部变量有什么区别 ？**

把局部变量改变为静态变量后是改变了它的存储方式即改变了它的**生存期**。把全局变量改变为静态变量后是改变了它的**作用域**，限制了它的使用范围。

static局部变量只被初始化一次，下一次依据上一次结果值；

**1.3static函数与普通函数有什么区别？**

static函数与普通函数作用域不同,仅在本文件。只在当前源文件中使用的函数应该说明为内部函数(static修饰的函数)，内部函数应该在当前源文件中说明和定义。对于可在当前源文件以外使用的函数，应该在一个头文件中说明，要使用这些函数的源文件要包含这个头文件.

static函数在内存中只有一份，普通函数在每个被调用中维持一份拷贝

1.  static全局变量？(限定变量在一个编译单元内，一个编译单元就是指一个cpp和它包含的头文件，这个回答可以结合编译需要经历的几个过程来答)
2.  static修饰普通函数？
3.  static修饰成员变量?
4.  static修饰成员函数？
5.  strcpy和memcpy主要有以下3方面的区别。  
    1、复制的内容不同。strcpy只能复制字符串，而memcpy可以复制任意内容，例如字符数组、整型、结构体、类等。  
    2、复制的方法不同。strcpy不需要指定长度，它遇到被复制字符的串结束符"\\0"才结束，所以容易溢出。memcpy则是根据其第3个参数决定复制的长度。  
    3、用途不同。通常在复制字符串时用strcpy，而需要复制其他类型数据时则一般用memcpy
6.  # **volatile是干啥的** #
    
    1.  访问寄存器要比访问内存要块，因此CPU会优先访问该数据在寄存器中的存储结果，但是内存中的数据可能已经发生了改变，而寄存器中还保留着原来的结果。为了避免这种情况的发生将该变量声明为volatile，告诉CPU每次都从内存去读取数据。
    2.  一个参数可以即是const又是volatile的吗？可以，一个例子是只读状态寄存器，是volatile是因为它可能被意想不到的被改变，是const告诉程序不应该试图去修改他。
7.  **说说const的作用，越多越好**
    
    1.  const修饰全局变量；
    2.  const修饰局部变量；
    3.  const修饰指针，const int \*；
    4.  const修饰指针指向的对象, int \* const；
    5.  const修饰引用做形参；
    6.  const修饰成员变量，必须在构造函数列表中初始化；
    7.  const修饰成员函数，说明该函数不应该修改非静态成员，但是这并不是十分可靠的，指针所指的非成员对象值可能会被改变
8.  [**new与malloc区别**][new_malloc]
    
    1.  new分配内存按照数据类型进行分配，malloc分配内存按照大小分配；
    2.  new不仅分配一段内存，而且会调用构造函数，但是malloc则不会。new的实现原理？但是还需要注意的是，之前看到过一个题说int\* p = new int与int\* p = new int()的区别，因为int属于C++内置对象，不会默认初始化，必须显示调用默认构造函数，但是对于自定义对象都会默认调用构造函数初始化。翻阅资料后，在C++11中两者没有区别了，自己测试的结构也都是为0；
    3.  new返回的是指定对象的指针，而malloc返回的是void\*，因此malloc的返回值一般都需要进行类型转化；
    4.  new是一个操作符可以重载，malloc是一个库函数；
    5.  new分配的内存要用delete销毁，malloc要用free来销毁；delete销毁的时候会调用对象的析构函数，而free则不会；
    6.  malloc分配的内存不够的时候，可以用realloc扩容。扩容的原理？new没用这样操作；
    7.  new如果分配失败了会抛出bad\_malloc的异常，而malloc失败了会返回NULL。因此对于new，正确的姿势是采用try…catch语法，而malloc则应该判断指针的返回值。为了兼容很多c程序员的习惯，C++也可以采用new nothrow的方法禁止抛出异常而返回NULL；
    8.  new和new\[\]的区别，new\[\]一次分配所有内存，多次调用构造函数，分别搭配使用delete和delete\[\]，同理，delete\[\]多次调用析构函数，销毁数组中的每个对象。而malloc则只能sizeof(int) \* n；
    9.  如果不够可以继续谈new和malloc的实现，空闲链表，分配方法(首次适配原则，最佳适配原则，最差适配原则，快速适配原则)。delete和free的实现原理，free为什么直到销毁多大的空间？
9.  [**C++多态性与虚函数表**][C]
    
    1.  C++多态的实现？   
        多态分为静态多态和动态多态。静态多态是通过重载和模板技术实现，在编译的时候确定。动态多态通过虚函数和继承关系来实现，执行动态绑定，在运行的时候确定。   
        动态多态实现有几个条件：   
        (1) 虚函数；   
        (2) 一个基类的指针或引用指向派生类的对象；   
        基类指针在调用成员函数(虚函数)时，就会去查找该对象的虚函数表。虚函数表的地址在每个对象的首地址。查找该虚函数表中该函数的指针进行调用。   
        每个对象中保存的只是一个虚函数表的指针，C++内部为每一个类维持一个虚函数表，该类的对象的都指向这同一个虚函数表。   
        虚函数表中为什么就能准确查找相应的函数指针呢？因为在类设计的时候，虚函数表直接从基类也继承过来，如果覆盖了其中的某个虚函数，那么虚函数表的指针就会被替换，因此可以根据指针准确找到该调用哪个函数。
    2.  虚函数的作用？

虚函数用于实现多态，这点大家都能答上来

但是虚函数在设计上还具有封装和抽象的作用。比如抽象工厂模式。

*  动态绑定是如何实现的？

第一个问题中基本回答了，主要都是结合虚函数表来答就行。[静态多态和动态多态][Link 1]。静态多态是指通过模板技术或者函数重载技术实现的多态，其在编译器确定行为。动态多态是指通过虚函数技术实现在运行期动态绑定的技术。

*  [**虚函数表**][Link 2]

1.  虚函数表是针对类的还是针对对象的？同一个类的两个对象的虚函数表是怎么维护的？

编译器为每一个类维护一个虚函数表，每个对象的首地址保存着该虚函数表的指针，同一个类的不同对象实际上指向同一张虚函数表。

1.  **纯虚函数如何定义，为什么对于存在虚函数的类中析构函数要定义成虚函数**

为了实现多态进行动态绑定，将派生类对象指针绑定到基类指针上，对象销毁时，如果析构函数没有定义为析构函数，则会调用基类的析构函数，显然只能销毁部分数据。如果要调用对象的析构函数，就需要将该对象的析构函数定义为虚函数，销毁时通过虚函数表找到对应的析构函数。

1.  **析构函数能抛出异常吗**

答案肯定是不能。 C++标准指明析构函数不能、也不应该抛出异常。C++异常处理模型最大的特点和优势就是对C++中的面向对象提供了最强大的无缝支持。那么如果对象在运行期间出现了异常，C++异常处理模型有责任清除那些由于出现异常所导致的已经失效了的对象(也即对象超出了它原来的作用域)，并释放对象原来所分配的资源， 这就是调用这些对象的析构函数来完成释放资源的任务，所以从这个意义上说，析构函数已经变成了异常处理的一部分。

(1) 如果析构函数抛出异常，则异常点之后的程序不会执行，如果析构函数在异常点之后执行了某些必要的动作比如释放某些资源，则这些动作不会执行，会造成诸如资源泄漏的问题。

(2) 通常异常发生时，c++的机制会调用已经构造对象的析构函数来释放资源，此时若析构函数本身也抛出异常，则前一个异常尚未处理，又有新的异常，会造成程序崩溃的问题。

*  **构造函数和析构函数中调用虚函数吗？**

（1）绝对不要在构造函数和析构函数中调用虚函数，他们都不是动态绑定的。

（2）如果析构函数是虚函数，那么可以看到类似动态绑定的效果，但这并不是动态绑定，也并不意味着我们可以随意在析构函数中调用、间接调用虚函数

（3）如果基类存在虚函数，析构函数必须为虚函数，更进一步的讲，如果程序可能会存在 base \*p = new drived() 这样的语句，即使没有虚函数也要有虚析构函数

（4） 为什么会产生这样的效果？？

因为vptr的绑定是发生在对象构造期间的，所以构造函数会有这样一个假设： 我正在构造的对象和我的类型是完全一致的， 同理虚析构函数也会这么假设。所以在构造/析构函数中调用virtual 函数时不会有任何多态效果的。

（5） 那为什么虚析构函数中调用虚函数会有多态？？

因为析构函数本身如果是虚函数的，在执行虚函数之前会通过vptr找到正确的析构函数，然而在那个析构函数调用的虚函数依旧是没有动态绑定。我们看到的"动态绑定"是虚析构函数的动态绑定，而不是析构函数所调用的虚函数的多态

*  **指针和引用的区别**

1.  指针保存的是所指对象的地址，引用是所指对象的别名，
2.  指针需要通过解引用间接访问，而引用是直接访问；
3.  指针可以改变地址，从而改变所指的对象，而引用必须从一而终；
4.  引用在定义的时候必须初始化，而指针则不需要；
5.  指针有指向常量的指针和指针常量，而引用没有常量引用；
6.  指针更灵活，用的好威力无比，用的不好处处是坑，而引用用起来则安全多了，但是比较死板。

*  **指针与数组千丝万缕的联系**
    
    1.  一个一维int数组的数组名实际上是一个int\* const 类型；
    2.  一个二维int数组的数组名实际上是一个int (\*const p)\[n\];
    3.  数组名做参数会退化为指针，除了sizeof

**[智能指针是怎么实现的？什么时候改变引用计数？][Link 3]**

1.  构造函数中计数初始化为1；
2.  拷贝构造函数中计数值加1；
3.  赋值运算符中，左边的对象引用计数减一，右边的对象引用计数加一；
4.  析构函数中引用计数减一；
5.  在赋值运算符和析构函数中，如果减一后为0，则调用delete释放对象。
6.  share\_prt与weak\_ptr的区别？

//share_ptr可能出现循环引用，从而导致内存泄露
 class A
 {
 public:
 share_ptr p;
 };
 
 class B
 {
 public:
 share_ptr<A> p;
 }
 
 int main()
 {
 while(true)
 {
 share_prt<A> pa(new A()); //pa的引用计数初始化为1
 share_prt pb(new B()); //pb的引用计数初始化为1
 pa->p = pb; //pb的引用计数变为2
 pb->p = pa; //pa的引用计数变为2
 }
 //假设pa先离开，引用计数减一变为1，不为0因此不会调用class A的析构函数，因此其成员p也不会被析构，pb的引用计数仍然为2；
 //同理pb离开的时候，引用计数也不能减到0
 return 0;
 }
 
 /*
 ** weak_ptr是一种弱引用指针，其存在不会影响引用计数，从而解决循环引用的问题

*  [**C++四种类型转换**][C 1]：**static\_cast, dynamic\_cast, const\_cast, reinterpret\_cast**
    
    1.  const\_cast用于将const变量转为非const
    2.  static\_cast用的最多，对于各种隐式转换，非const转const，void\*转指针等, static\_cast能用于多态想上转化，如果向下转能成功但是不安全，结果未知；
    3.  dynamic\_cast用于动态类型转换。只能用于含有虚函数的类，用于类层次间的向上和向下转化。只能转指针或引用。向下转化时，如果是非法的对于指针返回NULL，对于引用抛异常。要深入了解内部转换的原理。
    4.  reinterpret\_cast几乎什么都可以转，比如将int转指针，可能会出问题，尽量少用；
    5.  为什么不使用C的强制转换？C的强制转换表面上看起来功能强大什么都能转，但是转化不够明确，不能进行错误检查，容易出错。
 *  **内存对齐的原则**
    
    1.  从0位置开始存储；
    2.  变量存储的起始位置是该变量大小的整数倍；
    3.  结构体总的大小是其最大元素的整数倍，不足的后面要补齐；
    4.  结构体中包含结构体，从结构体中最大元素的整数倍开始存；
    5.  如果加入pragma pack(n) ，取n和变量自身大小较小的一个。
 *  **内联函数有什么优点？内联函数与宏定义的区别？**
    
    1.  宏定义在预编译的时候就会进行宏替换；
    2.  内联函数在编译阶段，在调用内联函数的地方进行替换，减少了函数的调用过程，但是使得编译文件变大。因此，内联函数适合简单函数，对于复杂函数，即使定义了内联编译器可能也不会按照内联的方式进行编译。
    3.  内联函数相比宏定义更安全，内联函数可以检查参数，而宏定义只是简单的文本替换。因此推荐使用内联函数，而不是宏定义。
    4.  使用宏定义函数要特别注意给所有单元都加上括号，\#define MUL(a, b) a \* b，这很危险，正确写法：\#define MUL(a, b) ((a) \* (b))
 *  **C++内存管理**
    
    1.  C++内存分为那几块？（堆区，栈区，常量区，静态和全局区）

在C++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。   
      **栈**，就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。里面的变量通常是局部变量、函数参数等。   
      **堆**，就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete。如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。   
      **自由存储区**，就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free来结束自己的生命的。   
      **全局/静态存储区**，全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。

**常量存储区**，这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改

**详细说明：**  
  
1、栈区（stack）— 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。   
2、堆区（heap） — 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。   
3、全局区（静态区）（static）—，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 - 程序结束后有系统释放   
4、文字常量区—常量字符串就是放在这里的。 程序结束后由系统释放   
5、程序代码区—存放函数体的二进制代码。

1.  每块存储哪些变量？
2.  学会迁移，可以说到malloc，从malloc说到操作系统的内存管理，说道内核态和用户态，然后就什么高端内存，slab层，伙伴算法，VMA可以巴拉巴拉了，接着可以迁移到fork()。

*  **STL里的内存池实现**   
    STL内存分配分为一级分配器和二级分配器，一级分配器就是采用malloc分配内存，二级分配器采用内存池。

二级分配器设计的非常巧妙，分别给8k，16k,…, 128k等比较小的内存片都维持一个空闲链表，每个链表的头节点由一个数组来维护。需要分配内存时从合适大小的链表中取一块下来。假设需要分配一块10K的内存，那么就找到最小的大于等于10k的块，也就是16K，从16K的空闲链表里取出一个用于分配。释放该块内存时，将内存节点归还给链表。  
如果要分配的内存大于128K则直接调用一级分配器。   
为了节省维持链表的开销，采用了一个union结构体，分配器使用union里的next指针来指向下一个节点，而用户则使用union的空指针来表示该节点的地址。

*  **STL里set和map是基于什么实现的。红黑树的特点？**
    
    1.  set和map都是基于红黑树实现的。
    2.  红黑树是一种平衡二叉查找树，与AVL树的区别是什么？AVL树是完全平衡的，红黑树基本上是平衡的。
    3.  为什么选用红黑数呢？因为红黑数是平衡二叉树，其插入和删除的效率都是N(logN)，与AVL相比红黑数插入和删除最多只需要3次旋转，而AVL树为了维持其完全平衡性，在坏的情况下要旋转的次数太多。  
        红黑树的定义：   
        (1) 节点是红色或者黑色；   
        (2) 父节点是红色的话，子节点就不能为红色；   
        (3) 从根节点到每个页子节点路径上黑色节点的数量相同；   
        (4) 根是黑色的，NULL节点被认为是黑色的。
 *  **STL里的其他数据结构和算法实现也要清楚**   
    这个问题，把STL源码剖析好好看看，不仅面试不慌，自己对STL的使用也会上升一个层次。
 *  **必须在构造函数初始化式里进行初始化的数据成员有哪些**   
    (1) 常量成员，因为常量只能初始化不能赋值，所以必须放在初始化列表里面   
    (2) 引用类型，引用必须在定义的时候初始化，并且不能重新赋值，所以也要写在初始化列表里面   
    (3) 没有默认构造函数的类类型，因为使用初始化列表可以不必调用默认构造函数来初始化，而是直接调用拷贝构造函数初始化
 *  [**模板特化**][Link 4]  
    (1) 模板特化分为全特化和偏特化，模板特化的目的就是对于某一种变量类型具有不同的实现，因此需要特化版本。例如，在STL里迭代器为了适应原生指针就将原生指针进行特化。
 *  [**定位内存泄露**][Link 5]  
    (1)在windows平台下通过CRT中的库函数进行检测；   
    (2)在可能泄漏的调用前后生成块的快照，比较前后的状态，定位泄漏的位置   
    (3)Linux下通过工具valgrind检测

char* strcpy(char* dst, const char* src)
 {
 assert(dst);
 assert(src);
 char* ret = dst;
 while((*dst++ = *src++) != '\0');
 return ret;
 }
 //该函数是没有考虑重叠的
 
 char* strcpy(char* dst, const char* src)
 {
 assert((dst != NULL) && (src != NULL));
 char* ret = dst;
 int size = strlen(src) + 1;
 if(dst > src || dst < src + len)
 {
 dst = dst + size - 1;
 src = src + size - 1;
 while(size--)
 {
 *dst-- = *src--;
 }
 }
 else
 {
 while(size--)
 {
 *dst++ = *src++;
 }
 }
 return ret;
 }

*  **手写memcpy函数**

void* memcpy(void* dst, const void* src, size_t size)
 {
 if(dst == NULL || src == NULL)
 {
 return NULL;
 }
 void* res = dst;
 char* pdst = (char*)dst;
 char* psrc = (char*)src;
 
 if(pdst > psrc && pdst < psrc + size) //重叠
 {
 pdst = pdst + size - 1;
 psrc = pdst + size - 1;
 while(size--)
 {
 *pdst-- = *psrc--;
 }
 }
 else //无重叠
 {
 while(size--)
 {
 *dst++ = *src++;
 }
 }
 return ret;
 }

*  **手写strcat函数**

char* strcat(char* dst, const char* src)
    {
        char* ret = dst;
     
        while(*dst != '\0')
            ++dst;
     
        while((*dst++ = *src) != '\0');
        return ret;
    }

*  **手写strcmp函数**

int strcmp(const char* str1, const char* str2)
    {
     
        while(*str1 == *str2 && *str1 != '\0')
        {
            ++str1;
            ++str2;
        }
        return *str1 - *str2;
    }

# 数据结构与算法 #

这一块考察范围太广，主要靠多刷题吧，牛客网，剑指OFFER，LeetCode等。

### [**Hash表**][Hash] ###

*  Hash表实现（拉链和分散地址）
 *  Hash策略常见的有哪些？
 *  STL中hash\_map扩容发生什么？   
    (1) 创建一个新桶，该桶是原来桶两倍大最接近的质数(判断n是不是质数的方法：用n除2到范围内的数) ；   
    (2) 将原来桶里的数通过指针的转换，插入到新桶中(注意STL这里做的很精细，没有直接将数据从旧桶遍历拷贝数据插入到新桶，而是通过指针转换)   
    (3) 通过swap函数将新桶和旧桶交换，销毁新桶。

### [**树**][Link 6] ###

*  二叉树结构，二叉查找树实现；
 *  二叉树的六种遍历；
 *  二叉树的按层遍历；
 *  递归是解决二叉树相关问题的神级方法；
 *  树的各种常见算法题([http://blog.csdn.net/xiajun07061225/article/details/12760493][http_blog.csdn.net_xiajun07061225_article_details_12760493])；
 *  **什么是红黑树？**
    
     *  节点为红色或者黑色；
     *  根节点为黑色；
     *  从根节点到每个叶子节点经过的黑色节点个数的和相同；
     *  如果父节点为红色，那么其子节点就不能为红色。
 *  **红黑树与AVL树的区别**
    
     *  红黑树与AVL树都是平衡树，但是AVL是完全平衡的(平衡就是值树中任意节点的左子树和右子树高度差不超过1)；
     *  红黑树效率更高，因为AVL为了保证其完全平衡，插入和删除的时候在最坏的情况下要旋转logN次，而红黑树插入和删除的旋转次数要比AVL少。
 *  **[Trie树(字典树)][Trie]**
    
     *  每个节点保存一个字符
     *  根节点不保存字符
     *  每个节点最多有n个子节点(n是所有可能出现字符的个数)
     *  查询的复杂父为O(k)，k为查询字符串长度

### **链表** ###

*  链表和插入和删除，单向和双向链表都要会
 *  链表的问题考虑多个指针和递归   
    (1) 反向打印链表(递归)

#include <stdio.h>
 #include <stdlib.h>
 typedef struct Node {
 	int data;
 	struct Node *next;
 }Node ;
 Node *create_list(int *arr,const int len)
 {
 	if(arr==NULL||len<=0)
 	{
 		return NULL;
 	}
 	Node *head = (Node*)malloc(sizeof(Node));
 	head->data = arr[0];
 	Node *p,*q = head;
 	for(int i=1;i<len;i++)
 	{
 		p = (Node*)malloc(sizeof(Node));
 		p->data = arr[i];
 		q->next = p;
 		q = p;
 	}
 	q->next = NULL;
 	return head;
 }
 void rprint(Node *head)
 {
 	if(head==NULL)
 	{
 		return ;
 	} else {
 		rprint(head->next);
 		printf("%d ",head->data);
 	}
 }
 void print(Node *head)
 {
 	Node *p = head;
 	while(p!=NULL)
 	{
 		fprintf(stdout,"%d ",p->data);
 		p = p->next;
 	}
 }
 int main(void)
 {
 	int a[] = {1,2,3,4,5,6,7,8,9};
 	const int len = sizeof(a)/sizeof(int);
 	Node *head = create_list(a,len);
 	print(head);
 	printf("\n");
 	rprint(head);
 	return 0;
 }

如何反转单向链表和双向链表（ 空间复杂度O(1) ）

//反转链表，最简单的就是使用栈了，放进栈里然后拿出来，但这样的操作使用的空间复杂度是O(N)..其实可以做到空间复杂度是O(1)的。
    
    public class C08_RevolveLinked1 {
    	// 单向链表
    	public static class Node {
    		int value;
    		Node next;
     
    		public Node(int value) {
    			this.value = value;
    		}
    	}
     
    	// 反转单向链表
    	public static Node reverseList(Node head) {
    		Node next = null;
    		Node pre = null;
    		while (head != null) {
    			next = head.next;// 备份
    			head.next = pre;// 将头节点的下一个节点指向空（pre）
    			pre = head;// pre指向原来的头节点
    			head = next;// 头节点变为了它的下一节点（向下移动了一位）
    		}
    		return pre;// 因为head是在为空的时候退出的循环，所以应该返回他的上一节点
    	}
     
     
    	// 打印单向链表
    	public static void printList(Node head) {
    		System.out.print("Linked List:");
    		while (head != null) {
    			System.out.print(head.value + " ");
    			head = head.next;
    		}
    		System.out.println();
    	}
    	
    /
    	
    	// 双向链表
    	public static class DoubleNode {
    		int value;
    		DoubleNode last;
    		DoubleNode next;
    		
    		public DoubleNode(int value) {
    			this.value = value;
    		}
    	}
    	// 反转双向链表
    	public static DoubleNode reverseList(DoubleNode head) {
    		DoubleNode pre = null;
    		DoubleNode next = null;
    		while (head != null) {
    			next = head.next;
    			head.next = pre;
    			head.last = next;
    			pre = head;
    			head = next;
    		}
    		return pre;
    	}
     
    	// 打印双向链表
    	// 分正向和反向打印！！
    	public static void printList(DoubleNode head) {
    		System.out.print("Double Linked List: ");
    		DoubleNode end = null;
    		while (head != null) {
    			System.out.print(head.value + " ");
    			end = head;
    			head = head.next;
    		}
    		System.out.print(" ||  ");
    		while (end != null) {
    			System.out.print(end.value + " ");
    			end = end.last;
    		}
    		System.out.println();
    	}
     
    	public static void main(String[] args) {
    		Node head1 = new Node(1);
    		head1.next = new Node(2);
    		head1.next.next = new Node(3);
    		printList(head1);
    		head1 = reverseList(head1);
    		printList(head1);
     
    		System.out.println("==================");
     
    		DoubleNode head2 = new DoubleNode(1);
    		head2.next = new DoubleNode(2);
    		head2.next.last = head2;
    		head2.next.next = new DoubleNode(3);
    		head2.next.next.last = head2.next;
    		head2.next.next.next = new DoubleNode(4);
    		head2.next.next.next.last = head2.next.next;
    		printList(head2);
    		printList(reverseList(head2));
    	}
    }

(2) 打印倒数第K个节点(前后指针)

如何找出单链表中的倒数第k个元素   
（1）方法1：首先遍历一遍单链表，求出整个单链表的长度n，然后将倒数第k个，转换为正数第n-k个，接下去遍历一次就可以得到结果。但该算法需要对链表进行两次遍历，第一次遍历用于求解单链表的长度，第二次遍历用于查找正数第n-k个元素。   
（2）方法2：如果沿着从头到尾的方向，从链表中的某个元素开始，遍历k个元素后刚好达到链表尾，那么该元素就是要找的倒数第k个元素。根据这一性质，可以设计如下算法：从头节点开始，一次对链表的每一个节点元素进行这样的测试，遍历k个元素，查看是否到达链表尾，直到找到那个倒数第k个元素为止。这种方法将对同一批元素进行反复多次的遍历，对于链表中的大部分元素而言，都要遍历k个元素，如果链表的长度为n，该算法的时间复杂度为O(kn)级，效率太低。   
（3）方法3：有一种更高效的方式，只需要一次遍历即可查找到倒数第k个元素。由于单链表只能从头到尾依次访问链表的各个节点，所以如果要找链表的倒数第k个元素，也只能从头到尾进行遍历查找。在查找过程中，设置两个指针，让其中一个指针比另一个指针先前移k-1步，然后两个指针同时往前移动。循环直到先行的指针指为NULL时，另一个指针所指的位置就是所要找的位置。

#include <stdio.h>
 #include <stdlib.h>
 
 typedef struct node
 {
 int data;
 struct node *next;
 } NODE;
 
 
 // 尾插法创建单链表(带头节点)
 NODE *createEnd(int arr[], int len)
 {
 NODE *head = (NODE *)malloc(sizeof(NODE)); // 生成头节点
 head->next = NULL;
 NODE *end = head; // 尾指针初始化
 
 for (int i = 0; i < len; i++) {
 
 NODE *p = (NODE *)malloc(sizeof(NODE)); // 为每个数组元素建立一个节点
 p->data = arr[i];
 end->next = p; // 将节点p插入到终端节点之后
 end = p;
 }
 
 end->next = NULL; // 单链表建立完毕，将终端节点的指针域置空
 
 return head;
 }
 
 
 
 // 找出单链表中的倒数第k个元素
 NODE *search_last_k(NODE *head, int k)
 {
 NODE *p1 = head;
 NODE *p2 = head;
 
 for (int i = 0; i < k; i++) {
 p2 = p2->next;
 }
 
 
 while (p2 != NULL) {
 p1 = p1->next;
 p2 = p2->next;
 }
 
 
 return p1;
 
 }
 
 
 
 
 // 单链表打印
 void print(NODE *head)
 {
 if (head == NULL) return;
 
 NODE *p = head->next;
 while (p != NULL) {
 printf("%d\n", p->data);
 p = p->next;
 }
 }
 
 int main(void)
 {
 int arr[] = {1,2,3,4,5,6,7};
 int len = sizeof(arr)/sizeof(int);
 
 NODE *head = createEnd(arr, len);
 
 print(head);
 
 printf("-----------\n");
 
 NODE *temp_k = search_last_k(head, 3);
 printf("%d\n",temp_k->data);
 
 
 return 0;
 }

(3) 链表是否有环(快慢指针)等等。b ggg

**给定一个单链表，只给出头指针h：**

**1、如何判断是否存在环？**

**2、如何知道环的长度？**

**3、如何找出环的连接点在哪里？**

**4、带环链表的长度是多少？**

**解法：**

**1、对于问题1，使用追赶的方法，设定两个指针slow、fast，从头指针开始，每次分别前进1步、2步。如存在环，则两者相遇；如不存在环，fast遇到NULL退出。**

**2、对于问题2，记录下问题1的碰撞点p，slow、fast从该点开始，再次碰撞所走过的操作数就是环的长度s。**

**3、问题3：有定理：碰撞点p到连接点的距离=头指针到连接点的距离，因此，分别从碰撞点、头指针开始走，相遇的那个点就是连接点。(证明在后面附注)**

**4、问题3中已经求出连接点距离头指针的长度，加上问题2中求出的环的长度，二者之和就是带环单链表的长度**

#include <stdio.h>
 
 typedef struct Node
 {
 	int val;
 	Node *next;
 }Node,*pNode;
 
 
 
 //判断是否有环
 bool isLoop(pNode pHead)
 {
 	pNode fast = pHead;
 	pNode slow = pHead;
 	//如果无环，则fast先走到终点
 	//当链表长度为奇数时，fast->Next为空
 	//当链表长度为偶数时，fast为空
 	while( fast != NULL && fast->next != NULL)
 	{
 
 		fast = fast->next->next;
 		slow = slow->next;
 		//如果有环，则fast会超过slow一圈
 		if(fast == slow)
 		{
 			break;
 		}
 	}
 
 	if(fast == NULL || fast->next == NULL )
 		return false;
 	else
 		return true;
 }
 
 //计算环的长度
 int loopLength(pNode pHead)
 {
 	if(isLoop(pHead) == false)
 		return 0;
 	pNode fast = pHead;
 	pNode slow = pHead;
 	int length = 0;
 	bool begin = false;
 	bool agian = false;
 	while( fast != NULL && fast->next != NULL)
 	{
 		fast = fast->next->next;
 		slow = slow->next;
 		//超两圈后停止计数，挑出循环
 		if(fast == slow && agian == true)
 			break;
 		//超一圈后开始计数
 		if(fast == slow && agian == false)
 		{			
 			begin = true;
 			agian = true;
 		}
 
 		//计数
 		if(begin == true)
 			++length;
 		
 	}
 	return length;
 }
 
 
 //求出环的入口点
 Node* findLoopEntrance(pNode pHead)
 {
 	pNode fast = pHead;
 	pNode slow = pHead;
 	while( fast != NULL && fast->next != NULL)
 	{
 
 		fast = fast->next->next;
 		slow = slow->next;
 		//如果有环，则fast会超过slow一圈
 		if(fast == slow)
 		{
 			break;
 		}
 	}
 	if(fast == NULL || fast->next == NULL)
 		return NULL;
 	slow = pHead;
 	while(slow != fast)
 	{
 		slow = slow->next;
 		fast = fast->next;
 	}
 
 	return slow;
 }

###  ###

## [判断两个链表是否相交][Link 7] ##

1 假设两个链表都没有环

[![81b78497tw1eesdi7bb2kj20d403qaa0.jpg][]][81b78497tw1eesdi7bb2kj20d403qaa0.jpg]

**解题思路**

a. 直接循环判断第一个链表的每个节点是否在第二个链表中。但，这种方法的时间复杂度为O(Length(h1) \* Length(h2))。显然，我们得找到一种更为有效的方法，至少不能是O（N^2）的复杂度。

b. 针对第一个链表直接构造hash表，然后查询hash表，判断第二个链表的每个节点是否在hash表出现，如果所有的第二个链表的节点都能在hash表中找到，即说明第二个链表与第一个链表有相同的节点。时间复杂度为为线性：O(Length(h1) + Length(h2))，同时为了存储第一个链表的所有节点，空间复杂度为O(Length(h1))。是否还有更好的方法呢，既能够以线性时间复杂度解决问题，又能减少存储空间？

c.转换为环的问题。把第二个链表接在第一个链表后面，如果得到的链表有环，则说明两个链表相交。如何判断有环的问题上面已经讨论过了，但这里有更简单的方法。因为如果有环，则第二个链表的表头一定也在环上，即第二个链表会构成一个循环链表，我们只需要遍历第二个链表，看是否会回到起始点就可以判断出来。这个方法的时间复杂度是线性的，空间是常数。

d.进一步考虑“如果两个没有环的链表相交于某一节点，那么在这个节点之后的所有节点都是两个链表共有的”这个特点，我们可以知道，如果它们相交，则最后一个节点一定是共有的。而我们很容易能得到链表的最后一个节点，所以这成了我们简化解法的一个主要突破口。那么，我们只要判断两个链表的尾指针是否相等。相等，则链表相交；否则，链表不相交。

所以，先遍历第一个链表，记住最后一个节点。然后遍历第二个链表，到最后一个节点时和第一个链表的最后一个节点做比较，如果相同，则相交，否则，不相交。这样我们就得到了一个时间复杂度，它为O((Length(h1) + Length(h2))，而且只用了一个额外的指针来存储最后一个节点。这个方法时间复杂度为线性O(N)，空间复杂度为O(1)，显然比解法三更胜一筹

2 假设两个链表都有环，情况只有2种：相交于”环上”或相交于”不是环的部分”。因此环一定是在公共部分上的。假如知道其中一个链表上环的任意一个节点，则只需要判断是否在另一个链表上就行了。这里有个疑问？一般意义上，链表有环并不存在这种形式：1->2->3->2->4?

![带环单向链表相交只有2种情况][2]

![复制代码][copycode.gif]

//判断带环不带环时链表是否相交  
    //2.如果都不带环，就判断尾节点是否相等  
    //3.如果都带环，判断一链表上俩指针相遇的那个节点，在不在另一条链表上。  
    bool detect(Node * head1, Node * head2)  
    {  
        Node * circleNode1;  
        Node * circleNode2;  
        Node * lastNode1;  
        Node * lastNode2;  
          
        bool isCircle1 = isCircle(head1,circleNode1, lastNode1);  
        bool isCircle2 = isCircle(head2,circleNode2, lastNode2);  
          
        //一个有环，一个无环  
        if(isCircle1 != isCircle2)  
            return false;  
        //两个都无环，判断最后一个节点是否相等  
        else if(!isCircle1 && !isCircle2)  
        {  
            return lastNode1 == lastNode2;  
        }  
        //两个都有环，判断环里的节点是否能到达另一个链表环里的节点  
        else  
        {  
            Node * temp = circleNode1->next;  //updated，多谢苍狼 and hyy。  
            while(temp != circleNode1)    
            {  
                if(temp == circleNode2)  
                    return true;  
                temp = temp->next;  
            }  
            return false;  
        }  
          
        return false;  
    }

![复制代码][copycode.gif]

3   求相交的第一个元素

对于1中相交，只要知道两个链表长度L1和L2，那么让长的那个先走abs(L1-L2),然后一起走，相同的那个节点就是第一个元素

![复制代码][copycode.gif]

//求两链表相交的第一个公共节点
 Node* findIntersectNode(Node *h1,Node *h2)
 {
 int len1 = listLength(h1); //求链表长度
 int len2 = listLength(h2);
 //对齐两个链表
 if(len1 > len2)
 {
 for(int i=0;i<len1-len2;i++)
 h1=h1->next;
 }
 else 
 {
 for(int i=0;i<len2-len1;i++)
 h2=h2->next;
 }
 
 while(h1 != NULL)
 {
 if(h1 == h2)
 return h1;
 h1 = h1->next;
 h2 = h2->next; 
 }
 return NULL;
 }

### **栈和队列** ###

*  **队列和栈的区别**？(从实现，应用，自身特点多个方面来阐述，不要只说一个先入先出，先入后出，这个你会别人也会，要展现出你比别人掌握的更深)

栈（Stack）和队列（Queue）是两种操作受限的线性表。

（线性表：线性表是一种线性结构，它是一个含有n≥0个结点的有限序列，同一个线性表中的数据元素数据类型相同并且满足“一对一”的逻辑关系。

“一对一”的逻辑关系指的是对于其中的结点，有且仅有一个开始结点没有前驱但有一个后继结点，有且仅有一个终端结点没有后继但有一个前驱结点，其它的结点都有且仅有一个前驱和一个后继结点。）

这种受限表现在：栈的插入和删除操作只允许在表的尾端进行（在栈中成为“栈顶”），满足“FIFO：First In Last Out”；队列只允许在表尾插入数据元素，在表头删除数据元素,满足“First In First Out”。

栈与队列的相同点：

1.都是线性结构。

2.插入操作都是限定在表尾进行。

3.都可以通过顺序结构和链式结构实现。、

4.插入与删除的时间复杂度都是O（1），在空间复杂度上两者也一样。

5.多链栈和多链队列的管理模式可以相同。

栈与队列的不同点：

1.删除数据元素的位置不同，栈的删除操作在表尾进行，队列的删除操作在表头进行。

2.应用场景不同；常见栈的应用场景包括括号问题的求解，表达式的转换和求值，函数调用和递归实现，深度优先搜索遍历等；常见的队列的应用场景包括计算机系统中各种资源的管理，消息缓冲器的管理和广度优先搜索遍历等。

3.顺序栈能够实现多栈空间共享，而顺序队列不能。

*  典型的应用场景

### **海量数据问题** ###

*  十亿整数（随机生成，可重复）中前K最大的数   
    类似问题的解决方法思路：首先哈希将数据分成N个文件，然后对每个文件建立K个元素最小/大堆（根据要求来选择）。最后将文件中剩余的数插入堆中，并维持K个元素的堆。最后将N个堆中的元素合起来分析。可以采用归并的方式来合并。在归并的时候为了提高效率还需要建一个N个元素构成的最大堆，先用N个堆中的最大值填充这个堆，然后就是弹出最大值，指针后移的操作了。当然这种问题在现在的互联网技术中，一般就用map-reduce框架来做了。  
    大数据排序相同的思路：先哈希（哈希是好处是分布均匀，相同的数在同一个文件中），然后小文件装入内存快排，排序结果输出到文件。最后建堆归并。
 *  **十亿整数（随机生成，可重复）中出现频率最高的一千个**

### [**排序算法**][Link 8] ###

*  排序算法当然是基础内容了，必须至少能快速写出，快排，建堆，和归并
 *  每种算法的时间空间复杂度，最好最差平均情况

### [**位运算**][Link 9] ###

### 布隆过滤器 ###

几十亿个数经常要查找某一个数在不在里面，使用布隆过滤器，布隆过滤器的原理。布隆过滤器可能出现误判，怎么保证无误差？

# 网络与TCP/IP #

参考书籍：《图解TCP/IP》，《TCP/IP详解 卷一》，《图解HTTP》，《HTTP权威指南》

*  [TCP与UDP之间的区别][TCP_UDP]

[https://blog.csdn.net/shanghairuoxiao/article/details/68927070][https_blog.csdn.net_shanghairuoxiao_article_details_68927070]

传输层  
既然有了IP协议，能将数据发送到指定的主机为什么还要由传输层。原因有两点：

IP协议提供的是不可靠的传输协议，它只是尽力将数据发送到目标主机，但是如果数据丢包，数据损坏，它都不能提供任何解决办法；

IP协议只是将数据发送到了目标主机，但是应该由哪个应用程序来接受这个数据包呢？IP协议没有办法告诉我们。   
因此传输层的作用就是为了实现以上两点目的。

传输层协议有 TCP 协议和 UDP 协议。TCP 协议是面向有连接的协议，也就是说在使用 TCP 协议传输数据之前一定要在发送方和接收方之间建立连接。一般情况下建立连接需要三步，关闭连接需要四步。

TCP概述： TCP 协议是面向有连接的协议，还有数据重传、流量控制等功能，TCP 协议能够正确处理丢包问题，保证接收方能够收到数据，与此同时还能够有效利用网络带宽。然而 TCP 协议中定义了很多复杂的规范，因此效率不如 UDP 协议，不适合实时的视频和音频传输。

UDP概述： UDP 协议是面向无连接的协议，它只会把数据传递给接收端，但是不会关注接收端是否真的收到了数据。但是这种特性反而适合多播，实时的视频和音频传输。因为个别数据包的丢失并不会影响视频和音频的整体效果。

IP 协议中的两大关键要素是源 IP 地址和目标 IP 地址。而刚刚我们说过，传输层的主要作用是实现应用程序之间的通信。因此传输层的协议中新增了两个要素：源端口号，目标端口号。再加上IP首部中的协议号，通过这五个信息，可以唯一识别一个通信。用一句话来概括就是：“源 IP 地址，目标 IP 地址，源端口号，目标端口号和协议号”这五个信息只要有一个不同，都被认为是不同的通信。

端口号  
作用：用于区分同一台主机中正在通信的不同应用程序，因此也被称为程序地址。不同的端口用于区分同一台主机上不同的应用程序。假设你打开了两个浏览器，浏览器 A 发出的请求不会被浏览器 B 接收，这就是因为 A 和 B 具有不同的端口。

分为两种：   
1. 知名端口号：这种端口号是固定的，用于服务器程序，使用对应协议的程序就将端口号设为对应的数字。比如DNS的端口号就是53.   
2. 动态端口号：这种端口号是不固定的，用于客户端程序，客户端程序对端口号要求不高，只要该端口号在本机中唯一就行。

常见的知名端口号：

端口号    协议  
53    DNS  
80    HTTP  
20    FTP数据  
21    FTP控制  
23    SSH  
25    SMTP  
TCP与UDP区别  
TCP基于有连接，UDP基于无连接。有连接就是TCP在传输前先发送连接请求和应答包，确定双方能够正常传输后，才开始进行数据传输。无连接就是UDP在发送数据之前，并不考虑对方能否接受到，甚至目的地址可能都是无效；

TCP能保证可靠传输，UDP不能保证可靠传输TCP。所谓可靠就是TCP能保证把数据一定送到目的地址。为了实现可靠，TCP采用有连接的，超时重传，应答机制等。而UDP则没有这些，也不能保证数据一定能送到；

TCP结构复杂，消耗资源多，建立过程较慢较复杂。UDP结构简单，消耗资源少，建立过程较快；

TCP基于流模式，UDP是数据报模式。TCP把数据看成一连串无结构的字节流，没有边界，一段段传输构成了整个数据块。通过发送缓冲区和接受缓冲区来存储数据流。而UDP数据报模式，每一个数据报都是一个独立的对象，有着指定的大小。

TCP连接只能是点到点，而UDP可以一对一，一对多或者多对多。TCP只能是点到点原因很简单，因为TCP的传输前要先建立连接。因此，广播和多播只能采用UDP数据报的方式。

TCP有确认，重传，拥赛控制机制，UDP在没有建立连接或者对方已经退出的情况下任然会继续发送数据，导致通信流量的浪费。

用途  
TCP：用于实现可靠传输的情况，文件非常重要，对网络拥堵有较高要求的情况。

UDP：   
1. 用于高速传输和实时性较高的场合（即时通信）。对于采用UDP的实事视频通信，如果出现丢包也只会出现短暂卡顿，但是如果采用TCP丢包后需要重发，会导致很长时间的卡顿。   
2. 包总量较少的通信（DNS），客户端较多   
3. 广播通信

UDP首部

源端口号：表示发送端端口号，不需要时设为0  
目标端口号：表示接收端端口号  
包长度：表示整个UDP包的长度  
校验和：为了提供可靠的UDP首部和数据而设计，只要源IP地址，目标IP地址，源端口号，目标端口号，协议号有一个发生了篡改校验和都会不正确。  
TCP首部

源端口号：发送端端口号  
目标端口号：接受端端口号  
序列号：发送数据时，表示发送数据的位置，发送完一次数据后，序列号的值都等于原来的序列号加上数据的长度  
应答号：用于接受端告诉发送端下次应该从哪个位置开始发送，表示前面的数据已经都收到了  
数据偏移：实际就是TCP首部长度  
保留：一般设置为0，用于后续扩展  
控制位：长度为8，从左到右分别是CWR，ECE，URG，ACK，PSH，RST，SYN，FIN  
窗口大小：能够发送数据的最大值，为0时可以发送探测窗口  
校验和：与UDP校验和作用相同  
紧急指针：用于处理紧急情况  
选项：其他控制设置  
[https://blog.csdn.net/ch1406285246/article/details/55504330][https_blog.csdn.net_ch1406285246_article_details_55504330]

(1) IP首部，TCP首部，UDP首部   
(2) TCP和UDP区别   
(3) TCP和UDP应用场景   
(4) 如何实现可靠的UDP

*  [TCP三次握手与四次挥手][TCP]
 *  [详细说明TCP状态迁移过程][TCP]  
    (1) 三次握手和四次挥手状态变化；   
    (2) 2MSL是什么状态？作用是什么？   
    (3)三次握手为什么不是两次或者四次？
 *  [TCP相关技术][TCP]
    
    1.  TCP重发机制，Nagle算法
    2.  TCP的拥塞控制使用的算法和具体过程
    3.  TCP的窗口滑动
 *  [TCP客户与服务器模型，用到哪些函数][TCP 1]
 *  [UDP客户与服务器模型，用到哪些函数][UDP]
 *  [域名解析过程，ARP的机制，RARP的实现][ARP_RARP]
    
    1.  RARP用于无盘服务器，开机后通过发送RARP包给RARP服务器，通过mac地址得到IP地址
 *  Ping和TraceRoute实现原理

(1) Ping是通过发送ICMP报文回显请求实现。  
(2) TraceRoute通过发送UDP报文，设置目的端口为一个不可能的值，将IP首部中的TTL分别设置从1到N，每次逐个增加，如果收到端口不可达，说明到达目的主机，如果是因为TTL跳数超过，路由器会发送主机不可达的ICMP报文。

## [HTTP][] ##

**http/https 1.0、1.1、2.0**

1.  http的主要特点:   
    **简单快速：**当客户端向服务器端发送请求时，只是简单的填写请求路径和请求方法即可，然后就可以通过浏览器或其他方式将该请求发送就行了   
    **灵活：** HTTP 协议允许客户端和服务器端传输任意类型任意格式的数据对象   
    **无连接：**无连接的含义是限制每次连接只处理一个请求。服务器处理完客户的请求，并收到客户的应答后，即断开连接，采用这种方式可以节省传输时间。(当今多数服务器支持Keep-Alive功能，使用服务器支持长连接，解决无连接的问题)  
    **无状态：**无状态是指协议对于事务处理没有记忆能力，服务器不知道客户端是什么状态。即客户端发送HTTP请求后，服务器根据请求，会给我们发送数据，发送完后，不会记录信息。(使用 cookie 机制可以保持 session，解决无状态的问题)
2.  http1.1的特点   
    a、默认持久连接节省通信量，只要客户端服务端任意一端没有明确提出断开TCP连接，就一直保持连接，可以发送多次HTTP请求   
    b、管线化，客户端可以同时发出多个HTTP请求，而不用一个个等待响应   
    c、断点续传
3.  [http2.0的特点][http2.0]  
    a、HTTP/2采用二进制格式而非文本格式   
    b、HTTP/2是完全多路复用的，而非有序并阻塞的——只需一个HTTP连接就可以实现多个请求响应   
    c、使用报头压缩，HTTP/2降低了开销   
    d、HTTP/2让服务器可以将响应主动“推送”到客户端缓存中

*  # **get/post 区别** #

**区别一：  
get重点在从服务器上获取资源，post重点在向服务器发送数据；  
区别二：  
get传输数据是通过URL请求，以field（字段）= value的形式，置于URL后，并用"?"连接，多个请求数据间用"&"连接，如http://127.0.0.1/Test/login.action?name=admin&password=admin，这个过程用户是可见的；  
post传输数据通过Http的post机制，将字段与对应值封存在请求实体中发送给服务器，这个过程对用户是不可见的；  
区别三：  
Get传输的数据量小，因为受URL长度限制，但效率较高；  
Post可以传输大量数据，所以上传文件时只能用Post方式；  
区别四：  
get是不安全的，因为URL是可见的，可能会泄露私密信息，如密码等；  
post较get安全性较高；**

*  # **返回状态码** #

**200：请求被正常处理  
204：请求被受理但没有资源可以返回  
206：客户端只是请求资源的一部分，服务器只对请求的部分资源执行GET方法，相应报文中通过Content-Range指定范围的资源。  
301：永久性重定向  
302：临时重定向  
303：与302状态码有相似功能，只是它希望客户端在请求一个URI的时候，能通过GET方法重定向到另一个URI上  
304：发送附带条件的请求时，条件不满足时返回，与重定向无关  
307：临时重定向，与302类似，只是强制要求使用POST方法  
400：请求报文语法有误，服务器无法识别  
401：请求需要认证  
403：请求的对应资源禁止被访问  
404：服务器无法找到对应资源  
500：服务器内部错误  
503：服务器正忙**

**http 协议头相关**

http数据由请求行，首部字段，空行，报文主体四个部分组成   
首部字段分为：通用首部字段，请求首部字段，响应首部字段，实体首部字段

**https与http的区别？如何实现加密传输？**

*  https就是在http与传输层之间加上了一个SSL
 *  对称加密与非对称加密

**浏览器中输入一个URL发生什么，用到哪些协议？**

浏览器中输入URL，首先浏览器要将URL解析为IP地址，解析域名就要用到DNS协议，首先主机会查询DNS的缓存，如果没有就给本地DNS发送查询请求。DNS查询分为两种方式，一种是递归查询，一种是迭代查询。如果是迭代查询，本地的DNS服务器，向根域名服务器发送查询请求，根域名服务器告知该域名的一级域名服务器，然后本地服务器给该一级域名服务器发送查询请求，然后依次类推直到查询到该域名的IP地址。DNS服务器是基于UDP的，因此会用到UDP协议。

得到IP地址后，浏览器就要与服务器建立一个http连接。因此要用到http协议，http协议报文格式上面已经提到。http生成一个get请求报文，将该报文传给TCP层处理。如果采用https还会先对http数据进行加密。TCP层如果有需要先将HTTP数据包分片，分片依据路径MTU和MSS。TCP的数据包然后会发送给IP层，用到IP协议。IP层通过路由选路，一跳一跳发送到目的地址。当然在一个网段内的寻址是通过以太网协议实现(也可以是其他物理层协议，比如PPP，SLIP)，以太网协议需要直到目的IP地址的物理地址，有需要ARP协议。

**安全相关**

至少了解攻击的原理和基本的防御方法，常见的攻击方法有一下几种

*  SQL注入
 *  XSS
 *  CSRF
 *  SYN洪水攻击
 *  APR欺骗

## [数据库][Link 10] ##

主要参考书籍：《数据库系统概念》，《高性能MySQL》

*  SQL语言(内外连接，子查询，分组，聚集，嵌套，逻辑)
 *  MySQL索引方法？索引的优化？

[https://blog.csdn.net/qq\_37307063/article/details/70141679][https_blog.csdn.net_qq_37307063_article_details_70141679]

[http://www.runoob.com/w3cnote/mysql-index.html][http_www.runoob.com_w3cnote_mysql-index.html]

[https://www.cnblogs.com/zhaobingqing/p/7071331.html][https_www.cnblogs.com_zhaobingqing_p_7071331.html]

[https://www.2cto.com/database/201804/740181.html][https_www.2cto.com_database_201804_740181.html]

*  InnoDB与MyISAM区别？

InnoDB：  
支持事务处理等  
不加锁读取  
支持外键  
支持行锁  
不支持FULLTEXT类型的索引  
不保存表的具体行数，扫描表来计算有多少行  
DELETE 表时，是一行一行的删除  
InnoDB 把数据和索引存放在表空间里面  
跨平台可直接拷贝使用  
InnoDB中必须包含AUTO\_INCREMENT类型字段的索引  
表格很难被压缩

MyISAM：  
不支持事务，回滚将造成不完全回滚，不具有原子性  
不支持外键  
不支持外键  
支持全文搜索  
保存表的具体行数,不带where时，直接返回保存的行数  
DELETE 表时，先drop表，然后重建表  
MyISAM 表被存放在三个文件 。frm 文件存放表格定义。 数据文件是MYD (MYData) 。 索引文件是MYI (MYIndex)引伸  
跨平台很难直接拷贝  
MyISAM中可以使AUTO\_INCREMENT类型字段建立联合索引  
表格可以被压缩

选择：  
因为MyISAM相对简单所以在效率上要优于InnoDB.如果系统读多，写少。对原子性要求低。那么MyISAM最好的选择。且MyISAM恢复速度快。可直接用备份覆盖恢复。  
如果系统读少，写多的时候，尤其是并发写入高的时候。InnoDB就是首选了。  
两种类型都有自己优缺点，选择那个完全要看自己的实际类弄。

\}【

1、MyISAM：默认表类型，它是基于传统的ISAM类型，ISAM是Indexed Sequential Access Method (有索引的顺序访问方法) 的缩写，它是存储记录和文件的标准方法。不是事务安全的，而且不支持外键，如果执行大量的select，insert MyISAM比较适合。

2、InnoDB：支持事务安全的引擎，支持外键、行锁、事务是他的最大特点。如果有大量的update和insert，建议使用InnoDB，特别是针对多个并发和QPS较高的情况。

**一、表锁差异**

**MyISAM:**

myisam只支持表级锁，用户在操作myisam表时，select，update，delete，insert语句都会给表自动加锁，如果加锁以后的表满足insert并发的情况下，可以在表的尾部插入新的数据。也可以通过lock table命令来锁表，这样操作主要是可以模仿事务，但是消耗非常大，一般只在实验演示中使用。

**InnoDB ：**

Innodb支持事务和行级锁，是innodb的最大特色。

事务的ACID属性：atomicity,consistent,isolation,durable。

并发事务带来的几个问题：更新丢失，脏读，不可重复读，幻读。

事务隔离级别：未提交读(Read uncommitted)，已提交读(Read committed)，可重复读(Repeatable read)，可序列化(Serializable)

四种隔离级别的比较

<table> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;"> 读数据一致性及并发副作用 &nbsp; 隔离级别 </td> 
 <td> 读数据一致性 </td> 
 <td> 脏读 </td> 
 <td> 不可重复读 </td> 
 <td> 幻读 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;">为提交读(read uncommitted)</td> 
 <td> 最低级别，不读物理上顺坏的数据 </td> 
 <td> 是 </td> 
 <td> 是 </td> 
 <td> 是 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;">已提交读(read committed)</td> 
 <td> 语句级 </td> 
 <td> 否 </td> 
 <td> 是 </td> 
 <td> 是 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;">可重复读(Repeatable red)</td> 
 <td> 事务级 </td> 
 <td> 否 </td> 
 <td> 否 </td> 
 <td> 是 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;">可序列化(Serializable)</td> 
 <td> 最高级别，事务级 </td> 
 <td> 否 </td> 
 <td> 否 </td> 
 <td> 否 </td> 
 </tr> 
 </tbody> 
</table>

查看mysql的默认事务隔离级别“show global variables like ‘tx\_isolation’; ”

Innodb的行锁模式有以下几种：共享锁，排他锁，意向共享锁(表锁)，意向排他锁(表锁)，间隙锁。

注意：当语句没有使用索引，innodb不能确定操作的行，这个时候就使用的意向锁，也就是表锁

关于死锁：

什么是死锁？当两个事务都需要获得对方持有的排他锁才能完成事务，这样就导致了循环锁等待，也就是常见的死锁类型。

解决死锁的方法：

1、  数据库参数

2、  应用中尽量约定程序读取表的顺序一样

3、  应用中处理一个表时，尽量对处理的顺序排序

4、  调整事务隔离级别（避免两个事务同时操作一行不存在的数据，容易发生死锁）

**二、数据库文件差异**

**MyISAM ：**

myisam属于堆表

myisam在磁盘存储上有三个文件，每个文件名以表名开头，扩展名指出文件类型。

.frm 用于存储表的定义

.MYD 用于存放数据

.MYI 用于存放表索引

myisam表还支持三种不同的存储格式：

静态表(默认，但是注意数据末尾不能有空格，会被去掉)

动态表

压缩表

**InnoDB ：**

innodb属于索引组织表

innodb有两种存储方式，共享表空间存储和多表空间存储

两种存储方式的表结构和myisam一样，以表名开头，扩展名是.frm。

如果使用共享表空间，那么所有表的数据文件和索引文件都保存在一个表空间里，一个表空间可以有多个文件，通过innodb\_data\_file\_path和innodb\_data\_home\_dir参数设置共享表空间的位置和名字，一般共享表空间的名字叫ibdata1-n。

如果使用多表空间，那么每个表都有一个表空间文件用于存储每个表的数据和索引，文件名以表名开头，以.ibd为扩展名。

**三、索引差异**

1、关于自动增长

myisam引擎的自动增长列必须是索引，如果是组合索引，自动增长可以不是第一列，他可以根据前面几列进行排序后递增。

innodb引擎的自动增长咧必须是索引，如果是组合索引也必须是组合索引的第一列。

2、关于主键

myisam允许没有任何索引和主键的表存在，

myisam的索引都是保存行的地址。

innodb引擎如果没有设定主键或者非空唯一索引，就会自动生成一个6字节的主键(用户不可见)

innodb的数据是主索引的一部分，附加索引保存的是主索引的值。

3、关于count()函数

myisam保存有表的总行数，如果select count(\*) from table;会直接取出出该值

innodb没有保存表的总行数，如果使用select count(\*) from table；就会遍历整个表，消耗相当大，但是在加了wehre       条件后，myisam和innodb处理的方式都一样。

4、全文索引

myisam支持 FULLTEXT类型的全文索引

innodb不支持FULLTEXT类型的全文索引，但是innodb可以使用sphinx插件支持全文索引，并且效果更好。（sphinx   是一个开源软件，提供多种语言的API接口，可以优化mysql的各种查询）

5、delete from table

使用这条命令时，innodb不会从新建立表，而是一条一条的删除数据，在innodb上如果要清空保存有大量数据的表，最       好不要使用这个命令。(推荐使用truncate table，不过需要用户有drop此表的权限)

6、索引保存位置

myisam的索引以表名+.MYI文件分别保存。

innodb的索引和数据一起保存在表空间里。

**四、开发的注意事项**

1、可以用 show create table tablename 命令看表的引擎类型。

2、对不支持事务的表做start/commit操作没有任何效果，在执行commit前已经提交。

3、可以执行以下命令来切换非事务表到事务（数据不会丢失），innodb表比myisam表更安全：alter table tablename type=innodb;或者使用 alter table tablename engine = innodb;

4、默认innodb是开启自动提交的，如果你按照myisam的使用方法来编写代码页不会存在错误，只是性能会很低。如何在编写代码时候提高数据库性能呢？

a、尽量将多个语句绑到一个事务中，进行提交，避免多次提交导致的数据库开销。

b、在一个事务获得排他锁或者意向排他锁以后，如果后面还有需要处理的sql语句，在这两条或者多条sql语句之间程序应尽量少的进行逻辑运算和处理，减少锁的时间。

c、尽量避免死锁

d、sql语句如果有where子句一定要使用索引，尽量避免获取意向排他锁。

f、针对我们自己的数据库环境，日志系统是直插入，不修改的，所以我们使用混合引擎方式，ZION\_LOG\_DB照旧使用myisam存储引擎，只有ZION\_GAME\_DB，ZION\_LOGIN\_DB，DAUM\_BILLING使用Innodb引擎。

**五、究竟该怎么选择**

下面先让我们回答一些问题：

◆你的数据库有外键吗？

◆你需要事务支持吗？

◆你需要全文索引吗？

◆你经常使用什么样的查询模式？

◆你的数据有多大？     
    
myisam只有索引缓存     
innodb不分索引文件数据文件 innodb buffer     
myisam只能管理索引，在索引数据大于分配的资源时，会由操作系统来cache；数据文件依赖于操作系统的cache。innodb不管是索引还是数据，都是自己来管理    
    
思考上面这些问题可以让你找到合适的方向，但那并不是绝对的。如果你需要事务处理或是外键，那么InnoDB 可能是比较好的方式。如果你需要全文索引，那么通常来说 MyISAM是好的选择，因为这是系统内建的，然而，我们其实并不会经常地去测试两百万行记录。所以，就算是慢一点，我们可以通过使用Sphinx从InnoDB中获得全文索引。    
    
数据的大小，是一个影响你选择什么样存储引擎的重要因素，大尺寸的数据集趋向于选择InnoDB方式，因为其支持事务处理和故障恢复。数据库的在小决定了故障恢复的时间长短，InnoDB可以利用事务日志进行数据恢复，这会比较快。而MyISAM可能会需要几个小时甚至几天来干这些事，InnoDB只需要几分钟。    
    
操作数据库表的习惯可能也会是一个对性能影响很大的因素。比如： COUNT() 在 MyISAM 表中会非常快，而在InnoDB 表下可能会很痛苦。而主键查询则在InnoDB下会相当相当的快，但需要小心的是如果我们的主键太长了也会导致性能问题。大批的inserts 语句在 MyISAM下会快一些，但是updates 在InnoDB下会更快一些——尤其在并发量大的时候。    
    
所以，到底你检使用哪一个呢？根据经验来看，如果是一些小型的应用或项目，那么MyISAM 也许会更适合。当然，在大型的环境下使用 MyISAM 也会有很大成功的时候，但却不总是这样的。如果你正在计划使用一个超大数据量的项目，而且需要事务处理或外键支持，那么你真的应该直接使用 InnoDB方式。但需要记住InnoDB 的表需要更多的内存和存储，转换100GB 的MyISAM 表到InnoDB 表可能会让你有非常坏的体验。    
    
对于支持事务的InnoDB类型的表，影响速度的主要原因是AUTOCOMMIT默认设置是打开的，而且程序没有显式调用BEGIN 开始事务，导致每插入一条都自动Commit，严重影响了速度。可以在执行sql前调用begin，多条sql形成一个事务（即使autocommit打开也可以），将大大提高性能。

InnoDB

InnoDB 给 MySQL 提供了具有事务(commit)、回滚(rollback)和崩溃修复能力 (crash recovery capabilities)的事务安全(transaction-safe (ACID compliant))型表。 InnoDB 提供了行锁(locking on row level)，提供与 Oracle 类型一致的不加锁读取(non- locking read in SELECTs)。这些特性均提高了多用户并发操作的性能表现。在InnoDB表中不需要扩大锁定 (lock escalation)，因为 InnoDB 的列锁定(row level locks)适宜非常小的空间。 InnoDB 是 MySQL 上第一个提供外键约束(FOREIGN KEY constraints)的表引擎。    
  
InnoDB 的设计目标是处理大容量数据库系统，它的 CPU 利用率是其它基于磁盘的关系数据库引擎所不能比的。在技术上，InnoDB 是一套放在 MySQL 后台的完整数据库系统，InnoDB 在主内存中建立其专用的缓冲池用于高速缓冲数据和索引。 InnoDB 把数据和索引存放在表空间里，可能包含多个文件，这与其它的不一样，举例来说，在 MyISAM 中，表被存放在单独的文件中。InnoDB 表的大小只受限于操作系统的文件大小，一般为 2 GB。    
InnoDB所有的表都保存在同一个数据文件 ibdata1 中（也可能是多个文件，或者是独立的表空间文件）,相对来说比较不好备份，免费的方案可以是拷贝数据文件、备份 binlog，或者用 mysqldump。

MyISAM     
MyISAM 是MySQL缺省存贮引擎 .     
每张MyISAM 表被存放在三个文件 。frm 文件存放表格定义。 数据文件是MYD (MYData) 。 索引文件是 MYI (MYIndex) 引伸。     
因为MyISAM相对简单所以在效率上要优于InnoDB..小型应用使用MyISAM是不错的选择.     
MyISAM表是保存成文件的形式,在跨平台的数据转移中使用MyISAM存储会省去不少的麻烦     
    
以下是一些细节和具体实现的差别：     
    
1.InnoDB不支持FULLTEXT类型的索引。     
2.InnoDB 中不保存表的具体行数，也就是说，执行select count(\*) from table时，InnoDB要扫描一遍整个表来计算有多少行，但是MyISAM只要简单的读出保存好的行数即可。注意的是，当count(\*)语句包含 where条件时，两种表的操作是一样的。    
3.对于AUTO\_INCREMENT类型的字段，InnoDB中必须包含只有该字段的索引，但是在MyISAM表中，可以和其他字段一起建立联合索引。     
4.DELETE FROM table时，InnoDB不会重新建立表，而是一行一行的删除。     
5.LOAD TABLE FROM MASTER操作对InnoDB是不起作用的，解决方法是首先把InnoDB表改成MyISAM表，导入数据后再改成InnoDB表，但是对于使用的额外的InnoDB特性（例如外键）的表不适用。    
  
另外，InnoDB表的行锁也不是绝对的，如果在执行一个SQL语句时MySQL不能确定要扫描的范围，InnoDB表同样会锁全表，例如 update table set num=1 where name like “%aaa%”    
  
任何一种表都不是万能的，只用恰当的针对业务类型来选择合适的表类型，才能最大的发挥MySQL的性能优势。

**六、重复地总结一遍**

1、MyISAM不支持事务，InnoDB是事务类型的存储引擎，当我们的表需要用到事务支持的时候，那肯定是不能选择MyISAM了。

2、MyISAM只支持表级锁，BDB支持页级锁和表级锁默认为页级锁，而InnoDB支持行级锁和表级锁默认为行级锁  
   
表级锁：直接锁定整张表，在锁定期间，其他进程无法对该表进行写操作，如果设置的是写锁，那么其他进程读也不允许  
   
MyISAM是表级锁定的存储引擎，它不会出现死锁问题  
   
对于write，表锁定原理如下：  
   
如果表上没有锁，在其上面放置一个写锁，否则，把锁定请求放在写锁队列中。  
   
对于read，表锁定原理如下 ：  
   
如果表上没有写锁定，那么把一个读锁放在其上面，否则把锁请求放在读锁定队列中  
   
当一个锁定被释放时，表可被写锁定队列中的线程得到，然后才是读锁定队列中的线程。这意味着，如果你在一个表上有许多更新，那么你的SELECT语句将等到所有的写锁定线程执行完。

行级锁：只对指定的行进行锁定，其他进程还是可以对表中的其他行进行操作的。  
   
行级锁是Mysql粒度最小的一种锁，它能大大的减少数据库操作的冲突，但是粒度越小实现成本也越大。  
   
行级锁可能会导致“死锁”，那到底是怎么导致的呢，分析原因：Mysql行级锁并不是直接锁记录，而是锁索引。索引分为主键索引和非主键索引两种，如果一条sql语句操作了主键索引，那么Mysql就会锁定这个主键索引，如果sql语句操作的是非主键索引，那么Mysql会先锁定这个非主键索引，再去锁定主键索引。  
   
在UPDATE 和 DELETE操作时Mysql不仅会锁定所有WHERE 条件扫描过得索引，还会锁定相邻的键值。  
   
“死锁”举例分析：  
   
表Test：（ID,STATE,TIME）  主键索引：ID  非主键索引：STATE  
   
当执行"UPDATE  STATE =1011 WHERE STATE=1000"  语句的时候会锁定STATE索引，由于STATE 是非主键索引,所以Mysql还会去请求锁定ID索引  
   
当另一个SQL语句与语句1几乎同时执行时：“UPDATE STATE=1010 WHERE ID=1”  对于语句2 Mysql会先锁定ID索引，由于语句2操作了STATE字段，所以Mysql还会请求锁定STATE索引。这时。彼此锁定着对方需要的索引，又都在等待对方释放锁定。所以出现了"死锁"的情况。  
   
行级锁的优点：  
   
有许多线程访问不同的行时，只存在少量的冲突。  
   
回滚时只有少量的更改  
   
可以长时间锁定单一的行  
   
行级锁缺点：  
   
相对于页级锁和表级锁来说占用了更多的内存  
   
当表的大部分行在使用时，比页级锁和表级锁慢，因为你必须获得更多的锁  
   
当在大部分数据上经常使用GROUP BY操作，肯定会比表级锁和页级锁慢。  
   
页级锁：表级锁速度快，但是冲突多；行级锁速度慢，但冲突少；页级锁就是他俩折中的，一次锁定相邻的一组记录。

3、MyISAM引擎不支持外键，InnoDB支持外键

4、MyISAM引擎的表在大量高并发的读写下会经常出现表损坏的情况  
   
我们以前做的项目就遇到这个问题，表的INSERT 和 UPDATE操作很频繁，原来用的MyISAM引擎，导致表隔三差五就损坏，后来更换成了InnoDB引擎。  
   
其他容易导致表损坏原因：  
   
服务器突然断电导致数据文件损坏，强制关机（mysqld未关闭情况下）导致表损坏  
   
mysqld进程在写入操作的时候被杀掉  
   
磁盘故障  
   
表损坏常见症状：  
   
查询表不能返回数据或返回部分数据  
   
打开表失败： Can’t open file: ‘×××.MYI’ (errno: 145) 。  
   
Error: Table 'p' is marked as crashed and should be repaired 。

Incorrect key file for table: '...'. Try to repair it  
   
Mysql表的恢复：

对于MyISAM表的恢复：

可以使用Mysql自带的myisamchk工具： myisamchk -r tablename  或者 myisamchk -o tablename（比前面的更保险） 对表进行修复

5、对于count()查询来说MyISAM更有优势

因为MyISAM存储了表中的行数记录，执行SELECT COUNT() 的时候可以直接获取到结果，而InnoDB需要扫描全部数据后得到结果。

但是注意一点：对于带有WHERE 条件的 SELECT COUNT()语句两种引擎的表执行过程是一样的，都需要扫描全部数据后得到结果

6、 InnoDB是为处理巨大数据量时的最大性能设计，它的CPU效率可能是任何其它基于磁盘的关系数据库引擎所不能匹敌的。

7、MyISAM支持全文索引（FULLTEXT），InnoDB不支持

8、MyISAM引擎的表的查询、更新、插入的效率要比InnoDB高

网上截取了前辈们测试结论：

测试方法：连续提交10个query， 表记录总数：38万 ， 时间单位 s  
   
        引擎类型                    MyISAM                InnoDB              性能相差  
   
        count                      0.0008357            3.0163                3609  
   
        查询主键                  0.005708              0.1574                27.57  
   
        查询非主键                  24.01                  80.37                3.348  
   
        更新主键                  0.008124            0.8183                100.7  
   
        更新非主键                0.004141            0.02625              6.338  
   
        插入                        0.004188            0.3694                88.21

（1）加了索引以后，对于MyISAM查询可以加快：4 206.09733倍，对InnoDB查询加快510.72921倍，同时对MyISAM更新速度减慢为原来的1/2，InnoDB的更  
  新速度减慢为原来的1/30。要看情况决定是否要加索引，比如不查询的log表，不要做任何的索引。  
   
    （2）如果你的数据量是百万级别的，并且没有任何的事务处理，那么用MyISAM是性能最好的选择。  
   
    （3）InnoDB表的大小更加的大，用MyISAM可省很多的硬盘空间。  
   
        在我们测试的这个38w的表中，表占用空间的情况如下：  
            引擎类型                    MyISAM              InnoDB  
            数据                      53,924 KB          58,976 KB  
            索引                      13,640 KB          21,072 KB  
            占用总空间              67,564 KB          80,048 KB  
    
        另外一个176W万记录的表， 表占用空间的情况如下：  
   
            引擎类型                MyIsam              InnorDB  
            数据                  56,166 KB          90,736 KB  
            索引                  67,103 KB          88,848 KB  
            占用总空间        123,269 KB        179,584 KB

七、性能对比

测试的版本是mysql  Ver 14.14 Distrib 5.1.49, for debian-linux-gnu (i686)，使用的是Innodb plugin 1.0.8（官方称比built-in版本性能更好）和默认的MyISAM。

测试机器是笔记本，配置如下：Intel 酷睿2双核 P8600，2G\*2 DDR3 1066内存，320G硬盘5400转。

测试一：数据插入性能测试，这里我分别对innodb\_flush\_log\_at\_trx\_commit参数打开和关闭都测了了一下，每次测试都是运行40s，表中数字都是实际插入条数。

MyISAM                 Innodb (打开)      Innodb (关闭)

单线程，逐个插入         120000                 60000              60000

4线程，逐个插入          40000\*4                20000\*4            40000\*4

单线程，批量100条/次插入  3600\*100               800\*100            3000\*100

单线程，批量200条/次插入  1800\*200               400\*200            1600\*200

可以发现批量插入的性能远高于单条插入，但是一次批量的大小对性能影响不大。每条记录是否都刷新日志的参数对innodb性能的影响巨大。总体上来说，MyISAM性能更优一点。这里有一点需要注意，在插入测试过程中，我对系统资源进行了监控，发现MyISAM对系统资源占用很低，但是Innodb对磁盘占用却很高，应该是对事务控制多了很多需要记录的日志。

测试二：数据读取性能测试。每次随机读取1000条记录，反复进行读取。

MyISAM        Innodb

单线程，200次读取         5.7s          16.7s

4线程，200次读取          12s           40.8s

可以看出MyISAM的读取性能非常恐怖，性能差距在3倍的样子。

以上两个测试发现MyISAM在无事务的需求下几乎完胜，但是要知道它是表锁，Innodb是行锁，那么在并发读写同时存在的情况下，那结果会是怎么样呢？！

测试三：两个线程并发写入，2个线程并发读取。

MyISAM                                 Innodb

逐个插入                写入40s：10000\*2 读取200次\*2：14s        写入40s：60000\*2 读取200次\*2：50s

批量100条/次插入        写入40s：1000\*100\*2 读取200次\*2：10s      写入40s：1500\*100\*2 读取200次\*2：50s

这下立刻显示出Innodb在并发情况下强劲的性能，几乎没有什么性能衰减。而MyISAM单条插入速度变得非常慢，批量插入也下降了40%性能。

总结一下，在写多读少的应用中还是Innodb插入性能更稳定，在并发情况下也能基本，如果是对读取速度要求比较快的应用还是选MyISAM。

】[https://www.cnblogs.com/y-rong/p/8110596.html][https_www.cnblogs.com_y-rong_p_8110596.html]

*  事务的ACID

1)原子性(Atomic)：事务中各项操作，要么全做要么全不做，任何一项操作的失败都会导致整个事务的失败；

2)一致性(Consistent)：事务结束后系统状态是一致的；

3)隔离性(Isolated)：并发执行的事务彼此无法看到对方的中间状态；

4)持久性(Durable)：事务完成后所做的改动都会被持久化，即使发生灾难性的失败。通过日志和同步备份可以在故障发生后重建数据。

*  幻读（Phantom Read）：事务A重新执行一个查询，返回一系列符合查询条件的行，发现其中插入了被事务B提交的行。
 *  不可重复读（Unrepeatable Read）：事务A重新读取前面读取过的数据，发现该数据已经被另一个已提交的事务B修改过了。
 *  脏读（Dirty Read）：A事务读取B事务尚未提交的数据并在此基础上操作，而B事务执行回滚，那么A读取到的数据就是脏数据。

不可重复读（Unrepeatable Read）：事务A重新读取前面读取过的数据，发现该数据已经被另一个已提交的事务B修改过了。

[http://www.cnblogs.com/malaikuangren/archive/2012/04/06/2434760.html][http_www.cnblogs.com_malaikuangren_archive_2012_04_06_2434760.html]

[https://blog.csdn.net/mfl0315/article/details/51981792][https_blog.csdn.net_mfl0315_article_details_51981792]

[https://www.cnblogs.com/suncan0/p/4767894.html][https_www.cnblogs.com_suncan0_p_4767894.html]

*  事务的四个隔离级别

数据库事务的隔离级别有4种，由低到高分别为Read uncommitted 、Read committed 、Repeatable read 、Serializable 。而且，在事务的并发操作中可能会出现脏读，不可重复读，幻读。下面通过事例一一阐述它们的概念与联系。

--------------------

Read uncommitted

读未提交，顾名思义，就是一个事务可以读取另一个未提交事务的数据。

事例：老板要给程序员发工资，程序员的工资是3.6万/月。但是发工资时老板不小心按错了数字，按成3.9万/月，该钱已经打到程序员的户口，但是事务还没有提交，就在这时，程序员去查看自己这个月的工资，发现比往常多了3千元，以为涨工资了非常高兴。但是老板及时发现了不对，马上回滚差点就提交了的事务，将数字改成3.6万再提交。

分析：实际程序员这个月的工资还是3.6万，但是程序员看到的是3.9万。他看到的是老板还没提交事务时的数据。这就是脏读。

--------------------

那怎么解决脏读呢？Read committed！读提交，能解决脏读问题。

--------------------

Read committed

读提交，顾名思义，就是一个事务要等另一个事务提交后才能读取数据。

事例：程序员拿着信用卡去享受生活（卡里当然是只有3.6万），当他埋单时（程序员事务开启），收费系统事先检测到他的卡里有3.6万，就在这个时候！！程序员的妻子要把钱全部转出充当家用，并提交。当收费系统准备扣款时，再检测卡里的金额，发现已经没钱了（第二次检测金额当然要等待妻子转出金额事务提交完）。程序员就会很郁闷，明明卡里是有钱的…

分析：这就是读提交，若有事务对数据进行更新（UPDATE）操作时，读操作事务要等待这个更新操作事务提交后才能读取数据，可以解决脏读问题。但在这个事例中，出现了一个事务范围内两个相同的查询却返回了不同数据，这就是不可重复读。

--------------------

那怎么解决可能的不可重复读问题？Repeatable read ！

--------------------

Repeatable read

重复读，就是在开始读取数据（事务开启）时，不再允许修改操作

事例：程序员拿着信用卡去享受生活（卡里当然是只有3.6万），当他埋单时（事务开启，不允许其他事务的UPDATE修改操作），收费系统事先检测到他的卡里有3.6万。这个时候他的妻子不能转出金额了。接下来收费系统就可以扣款了。

分析：重复读可以解决不可重复读问题。写到这里，应该明白的一点就是，不可重复读对应的是修改，即UPDATE操作。但是可能还会有幻读问题。因为幻读问题对应的是插入INSERT操作，而不是UPDATE操作。

--------------------

什么时候会出现幻读？

事例：程序员某一天去消费，花了2千元，然后他的妻子去查看他今天的消费记录（全表扫描FTS，妻子事务开启），看到确实是花了2千元，就在这个时候，程序员花了1万买了一部电脑，即新增INSERT了一条消费记录，并提交。当妻子打印程序员的消费记录清单时（妻子事务提交），发现花了1.2万元，似乎出现了幻觉，这就是幻读。

--------------------

那怎么解决幻读问题？Serializable！

--------------------

Serializable 序列化

Serializable 是最高的事务隔离级别，在该级别下，事务串行化顺序执行，可以避免脏读、不可重复读与幻读。但是这种事务隔离级别效率低下，比较耗数据库性能，一般不使用。

--------------------

值得一提的是：大多数数据库默认的事务隔离级别是Read committed，比如Sql Server , Oracle。Mysql的默认隔离级别是Repeatable read。

[https://blog.csdn.net/ywl470812087/article/details/78533020][https_blog.csdn.net_ywl470812087_article_details_78533020]

*  查询优化(从索引上优化，从SQL语言上优化)

[https://blog.csdn.net/u012091092/article/details/53377607][https_blog.csdn.net_u012091092_article_details_53377607]

[https://blog.csdn.net/qq\_33936481/article/details/73531671][https_blog.csdn.net_qq_33936481_article_details_73531671]

[https://blog.csdn.net/youthsunshine/article/details/53465847][https_blog.csdn.net_youthsunshine_article_details_53465847]

*  B-与B+树区别？

[https://blog.csdn.net/zwz2011303359/article/details/63262541][https_blog.csdn.net_zwz2011303359_article_details_63262541]

【

看了很多讲B树和B+树的文章，大多都是围绕各自的特性讲的，第一，树中每个结点最多含有m个孩子（m>=2）；第二，……我也是从这些文章里弄懂了各种树的联系与区别，要真写，我可能还不如人家写得好。所以就在这里简明扼要的用几张图记录一下主要区别吧。

为了便于说明，我们先定义一条数据记录为一个二元组\[key,data\]，key为记录的键值，key唯一；data为数据记录除key外的数据。

B树

每个节点都存储key和data，所有节点组成这棵树，并且叶子节点指针为null。

B+树

只有叶子节点存储data，叶子节点包含了这棵树的所有键值，叶子节点不存储指针。

后来，在B+树上增加了顺序访问指针，也就是每个叶子节点增加一个指向相邻叶子节点的指针，这样一棵树成了数据库系统实现索引的首选数据结构。

原因有很多，最主要的是这棵树矮胖，呵呵。一般来说，索引很大，往往以索引文件的形式存储的磁盘上，索引查找时产生磁盘I/O消耗，相对于内存存取，I/O存取的消耗要高几个数量级，所以评价一个数据结构作为索引的优劣最重要的指标就是在查找过程中磁盘I/O操作次数的时间复杂度。树高度越小，I/O次数越少。

那为什么是B+树而不是B树呢，因为它内节点不存储data，这样一个节点就可以存储更多的key。

在MySQL中，最常用的两个存储引擎是MyISAM和InnoDB，它们对索引的实现方式是不同的。

MyISAM

data存的是数据地址。索引是索引，数据是数据。

InnoDB

data存的是数据本身。索引也是数据。

了解了数据结构再看索引，一切都不费解了，只是顺着逻辑推而已。另加两种存储引擎的区别：

1、MyISAM是非事务安全的，而InnoDB是事务安全的

2、MyISAM锁的粒度是表级的，而InnoDB支持行级锁

3、MyISAM支持全文类型索引，而InnoDB不支持全文索引

4、MyISAM相对简单，效率上要优于InnoDB，小型应用可以考虑使用MyISAM

5、MyISAM表保存成文件形式，跨平台使用更加方便

6、MyISAM管理非事务表，提供高速存储和检索以及全文搜索能力，如果在应用中执行大量select操作可选择

7、InnoDB用于事务处理，具有ACID事务支持等特性，如果在应用中执行大量insert和update操作，可选择

】[https://blog.csdn.net/zwz2011303359/article/details/63262541][https_blog.csdn.net_zwz2011303359_article_details_63262541]

*  MySQL的联合索引(又称多列索引)是什么？生效的条件？

【 
创建一个多列索引： 
CREATE TABLE test (   
    id         INT NOT NULL,   
    last\_name  CHAR(30) NOT NULL,   
    first\_name CHAR(30) NOT NULL,   
    PRIMARY KEY (id),   
    INDEX name (last\_name,first\_name)   
);   
创建多个索引： 
CREATE TABLE test (   
    id         INT NOT NULL,   
    last\_name  CHAR(30) NOT NULL,   
    first\_name CHAR(30) NOT NULL,   
    PRIMARY KEY (id),   
    INDEX name (last\_name),   
     INDEX\_2 name (first\_name)   
);   
当查询语句的条件中包含last\_name 和 first\_name时， 
例如：SELECT \* FROM test WHERE last\_name='Kun' AND first\_name='Li';   
sql会先过滤出last\_name符合条件的记录，在其基础上再过滤first\_name符合条件的记录。那如果我们分别在last\_name和first\_name上创建两个列索引，mysql的处理方式就不一样了，它会选择一个最严格的索引来进行检索，可以理解为检索能力最强的那个索引来检索，另外一个利用不上了，这样效果就不如多列索引了。 
但是多列索引的利用也是需要条件的，以下形式的查询语句能够利用上多列索引： 
SELECT \* FROM test WHERE last\_name='Widenius'; 
SELECT \* FROM test WHERE last\_name='Widenius' AND first\_name='Michael'; 
SELECT \* FROM test WHERE last\_name='Widenius' AND (first\_name='Michael' OR first\_name='Monty'); 
SELECT \* FROM test WHERE last\_name='Widenius' AND first\_name >='M' AND first\_name < 'N'; 
以下形式的查询语句利用不上多列索引： 
SELECT \* FROM test WHERE first\_name='Michael'; 
SELECT \* FROM test WHERE last\_name='Widenius' OR first\_name='Michael'; 
多列建索引比对每个列分别建索引更有优势，因为索引建立得越多就越占磁盘空间，在更新数据的时候速度会更慢。另外建立多列索引时，顺序也是需要注意的，应该将严格的索引放在前面，这样筛选的力度会更大，效率更高。】

【

联合索引又叫复合索引。对于复合索引:My[sql][]从左到右的使用索引中的字段，一个查询可以只使用索引中的一部份，但只能是最左侧部分。例如索引是key index (a,b,c). 可以支持a | a,b| a,b,c 3种组合进行查找，但不支持 b,c进行查找 .当最左侧字段是常量引用时，索引就十分有效。

两个或更多个列上的索引被称作复合索引。  
利用索引中的附加列，您可以缩小搜索的范围，但使用一个具有两列的索引 不同于使用两个单独的索引。复合索引的结构与电话簿类似，人名由姓和名构成，电话簿首先按姓氏对进行排序，然后按名字对有相同姓氏的人进行排序。如果您知 道姓，电话簿将非常有用；如果您知道姓和名，电话簿则更为有用，但如果您只知道名不姓，电话簿将没有用处。  
所以说创建复合索引时，应该仔细考虑列的顺序。对索引中的所有列执行搜索或仅对前几列执行搜索时，复合索引非常有用；仅对后面的任意列执行搜索时，复合索引则没有用处。  
如：建立 姓名、年龄、性别的复合索引。

create table test( a int, b int, c int, KEY a(a,b,c) );

**复合索引的建立原则：**

如果您很可能仅对一个列多次执行搜索，则该列应该是复合索引中的第一列。如果您很可能对一个两列索引中的两个列执行单独的搜索，则应该创建另一个仅包含第二列的索引。  
如上图所示，如果查询中需要对年龄和性别做查询，则应当再新建一个包含年龄和性别的复合索引。  
包含多个列的主键始终会自动以复合索引的形式创建索引，其列的顺序是它们在表定义中出现的顺序，而不是在主键定义中指定的顺序。在考虑将来通过主键执行的搜索，确定哪一列应该排在最前面。  
请注意，创建复合索引应当包含少数几个列，并且这些列经常在select查询里使用。在复合索引里包含太多的列不仅不会给带来太多好处。而且由于使用相当多的内存来存储复合索引的列的值，其后果是内存溢出和性能降低。

** 复合索引对排序的优化：**

复合索引只对和索引中排序相同或相反的order by 语句优化。  
 在创建复合索引时，每一列都定义了升序或者是降序。如定义一个复合索引：

CREATE INDEX idx_example ON table1 (col1 ASC, col2 DESC, col3 ASC)

其中 有三列分别是：col1 升序，col2 降序， col3 升序。现在如果我们执行两个查询  
 1：

Select col1, col2, col3 from table1 order by col1 ASC, col2 DESC, col3 ASC

和索引顺序相同  
 2：

Select col1, col2, col3 from table1 order by col1 DESC, col2 ASC, col3 DESC

和索引顺序相反  
 查询1，2 都可以别复合索引优化。  
 如果查询为：

Select col1, col2, col3 from table1 order by col1 ASC, col2 ASC, col3 ASC

排序结果和索引完全不同时，此时的 查询不会被复合索引优化。

查询优化器在在where查询中的作用：

如果一个多列索引存在于 列 Col1 和 Col2 上，则以下语句：Select   \* from table where   col1=val1 AND col2=val2 查询优化器会试图通过决定哪个索引将找到更少的行。之后用得到的索引去取值。  
 1． 如果存在一个多列索引，任何最左面的索引前缀能被优化器使用。所以联合索引的顺序不同，影响索引的选择，尽量将值少的放在前面。  
如：一个多列索引为 (col1 ，col2， col3)  
    那么在索引在列 (col1) 、(col1 col2) 、(col1 col2 col3) 的搜索会有作用。

SELECT * FROM tb WHERE col1 = val1 SELECT * FROM tb WHERE col1 = val1 and col2 = val2 SELECT * FROM tb WHERE col1 = val1 and col2 = val2 AND col3 = val3

2． 如果列不构成索引的最左面前缀，则建立的索引将不起作用。  
如：

SELECT * FROM tb WHERE col3 = val3 SELECT * FROM tb WHERE col2 = val2 SELECT * FROM tb WHERE col2 = val2 and col3=val3

3． 如果一个 Like 语句的查询条件不以通配符起始则使用索引。  
如：%车 或 %车%   不使用索引。  
    车%              使用索引。  
索引的缺点：  
1.       占用磁盘空间。  
2.       增加了插入和删除的操作时间。一个表拥有的索引越多，插入和删除的速度越慢。如 要求快速录入的系统不宜建过多索引。

**下面是一些常见的索引限制问题**

1、使用不等于操作符(<>, !=) 
下面这种情况，即使在列dept\_id有一个索引，查询语句仍然执行一次全表扫描 
select \* from dept where staff\_num <> 1000; 
但是[开发][Link 11]中的确需要这样的查询，难道没有解决问题的办法了吗？ 
有！ 
通过把用 or 语法替代不等号进行查询，就可以使用索引，以避免全表扫描：上面的语句改成下面这样的，就可以使用索引了。

select * from dept shere staff_num < 1000 or dept_id > 1000;

2、使用 is null 或 is not null  
使用 is null 或is nuo null也会限制索引的使用，因为数据库并没有定义null值。如果被索引的列中有很多null，就不会使用这个索引（除非索引是一个位图索引，关于位图索引，会在以后的blog[文章][Link 12]里做详细解释）。在sql语句中使用null会造成很多麻烦。  
解决这个问题的办法就是：建表时把需要索引的列定义为非空(not null)

3、使用函数  
如果没有使用基于函数的索引，那么where子句中对存在索引的列使用函数时，会使优化器忽略掉这些索引。下面的查询就不会使用索引：

select * from staff where trunc(birthdate) = '01-MAY-82';

但是把函数应用在条件上，索引是可以生效的，把上面的语句改成下面的语句，就可以通过索引进行查找。

select * from staff where birthdate < (to_date('01-MAY-82') + 0.9999);

4、比较不匹配的数据类型  
比较不匹配的数据类型也是难于发现的性能问题之一。  
下面的例子中，dept\_id是一个varchar2型的字段，在这个字段上有索引，但是下面的语句会执行全表扫描。

select * from dept where dept_id = 900198;

这是因为oracle会自动把where子句转换成to\_number(dept\_id)=900198，就是3所说的情况，这样就限制了索引的使用。  
把SQL语句改为如下形式就可以使用索引

select * from dept where dept_id = '900198';

恩，这里还有要注意的：

比方说有一个文章表，我们要实现某个类别下按时间倒序[列表][Link 13]显示功能：

SELECT * FROM articles WHERE category_id = ... ORDER BY created DESC LIMIT ...

这样的查询很常见，基本上不管什么应用里都能找出一大把类似的SQL来，学院派的读者看到上面的SQL，可能会说SELECT \*不好，应该仅仅查询需要的字段，那我们就索性彻底点，把SQL改成如下的形式：

SELECT id FROM articles WHERE category_id = ... ORDER BY created DESC LIMIT ...

我们假设这里的id是主键，至于文章的具体内容，可以都保存到memcached之类的键值类型的缓存里，如此一来，学院派的读者们应该挑不出什么毛病来了，下面我们就按这条SQL来考虑如何建立索引：

不考虑数据分布之类的特殊情况，任何一个合格的WEB开发人员都知道类似这样的SQL，应该建立一个”category\_id, created“复合索引，但这是最佳答案不？不见得，现在是回头看看标题的时候了：MySQL里建立索引应该考虑数据库引擎的类型！

如果我们的数据库引擎是InnoDB，那么建立”category\_id, created“复合索引是最佳答案。让我们看看InnoDB的索引结构，在InnoDB里，索引结构有一个特殊的地方：非主键索引在其BTree的叶节点上会额外保存对应主键的值，这样做一个最直接的好处就是Covering Index，不用再到数据文件里去取id的值，可以直接在索引里得到它。

如果我们的数据库引擎是MyISAM，那么建立"category\_id, created"复合索引就不是最佳答案。因为MyISAM的索引结构里，非主键索引并没有额外保存对应主键的值，此时如果想利用上Covering Index，应该建立"category\_id, created, id"复合索引。

唠完了，应该明白我的意思了吧。希望以后大家在考虑索引的时候能思考的更全面一点，实际应用中还有很多类似的问题，比如说多数人在建立索引的时候不从Cardinality（SHOW INDEX FROM ...能看到此参数）的角度看是否合适的问题，Cardinality表示唯一值的个数，一般来说，如果唯一值个数在总行数中所占比例小于20%的话，则可以认为Cardinality太小，此时索引除了拖慢insert/update/delete的速度之外，不会对select产生太大作用；还有一个细节是建立索引的时候未考虑字符集的影响，比如说username字段，如果仅仅允许英文，下划线之类的符号，那么就不要用gbk，utf-8之类的字符集，而应该使用latin1或者ascii这种简单的字符集，索引文件会小很多，速度自然就会快很多。这些细节问题需要读者自己多注意，我就不多说了。

】[https://www.cnblogs.com/codeAB/p/6387148.html][https_www.cnblogs.com_codeAB_p_6387148.html]

*  分库分表

[https://www.cnblogs.com/sunny3096/p/8595058.html][https_www.cnblogs.com_sunny3096_p_8595058.html]

[https://blog.csdn.net/mingover/article/details/71108852][https_blog.csdn.net_mingover_article_details_71108852]

【】

# Linux #

主要参考书籍：《现代操作系统》，《APUE》，《UNP》，《LINUX内核设计与实现》，《深入理解LINUX内核》

### [**进程与线程**][Link 14] ###

### [https://blog.csdn.net/shanghairuoxiao/article/details/74012512][https_blog.csdn.net_shanghairuoxiao_article_details_74012512] ###

(1) 进程与线程区别？   
(2) 线程比进程具有哪些优势？   
(3) 什么时候用多进程？什么时候用多线程？   
(4) LINUX中进程和线程使用的几个函数？   
(5) 线程同步？   
在Windows下线程同步的方式有：互斥量，信号量，事件，关键代码段   
在Linux下线程同步的方式有：互斥锁，自旋锁，读写锁，屏障(并发完成同一项任务时，屏障的作用特别好使)   
知道这些锁之间的区别，使用场景？

### [**进程间通讯方式**][Link 15] ###

[http://www.cnblogs.com/CheeseZH/p/5264465.html][Link 15]

> **管道( pipe )**：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。
> 
> **命名管道 (FIFO) **： 有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。
> 
> **信号量**：信号量用于实现进程间的互斥与同步，而不是用于存储进程间通信数据，有XSI信号量和POSIX信号量，POSIX信号量更加完善。
> 
> **消息队列( message queue )** ： 消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。
> 
> **共享内存( shared memory ) **：共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的 IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号两，配合使用，来实现进程间的同步和通信。(原理一定要清楚，常考)
> 
> **信号 ( sinal ) **： 信号是一种比较复杂的通信方式，用于通知接收进程某个事件已经发生，常见的信号。
> 
> **套接字( socket ) **： 套解口也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同及其间的进程通信。

*  **匿名管道与命名管道的区别**：匿名管道只能在具有公共祖先的两个进程间使用。
 *  **共享文件映射mmap**   
    mmap建立进程空间到文件的映射，在建立的时候并不直接将文件拷贝到物理内存，同样采用缺页终端。mmap映射一个具体的文件可以实现任意进程间共享内存，映射一个匿名文件，可以实现父子进程间共享内存。
 *  **常见的信号有哪些？**：SIGINT，SIGKILL(不能被捕获)，SIGTERM(可以被捕获)，SIGSEGV，SIGCHLD，SIGALRM

### [**内存管理**][Link 16] ###

1.  虚拟内存的作用？
2.  虚拟内存的实现？
3.  操作系统层面对内存的管理？
4.  内存池的作用？STL里[内存池如何实现][Link 17]？
5.  进程空间和内核空间对内存的管理不同？
6.  Linux的slab层，VAM？
7.  伙伴算法
8.  高端内存

### 进程调度 ###

[https://blog.csdn.net/qq\_38847853/article/details/80554515][https_blog.csdn.net_qq_38847853_article_details_80554515]

1.  Linux进程分为两种，实时进程和非实时进程；
2.  优先级分为静态优先级和动态优先级，优先级的范围；
3.  调度策略，FIFO，LRU，时间片轮转
4.  交互进程通过平均睡眠时间而被奖励；

### [**死锁**][Link 18] ###

(1) 死锁产生的条件；   
(2) 死锁的避免；

### 命令行 ###

*  Linux命令 在一个文件中，倒序打印第二行前100个大写字母

*  与CPU，内存，磁盘相关的命令(top，free, df, fdisk)

【

# [LINUX系统、磁盘与进程的相关命令][LINUX] #

**ps** ef：完整显示当前系统中所有运行的进程

**kill **停止或杀死进程。9表示强制杀掉进程或任务

**df **显示磁盘空间使用情况

**du** 用于显示指定目录下的文件以及子目录所占磁盘空间的大小。 与磁盘有关的命令

**fdisk **显示磁盘分区情况 fdisk -l /dve/sda

**free** 查看内存使用状况

**ifconfig** 用于显示和设置网卡 网卡设置ip，网卡设备后直接加上ip即可如 ifconfig etho ip地址。

**ifdown** 禁用网卡

**ifup** 启用网卡

**ping** 表示测试目标与本机的链接情况。 Ping -c 5 ip地址。

service

chkconfig

**iptables**

防火墙 itables -A INPUT -p tcp --dport 22 -j ACCEPT 表示在iptables 中的files表里INPUT链接增加了一条规则tcp协议，目标端口为22，参数为dport,处理方式为ACCEPT.

setenforce

getenforce

**mount**

挂载 mount -t iso9660 /dve/cdrom /mnt 表示用ISO9660文件系统格式挂载光盘设备，挂载地点为mnt目录。

**umount**

卸载命令\[挂载点\]【案例】umount /test/

**date**

显示系统的时间，可以在直接输入“date”命令来查看系统的时间

利用 date 命令来更改系统的时间

\- date MMDDHHMMCCYY.SS：月月日日时时分分年年.秒秒

\- 查看月历 - cal 3 2002：查看 2002 年 3 月的月历

\- 查看年历 - cal 2008：查看 2008 的年历.

】

*  网络相关的命令netstat，tcpdump等

[https://blog.csdn.net/GUI1259802368/article/details/80992815][https_blog.csdn.net_GUI1259802368_article_details_80992815]

*  sed, awk, grep三个超强大的命名，分别用与格式化修改，统计，和正则查找

【grep工作原理：  
grep命令在一个或多个文件中查找某个字符模式，如果这个模式中包含空格，就必须用引号把它括起来。grep命令中，模式可以是一个被引号括起来的字符串，也可以是单个词。位于模式之后的所有单词都被视为文件名。grep将输出发送到屏幕，它不会对输入文件进行任何修改或变化。grep返回的退出状态为0，表示成功。退出状态为1，表示没有找到。如果找不到指定的文件，退出状态为2。模式可以使用正则表达式。  
sed工作原理：sed是流式编辑器，读取文本的内容到模式空间，然后匹配后面的操作，然后把模式空间的内容输出到标准输出，结束运行。  
awk工作原理：①提取文本中的一行  
②对该行按照分隔符进行切片  
③命名，从前往后，$1,$2,$3等。每列的字段组成域。】【

<table> 
 <tbody> 
 <tr> 
 <td>grep命令在一个或多个文件中查找某个字符模式，如果这个模式中包含空格，就必须用引号把它括起来。grep命令中，模式可以是一个被引号括起来的字符串，也可以是单个词。位于模式之后的所有单词都被视为文件名。grep将输出发送到屏幕，它不会对输入文件进行任何修改或变化。grep返回的退出状态为0，表示成功。退出状态为1，表示没有找到。如果找不到指定的文件，退出状态为2。 sed是一个非交互式的流编辑器。所谓非交互式，是指使用sed只能在命令行下输入编辑命令来编辑文本，然后在屏幕上查看输出；而所谓流编辑器，是指sed每次只从文件（或输入）读入一行，然后对该行进行指定的处理，并将结果输出到屏幕（除非取消了屏幕输出又没有显式地使用打印命令），接着读入下一行。整个文件像流水一样被逐行处理然后逐行输出。 sed的工作过程： sed不是在原输入上直接进行处理的，而是先将读入的行放到缓冲区中，对缓冲区里的内容进行处理，处理完毕后也不会写回原文件（除非用shell的输出重定向来保存结果），而是直接输出到屏幕上。sed运行过程中维护着两个缓冲区，一个是活动的“模式空间（pattern space）”，另一个是起辅助作用的“暂存缓冲区（holding space）”。一般情况下，每当运行sed，sed首先把第一行装入模式空间，进行处理后输出到屏幕，然后将第二行装入模式空间替换掉模式空间里原来的内容，然后进行处理，以此类推。 awk工作原理: 1.&nbsp; &nbsp; &nbsp; &nbsp; awk 使用一行作为输入（通过文件或者管道），并将这一行赋给内部变量 $0 2.&nbsp; &nbsp; &nbsp; &nbsp; 行被空格分解为字段（单词），每一个字段存储在已编号的变量中，从 $1 开始。（ awk的内部变量 FS 用来确定字段的分隔符。初始时，为空格，包含制表符和空格符） 3.&nbsp; &nbsp; &nbsp; &nbsp; 对于一行，按照给定的正则表达式的顺序进行匹配，如果匹配则执行对应的 Action ，如果没有匹配上则不执行任何动作 ， Search Pattern 和 Action 是可选的，但是必须提供其中一个 。如果 Search Pattern 未提供，则对所有的输入行执行 Action 操作。如果 Action 未提供，则默认打印出该行的数据 。 {} 这种 Action 不做任何事情，和未提供的 Action 的工作方式不一样 4.&nbsp; &nbsp; &nbsp; &nbsp; 打印字段，用 print 、 printf 、 sprintf ，格式： { print $1, $3 } 内部变量 output field separator （ OFS ），默认为空格， $n 之间的逗号被 OFS 中的字符替换。 5.&nbsp; &nbsp; &nbsp; &nbsp; 输出之后，从文件中另取一行，并将其复制到 $0 中，覆盖原来的内容。重复进行……</td> 
 </tr> 
 </tbody> 
</table>

】【

<table> 
 <tbody> 
 <tr> 
 <td>Grep:&nbsp; 文本搜索工具，根据用户指定的“模式（pattern）”对目标文本进行过滤，显示被模式匹配到的行。不修改原文件 Sed: 不修改原文件，一行一行的读取文件到内存空间（模式空间）进程处理，处理流程如下： 1.读取一行内容到模式空间。 2.针对模式空间内容执行编辑命令 3.输出模式空间中的内容 4.清空模式空间。 Awk: 取出一行内容，按照分隔符进行切片（$1, $2…），对每片（域）进行处理，按照要求格式进行格式化输出。</td> 
 </tr> 
 </tbody> 
</table>

】【awk(关键字:分析&处理) 一行一行的分析处理 awk '条件类型1\{动作1\}条件类型2\{动作2\}' filename, awk 也可以读取来自前一个指令的 standard input 
相对于sed常常用于一整行处理, awk则比较倾向于一行当中分成数个"字段"(区域)来处理, 默认的分隔符是空格键或tab键 
例如: 
last -n 5 | awk '\{print $1 "\\t" $3\}' 这里大括号内$1"\\t"$3 之间不加空格也可以, 不过较好还是加上个空格, 另外注意"\\t"是有双引号的, 因为本身这些内容都在单引号内 
$0 代表整行 $1代表第一个区域, 依此类推 
awk的处理流程是: 
1. 读第一行, 将第一行资料填入变量 $0, $1... 等变量中 
2. 依据条件限制, 执行动作 
3. 接下来执行下一行 
所以, AWK一次处理是一行, 而一次中处理的最小单位是一个区域 
另外还有3个变量, NF: 每一行处理的字段数, NR 目前处理到第几行 FS 目前的分隔符 
逻辑判断 > < >= <= == !== , 赋值直接使用= 
cat /etc/passwd | awk '\{FS=":"\} $3<10 \{print $1 "\\t" $3\}' 首先定义分隔符为:, 然后判断, 注意看, 判断没有写在\{\}中, 然后执行动作, FS=":"这是一个动作, 赋值动作, 不是一个判断, 所以不写在\{\}中 
BEGIN END , 给程序员一个初始化和收尾的工作, BEGIN之后列出的操作在\{\}内将在awk开始扫描输入之前执行, 而END\{\}内的操作, 将在扫描完输入文件后执行. 
awk '/test/ \{print NR\}' abc 将带有test的行的行号打印出来, 注意//之间可以使用正则表达式 
awk \{\}内, 可以使用 if else ,for(i=0;i<10;i++), i=1 while(i<NF) 
可见, awk的很多用法都等同于C语言, 比如"\\t" 分隔符, print的格式, if, while, for 等等 
 
awk 是相当复杂的工具, 真正使用时, 再补充吧. (有关工具的picture) 
 
 
 
sed(关键字: 编辑) 以行为单位的文本编辑工具 sed可以直接修改档案, 不过一般不推荐这么做, 可以分析 standard input 
基本工作方式: sed \[-nef\] '\[动作\]' \[输入文本\] 
\-n : 安静模式, 一般sed用法中, 来自stdin的数据一般会被列出到屏幕上, 如果使用-n参数后, 只有经过sed处理的那一行被列出来. 
\-e : 多重编辑, 比如你同时又想删除某行, 又想改变其他行, 那么可以用 sed -e '1,5d' -e 's/abc/xxx/g' filename 
\-f : 首先将 sed的动作写在一个档案内, 然后通过 sed -f scriptfile 就可以直接执行 scriptfile 内的sed动作 (没有实验成功, 不推荐使用) 
\-i : 直接编辑, 这回就是真的改变文件中的内容了, 别的都只是改变显示. (不推荐使用) 
动作: 
a 新增, a 后面可以接字符串, 而这个字符串会在新的一行出现. (下一行) 
c 取代, c 后面的字符串, 这些字符串可以取代 n1,n2之间的行 
d 删除, 后面不接任何东西 
i 插入, 后面的字符串, 会在上一行出现 
p 打印, 将选择的资料列出, 通常和 sed -n 一起运作 sed -n '3p' 只打印第3行 
s 取代, 类似vi中的取代, 1,20s/old/new/g 
 
\[line-address\]q 退出, 匹配到某行退出, 提高效率 
 
\[line-address\]r 匹配到的行读取某文件 例如: sed '1r qqq' abc , 注意, 写入的文本是写在了第1行的后边, 也就是第2行 
 
\[line-address\]w file, 匹配到的行写入某文件  例如: sed -n '/m/w qqq' abc , 从abc中读取带m的行写到qqq文件中, 注意, 这个写入带有覆盖性. 
 
 
举例: 
sed '1d' abc 删除 abc 档案里的第一行, 注意, 这时会显示除了第一行之外的所有行, 因为第一行已经被删除了(实际文件并没有被删除,而只是显示的时候被删除了) 
sed -n '1d' abc 什么内容也不显示, 因为经过sed处理的行, 是个删除操作, 所以不现实. 
sed '2,$d' abc 删除abc中从第二行到最后一行所有的内容, 注意, $符号正则表达式中表示行末尾, 但是这里并没有说那行末尾, 就会指最后一行末尾, ^开头, 如果没有指定哪行开头, 那么就是第一行开头 
sed '$d' abc 只删除了最后一行, 因为并没有指定是那行末尾, 就认为是最后一行末尾 
sed '/test/d' abc 文件中所有带 test 的行, 全部删除 
sed '/test/a RRRRRRR' abc 将 RRRRRRR 追加到所有的带 test 行的下一行 也有可能通过行 sed '1,5c RRRRRRR' abc 
sed '/test/c RRRRRRR' abc 将 RRRRRRR 替换所有带 test 的行, 当然, 这里也可以是通过行来进行替换, 比如 sed '1,5c RRRRRRR' abc 
 
 
 
grep(关键字: 截取) 文本搜集工具, 结合正则表达式非常强大 
主要参数 \[\] 
\-c : 只输出匹配的行 
\-I : 不区分大小写 
\-h : 查询多文件时不显示文件名 
\-l : 查询多文件时, 只输出包含匹配字符的文件名 
\-n : 显示匹配的行号及行 
\-v : 显示不包含匹配文本的所有行(我经常用除去grep本身) 
基本工作方式: grep 要匹配的内容 文件名, 例如: 
grep 'test' d\* 显示所有以d开头的文件中包含test的行 
grep 'test' aa bb cc 显示在 aa bb cc 文件中包含test的行 
grep '\[a-z\]\\\{5\}\\' aa 显示所有包含字符串至少有5个连续小写字母的串】

*  ipcs和ipcrm命令

[https://blog.csdn.net/bluehawksky/article/details/39804551][https_blog.csdn.net_bluehawksky_article_details_39804551]

【

ipcs 命令

用途 ： linux/uinx上提供关于一些进程间通信方式的信息，包括共享内存，消息队列，信号，报告进程间通信设施状态。

语法

ipcs \[ -m\] \[ -q\] \[ -s\] \[ -S\] \[ -P\] \[ -l\] \[ -a | -b -c -o -p -t\] \[ -T\] \[ -C CoreFile\] \[ -N Kernel \]

描述

ipcs 命令往标准输出写入一些关于活动进程间通信设施的信息。如果没有指定任何标志，ipcs 命令用简短格式写入一些关于当前活动消息队列、共享内存段、信号量、远程队列和本地队列标题。

列标题和在 ipcs 命令中的列的含义列在下面。圆括号内的字母表示导致对应的报头出现的标志。all 设计符表示始终显示报头。这些标志仅仅确定提供给每个设备何种信息。但它们并不确定将列出哪些设备。

T （all）设施的类型。共有三种设施类型：

消息队列

共享内存段

信号量

ID （all）设施项的标识。

KEY （all）用作 msgget 子例程、semget 子例程或者 shmget 子例程的参数的键构成了设施项。

注： 当除去内存段时，共享内存段的密钥改变为 IPC\_PRIVATE，直到所有附加在段上的进程和它拆离。

MODE （all）设施访问方式和标志。这种方式由 11 个字符组成，解释如下：

前两个字符如下所示：

如果进程在等待 msgrcv 系统调用。

如果进程在等待 msgsnd 系统调用。

如果有关的共享内存段被除去。当附加在段上的最后一个进程拆离后它就会消失。

当第一个附加进程运行时，如果有关的共享内存段被清空。

如果没有设置相应的特定标志。

接下来的九个字符作为每三个一组解释。第一组是指拥有者有许可权；第二组是指在设施项的用户组中其他用户的许可权；最后一组指所有的用户。在每组中，第一个字符表示允许读，第二个字符表示可以写或者修改设施项，最后一个字符当前没有用过。

权限如下所示：

如果授予了读许可权。

如果授予了写许可权。

如果授予了修改许可权。

如果没有授予指定的许可权。

OWNER （all）设施项所有者的登录名。

GROUP （all）拥有设施项的组名。

CREATOR （a、c）设施项创建者的登录名。

CGROUP （a、c）设施项创建者的组名。

注： 对于 OWNER、GROUP、CREATOR 和 CGROUP，显示用户和组的标识而不显示登录名。

CBYTES （a、o）当前停留在相关消息队列中的消息的字节数。

QNUM （a、o）当前停留在相关消息队列中的消息的字节数。

QBYTES （a、b）停留在相关消息队列中消息允许的最大字节数。

LSPID （a、p）发送消息到相关队列的最后进程的标识。如果发送的最后一条消息是来自节点上的进程而不是保留该节点的队列，LSPID 是真正把消息放进队列的内核进程的 PID，而不是发送进程的 PID。

LRPID （a、p）接收来自相关队列的消息的进程标识。如果接收的最后一条消息来自一个节点上的进程而不是保留该队列的节点，LRPID 是真正接收队列上消息的内核进程的 PID ，而不是接收进程的 PID。

STIME （a、t）最后一条消息发送到相关队列的时间。对于远程队列，这是服务器时间。没有做任何措施来补偿本地时钟和服务器时钟之间的时区差异。

RTIME （a、t）接受最后一条来自相关队列的消息的时间。对于远程队列来说，这是服务器时间。没有做任何措施来补偿本地时钟和服务器始终之间的时区差异。

CTIME （a、t）创建和改变相关项的时间。对于远程队列，这是服务器时间。没有做任何措施来本地时钟和服务器时钟之间的任何时区差异。

NATTCH （a、o）连接在关联的共享内存段的进程数。

SEGSZ （a、b）关联的共享内存段的大小。

CPID （a、p）共享内存项的创建程序的进程标识。

LPID （a、p）连接或者拆离共享内存段的最后一个进程的标识。

ATIME （a、t）最后一次与关联的共享内存段完成连接的时间。

DTIME （a、t）最后一次与关联的共享内存段完成拆离的时间。

NSEMS （a、b）在与信号项相关联的信号集中的信号量数量。

OTIME （a、t）在关联的信号量中完成信号量操作的时间。

SID （S）共享内存段的标识。SID 可以用作 svmon -S 命令的输入。

该命令支持多字节字符集。

标志

-a 使用 -b、-c、-o、-p 和 -t 标志。

-b 写入消息队列的队列上消息的最大字节数、共享内存段的大小、每个信号量集中信号量的数量。

-c 写入构建该设施的用户的登录名和组名称。

-CCoreFile 用由 CoreFile 参数指定的文件来代替 /dev/mem 文件。CoreFile 参数是由 Ctrl-(left)Alt-Pad1 按键顺序创建的内存映象文件。

-l 当和 -S 标志一起使用时，该标志写入未展开的 SID 列表。

-m 写入一些关于活动共享内存段的信息。

-NKernel 用指定的 Kernel（ /usr/lib/boot/unix 文件是缺省的）。

-o 写以下的使用信息：

队列上的消息数

消息队列上消息的总字节数

连接在共享内存段上的进程数

-p 写进程编号的信息：

最后接收消息队列上消息的进程号

最后在消息队列上发送消息的进程号

创建进程的进程号

最后一个连接或拆离共享内存段的进程编号

-P 写入与共享内存标识有关的 SID（段标识）列表，以及保留在那个段中的字节数，和段是否已启用大页的标志符。如果段支持大页面，就显示一个 'Y'，否则显示一个 '-'。

-q 写入一些关于活动消息队列的信息。

-s 写入一些关于活动信号量集的信息。

-S 写入连接在共享内存标识上的 SID 列表。

-t 写入时间信息：

最后一次更改所有设备访问许可权的控制操作的时间。

消息队列上最后一次执行 msgsnd 和 msgrcv 的时间。

共享内存上最后一次执行 shmat 和 shmdt 的时间。

在信号量集上最后一次执行 semop 的时间。

-T 写入带有日期的 -t 标记的输出。

注:

如果用户指定 -C 或者 -N 标记，实型和有效的 UID／GID 设置为调用 ipcs 的用户的实型 UID／GID。

当运行 ipcs 时可以更改值；仅当检索它时它给出的信息才保证是正确的。

# #

## ipcs用法 ##

ipcs -a  是默认的输出信息 打印出当前系统中所有的进程间通信方式的信息

ipcs -m  打印出使用共享内存进行进程间通信的信息

ipcs -q   打印出使用消息队列进行进程间通信的信息

ipcs -s  打印出使用信号进行进程间通信的信息

输出格式的控制

ipcs -t   输出信息的详细变化时间

】【

ipcs -u  输出当前系统下ipc各种方式的状态信息(共享内存，消息队列，信号)

## ipcrm 命令 ##

移除一个消息对象。或者共享内存段，或者一个信号集，同时会将与ipc对象相关链的数据也一起移除。当然，只有超级管理员，或者ipc对象的创建者才有这项权利啦

## ipcrm用法 ##

ipcrm -M shmkey  移除用shmkey创建的共享内存段

ipcrm -m shmid    移除用shmid标识的共享内存段

ipcrm -Q msgkey  移除用msqkey创建的消息队列

ipcrm -q msqid  移除用msqid标识的消息队列

ipcrm -S semkey  移除用semkey创建的信号

ipcrm -s semid  移除用semid标识的信号

】【

linux/uinx上提供关于一些进程间通信方式的信息，包括共享内存，消息队列，信号

ipcs用法   
ipcs -a  是默认的输出信息 打印出当前系统中所有的进程间通信方式的信息  
ipcs -m  打印出使用共享内存进行进程间通信的信息  
ipcs -q   打印出使用消息队列进行进程间通信的信息  
ipcs -s  打印出使用信号进行进程间通信的信息

**输出格式的控制**  
ipcs -t   输出信息的详细变化时间

[![201308230906245.jpg][]][201308230906245.jpg]

ipcs -p  输出ipc方式的进程ID  
ipcs -c  输出ipc方式的创建者/拥有者

[![201308230906246.jpg][]][201308230906246.jpg]

ipcs -c  输出ipc各种方式的在该系统下的限制条件信息

[![201308230906247.jpg][]][201308230906247.jpg]

ipcs -u  输出当前系统下ipc各种方式的状态信息(共享内存，消息队列，信号)

ipcrm 命令   
移除一个消息对象。或者共享内存段，或者一个信号集，同时会将与ipc对象相关链的数据也一起移除。当然，只有超级管理员，或者ipc对象的创建者才有这项权利啦

**ipcrm用法 **  
ipcrm -M shmkey  移除用shmkey创建的共享内存段  
ipcrm -m shmid    移除用shmid标识的共享内存段  
ipcrm -Q msgkey  移除用msqkey创建的消息队列  
ipcrm -q msqid  移除用msqid标识的消息队列  
ipcrm -S semkey  移除用semkey创建的信号  
ipcrm -s semid  移除用semid标识的信号

】

*  查找当前目录以及字母下以.c结尾的文件，且文件中包含”hello world”的文件的路径

【

# [cmd find命令][cmd find] #

find 作用：从文件中收索字符串

格式：find 参数 "字符串" 路径\\文件名

参数： /V 显示所有未包含指定字符串的行。

/C 仅显示包含字符串的行数。

/N 显示行号。

/I 搜索字符串时忽略大小写。

/OFF\[LINE\] 不要跳过具有脱机属性集的文件。

当文件中包含要查找的字符串时，将返回这个字符串所在位置的整行内容。默认情况下是区分大小写的，若想要

不区分大小写就是用参数 /i 有时候，我们的需求并不是为了查找到某个字符串，而是要检测哪些行不含有特定的

字符串，这个时候，可以使用开关/v，用法为：find /v "Abc" test.txt，它表示查找那些不含字符串Abc的行（Abc要

区分大小写），如果不区分abc的大小写，那么，应该写成 find /i /v "Abc" test.txt。还有一点是find 支持查找通配

符文件。如 find "1" \*.txt。

findstr 是find的扩展，功能更强大

格式：findstr 参数 字符串 路径\\文件名

参数： /B 在一行的开始配对模式。 (就是指以字符串开头，begin 这样就方便了记忆)

/E 在一行的结尾配对模式。（就是指以字符串结尾，end 这样就方便记忆）

/L 按字使用搜索字符串。就是将后面的""里的当成一个字符

/R 将搜索字符串作为一般表达式使用。

/S 在当前目录和所有子目录中搜索匹配文件。

/I 指定搜索不分大小写。（英文：ignore 忽略）

/X 打印完全匹配的行。/x 是指完全匹配,就是说整行匹配,而不是含有关键字.

/V 只打印不包含匹配的行。（就是找出不包含字符串的）

/N 在匹配的每行前打印行数。（就是在输出行的前面加上原文件中的行数，英文：number）

显示的结果中冒号（:）是英文格式下的，在用for提取的时候需要注意！

/M 如果文件含有匹配项，只打印其文件名。（指定文件中输出含有字符串的文件名）

/O 在每个匹配行前打印字符偏移量。o开关的作用是告诉你每行第一个字符前的位置是该文件中的第几个字节

计算时别忘了文本中不可见的回车符合换行符将占两字节（某些文本中只占一字节）。还有空格键一个字符。

肯定听不懂。看例子：1.txt文件内容： 就三行三个c没有空格。输入：findstr /o c 1.txt 结果是：

c 0:c

c 3:c

c 6:c

怎么计算：第一行的c前没有字符所以是0.第二行的c前一行只有一个c算一个字符由于是第二行所以算一个回车

2个字符就是：1+2=3同理第三个c前有2个字符和2个回车：1\*2+2\*2=6.。

/P 忽略有不可打印字符的文件。(我不清楚，个人无法解释)

/C:string 使用指定字符串作为文字搜索字符串。

如：findstr /c:"a b" 1.txt 就会找出含"a b"的行并输出来（注意a和b中间有空格）

如果不用参数/c：findstr "a b" 1.txt 就会输出含有字母 a 或 b 的行。

/G:file 从指定的文件获得搜索字符串。 (/ 代表控制台)。

如：findstr /g:2.txt 1.txt 就是把1.txt中含有2.txt中任一行内容的行输出来。

上面的有点像：@echo off

for /f "delims=" %%a in ('type 2.txt') do (

findstr "%%a" 1.txt

echo.)

pause

（以上是自己试出来的，不保证正确）

/A:attr 指定有十六进位数字的颜色属性。请见 "color /?"（使用这个可以在dos上面搞出不同颜色的字，自己想想）

/F:file 从指定文件读文件列表 (/ 代表控制台)。

/D:dir 查找以分号为分隔符的目录列表

/OFF\[LINE\] 不跳过带有脱机属性集的文件。

除非参数有 /C 前缀，请使用空格隔开搜索字符串。

例如: FINDSTR "hello there" x.y 在文件 x.y 中寻找 "hello"或"there" 。 FINDSTR /C:"hello there" x.y 文

件 x.y 寻找"hello there"。

一般表达式的快速参考:

. 通配符: 任何字符

\* 重复: 以前字符或类别出现零或零以上次数

^ 行位置: 行的开始

$ 行位置: 行的终点

\[class\] 字符类别: 任何在字符集中的字符

\[^class\] 补字符类别: 任何不在字符集中的字符

\[x-y\] 范围: 在指定范围内的任何字符

\\x Escape: 元字符 x 的文字用法

\\<xyz 字位置: 字的开始

xyz\\> 字位置: 字的结束

<和\\>是单词锚定 ^是行首 $是行尾

注意的是：别把^，$和\\<,\\>弄混了一个是行一个是字。行开始与结束没什么好说的。而字的开始和结束就不一样了，例如：

1.txt里两行为"abcd" 和 "abcd e"用命令findstr "cd\\>" 1.txt 两行都会出现，只要是连在一起（没被空格开）的

并以cd结尾的（不 要求是行尾）都满足。相当于文本中出现英语中以cd结尾的的单词了的行都会输出来。

举一些例子（来自网络）：

1.findstr . 2.txt 或 findstr "." 2.txt 2.findstr .\* 2.txt 或 findstr ".\*" 2.txt

从文件2.txt中查找任意字符，不包括空字符或空行 从文件2.txt中查找任意字符包括空行和空字符

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

3.findstr "\[0-9\]" 2.txt 4.findstr "\[a-zA-Z\]" 2.txt

从文件2.txt中查找包括数字0－9的字符串或行 从文件2.txt中查找包括任意字符的字符串或行

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

5.findstr "\[abcezy\]" 2.txt 6.findstr "\[a-fl-z\]" 2.txt

从文件2.txt中查找包括a b c e z y字母的字符串或行 从文件2.txt中查找小写字符a-f l-z的字符串，但不包含g h I j k这几个字母。

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

7.findstr "M\[abc\]\[hig\]Y" 2.txt 8. ^和$符号的应用

从文件2.txt中可以匹配 MahY , MbiY, MahY等….. ^ 表示行首，"^step"仅匹配 "step hello world"中的第一个单词

$ 表示行尾，"step$"仅匹配 "hello world step"中最后一个单词

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝ ＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

9.finstr "\[^0-9\]" 2.txt

如果是纯数字的字符串或者行便过滤掉，例如2323423423 这样的字符串，如果是345hh888这样的形式就不成了。

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

10.findstr "\[^a-z\]" 2.txt

同上，如果是纯字母的字符串或者行便过滤掉，例如 sdlfjlkjlksjdklfjlskdf这样的字符，如果是sdfksjdkf99999这样的形式，掺杂着数字就不成了

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

11.\*号的作用

前面已经说过了 ".\*"表示搜索的条件是任意字符，\*号在正则表达式中的作用不是任何字符，而是表示左侧字符或者表达式的重复次数，\*号表示重复的次数为零次或者多次。

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

12.findstr "^\[0-9\]\*$" 2.txt

这个是匹配找到的纯数字，例如 234234234234，如果是2133234kkjl234就被过滤掉了。

Findstr "^\[a-z\]\*$" 2.txt

这个是匹配找到的纯字母，例如 sdfsdfsdfsdf，如果是213sldjfkljsdlk就被过滤掉了

如 果在搜索条件里没有\*号，也就是说不重复左侧的搜索条件，也就是\[0-9\] \[a-z\]那只能匹配字符串的第一个字符也只有这一个字符，因为有行首和行尾的限制，"^\[0-9\]$"第一个字符如果是数字就匹配，如果不是就过滤掉， 如果字符串是 9 就匹配，如果是98或者9j之类的就不可以了。

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

13. "\\<…\\>"这个表达式的作用

这个表示精确查找一个字符串，\\<sss 表示字的开始位置，sss\\>表示字的结束位置

echo hello world computer|findstr "\\<computer\\>"这样的形式

echo hello worldcomputer|findstr "\\<computer\\>" 这样的形式就不成了，他要找的是 "computer"这个字符串，所以不可以。

echo hello worldcomputer|findstr ".\*computer\\>"这样就可以匹配了

14.吧1.txt文档中超过10个字符的行输出到2.txt

@findstr .......... 1.txt>2.txt

感觉好像2.txt里是少于10个字符的行，可是实际却是超过10个字符的行，包括10个字符。

以上内容转自：[http://hi.baidu.com/bs0%D0%A1%B3%C2/blog/item/3f9c39ee0d29c0cbd439c94a.html][http_hi.baidu.com_bs0_D0_A1_B3_C2_blog_item_3f9c39ee0d29c0cbd439c94a.html]

find比findstr更强的地方：

1、统计含指定字符串的总行数。find /c "abc" test.txt可以统计test.txt中含有字符串abc的总行数，而findstr则没有直接提供该功能，需要配合for语句才能实现；

2、find可以读取Unicode格式的文本，而findstr则不行；

3、find可以过滤某些特殊字符，而findstr则不行，比如，我们在使用fsutil fsinfo drives语句查询磁盘分区的时候，如果想让盘符分行显示而不是显示在同一行上的时候（这在用for语句提取盘符的时候很有用），find可以大显身手，而findstr只能干瞪眼了，具体语句为： 代码: fsutil fsinfo drives|find /v ""

】

*  创建定时任务

[https://blog.csdn.net/hi\_kevin/article/details/8983746][https_blog.csdn.net_hi_kevin_article_details_8983746]

[https://www.jb51.net/article/101272.htm][https_www.jb51.net_article_101272.htm]

【

*  linux为当前用户创建定时任务

1.  键入 crontab  -e 编辑crontab服务文件

例如 文件内容如下:

\*/2 \* \* \* \* /bin/sh /home/admin/jiaoben/buy/deleteFile.sh

保存文件并并退出

\*/2 \* \* \* \* /bin/sh /home/admin/jiaoben/buy/deleteFile.sh

\*/2 \* \* \* \* 通过这段字段可以设定什么时候执行脚本

/bin/sh /home/admin/jiaoben/buy/deleteFile.sh 这一字段可以设定你要执行的脚本,这里要注意一下bin/sh 是指运行  脚本的命令  后面一段时指脚本存放的路径

2. 查看该用户下的crontab服务是否创建成功, 用 crontab  -l 命令

3. 启动crontab服务

一般启动服务用  /sbin/service crond start 若是根用户的cron服务可以用 sudo service crond start, 这里还是要注意  下 不同版本linux系统启动的服务的命令也不同 ,像我的虚拟机里只需用 sudo service cron restart 即可,若是在根用下直接键入service cron start就能启动服务

4. 查看服务是否已经运行用 ps -ax | grep cron

5. crontab命令

cron服务提供crontab命令来设定cron服务的,以下是这个命令的一些参数与说明:

crontab -u //设定某个用户的cron服务,一般root用户在执行这个命令的时候需要此参数

crontab -l //列出某个用户cron服务的详细内容

crontab -r //删除没个用户的cron服务

crontab -e //编辑某个用户的cron服务

比如说root查看自己的cron设置:crontab -u root -l

再例如,root想删除fred的cron设置:crontab -u fred -r

在编辑cron服务时,编辑的内容有一些格式和约定,输入:crontab -u root -e

进入vi编辑模式,编辑的内容一定要符合下面的格式:\*/1 \* \* \* \* ls >> /tmp/ls.txt

任务调度的crond常驻命令

crond 是linux用来定期执行程序的命令。当安装完成操作系统之后,默认便会启动此

任务调度命令。crond命令每分锺会定期检查是否有要执行的工作,如果有要执行的工

作便会自动执行该工作。

6. crontab命令选项:

-u指定一个用户

-l列出某个用户的任务计划

-r删除某个用户的任务

-e编辑某个用户的任务

7. cron文件语法:

分     小时    日       月       星期     命令

0-59   0-23   1-31   1-12     0-6     command     (取值范围,0表示周日一般一行对应一个任务)

记住几个特殊符号的含义:

“\*”代表取值范围内的数字,

“/”代表”每”,

“-”代表从某个数字到某个数字,

“,”分开几个离散的数字

8. 任务调度设置文件的写法

可用crontab -e命令来编辑,编辑的是/var/spool/cron下对应用户的cron文件,也可以直接修改/etc/crontab文件

具体格式如下:

Minute Hour Day Month Dayofweek   command

分钟     小时   天     月       天每星期       命令

每个字段代表的含义如下:

Minute             每个小时的第几分钟执行该任务

Hour               每天的第几个小时执行该任务

Day                 每月的第几天执行该任务

Month             每年的第几个月执行该任务

DayOfWeek     每周的第几天执行该任务

Command       指定要执行的程序

在这些字段里,除了“Command”是每次都必须指定的字段以外,其它字段皆为可选

字段,可视需要决定。对于不指定的字段,要用“\*”来填补其位置。

举例如下:

5       \*       \*           \*     \*     ls             指定每小时的第5分钟执行一次ls命令

30     5       \*           \*     \*     ls             指定每天的 5:30 执行ls命令

30     7       8         \*     \*     ls             指定每月8号的7:30分执行ls命令

30     5       8         6     \*     ls             指定每年的6月8日5:30执行ls命令

30     6       \*           \*     0     ls             指定每星期日的6:30执行ls命令\[注:0表示星期天,1表示星期1,

以此类推,也可以用英文来表示,sun表示星期天,mon表示星期一等。\]

30     3     10,20     \*     \*     ls     每月10号及20号的3:30执行ls命令\[注:“,”用来连接多个不连续的时段\]

25     8-11 \*           \*     \*     ls       每天8-11点的第25分钟执行ls命令\[注:“-”用来连接连续的时段\]

\*/15   \*       \*           \*     \*     ls         每15分钟执行一次ls命令 \[即每个小时的第0 15 30 45 60分钟执行ls命令 \]

30   6     \*/10         \*     \*     ls       每个月中,每隔10天6:30执行一次ls命令\[即每月的1、11、21、31日是的6:30执行一次ls 命令。 \]

每天7:50以root 身份执行/etc/cron.daily目录中的所有可执行文件

50   7       \*             \*     \*     root     run-parts     /etc/cron.daily   \[ 注:run-parts参数表示,执行后面目录中的所有可执行文件。 \]

9. 新增调度任务

新增调度任务可用两种方法:

1)、在命令行输入: crontab -e 然后添加相应的任务,wq存盘退出。

2)、直接编辑/etc/crontab 文件,即vi /etc/crontab,添加相应的任务。

10. 查看调度任务

crontab -l //列出当前的所有调度任务

crontab -l -u jp   //列出用户jp的所有调度任务

11. 删除任务调度工作

crontab -r   //删除所有任务调度工作

12. 任务调度执行结果的转向

例1:每天5:30执行ls命令,并把结果输出到/jp/test文件中

30 5 \* \* \* ls >/jp/test 2>&;1

注:2>&;1 表示执行结果及错误信息。

编辑/etc/crontab 文件配置cron

cron服务每分钟不仅要读一次/var/spool/cron内的所有文件,还需要读一次 /etc/crontab,因此我们配置这个文件也能运用cron服务做一些事情。用crontab配置是针对某个用户的,而编辑/etc/crontab是针对系统的任务。此文件的文件格式是:

SHELL=/bin/bash

PATH=/sbin:/bin:/usr/sbin:/usr/bin

MAILTO=root //如果出现错误,或者有数据输出,数据作为邮件发给这个帐号

HOME=/ //使用者运行的路径,这里是根目录

\# run-parts

01   \*   \*   \*   \*     root run-parts /etc/cron.hourly         //每小时执行

/etc/cron.hourly内的脚本

02   4   \*   \*   \*     root run-parts /etc/cron.daily           //每天执行/etc/cron.daily内的脚本

22   4   \*   \*   0     root run-parts /etc/cron.weekly       //每星期执行 /etc/cron.weekly内的脚本

42   4   1   \*   \*     root run-parts /etc/cron.monthly     //每月去执行/etc/cron.monthly内的脚本

大家注意”run-parts”这个参数了,如果去掉这个参数的话,后面就可以写要运行的某个脚本名,而不是文件夹名了

例如:

1) 在命令行输入: crontab -e 然后添加相应的任务,wq存盘退出。

2)直接编辑/etc/crontab 文件,即vi /etc/crontab,添加相应的任务

11 2 21 10 \* rm -rf /mnt/fb

】

### IO模型 ###

*  **五种IO模型：**阻塞IO，非阻塞IO，IO复用，信号驱动式IO，异步IO

# \{linux基础——linux下五种IO模型小结（阻塞IO、非阻塞IO、IO复用、信号驱动式IO、异步IO）\} #

【

一、阻塞IO模型 (同步I/O)  
阻塞IO是指进程进行IO操作的时候，因为数据没准备好或者缓冲区里没有空间而无法进行IO操作会进入睡眠，直到数据准备或者缓冲区有空间才回被唤醒的行为。阻塞IO是最通用的IO类型，所有套接字默认情况下都是阻塞的。

输入操作：read、readv、recv、recvfrom和recvmsg，调用这些输入函数之一，如果缓冲区没有数据可读，该进程会投入睡眠，直到有一些数据可达才被唤醒，唤醒之后把相应数据复制到接受缓冲区或者发送错误才返回。  
输出操作：write、writev、send、 sendto 和 sendmsg，调用这些输出函数之一，如果发送缓冲区里面没有空间，进程也将进入睡眠，直到有空间为止才被唤醒，唤醒之后把相应数据写到发送缓冲区才会返回，返回值将是内核能够复制到该缓冲区中的字节数。

二、非阻塞IO模型 (同步I/O)  
非阻塞IO使我们进行IO操作时，不会因为这些操作阻塞，如果这个操作不能完成，则调用后立刻出错返回。

把套接字设置成非阻塞的代码如下：  
int set\_nonblock(int fd)  
\{  
        int old\_option = fcntl(fd, F\_GETFL);  
        int new\_option = old\_option | O\_NONBLOCK;  
        fcntl(fd, F\_SETFL, new\_option);  
   
        return old\_option;  
\}

输入操作：如果输入操作不能被满足（对于TCP套接字即至少有一个字节的数据可读，对于UDP套接字即有一个完整的数据报可读）,内核中没有给返回相应的数据，那么，调用将立即返回一个-1错误。需要数据的话，我们必须持续的调用这个函数（也就是所谓的循环接收这种循环接收并不是阻塞，从而对CPU造成极大的浪费，也就是忙等，想要等待一定的数据，但是这些数据并没有到来，并且还占用着CPU，不太经常使用这种IO模型)。从而将内核空间的值拷贝到用户空间。一旦拷贝完成了，输入函数就可以返回了，返回的值也就不是-1了。  
输出操作：对于一个非阻塞的TCP套接字，如果其发送缓冲区中根本没有空间，输出函数调用将立即返回一个-1错误。如果其发送缓冲区中还有一些空间，返回值将是内核能够复制到该缓冲区中的字节数。

三、IO复用 (同步I/O)  
IO复用是一种预先告知内核的能力，使得内核一旦发现指定的描述符集合中有一个或多个触发IO条件，它就会通知进程。这个能力叫做IO复用。  
使用IO复用模型，我们可以调用select或者epoll，阻塞在这两个系统调用（select、epoll\_wait）之上，而不是阻塞在真正的I/O系统调用调用上（需要事先把监听的套接字设置成非阻塞）。可以同时对多个读操作，多个写操作的I/O函数进行检测，直到有数据可读或可写时，才真正调用I/O操作函数。  
注意：  
当一个服务器 在处理多个客户时，绝对不能阻塞于单个客户相关的系统函数调用。否则导致服务器端程序被挂起，不能为其它客户提供服务。解决方法如下：  
（1）使用非阻塞式I/O （2）对每个客户有单独的控制进程提供服务 （3）对每个I/O操作设置一个超时。

四、信号驱动式IO (同步I/O)  
信号驱动式IO就是指进程预先告知内核，当某个描述符上发送事件时，内核使用信号通知相关进程。信号驱动式IO并没有实现真正的异步，因为通知到进程之后，依然是由进程来完成IO操作。

对于TCP套接字：信号驱动式IO不适合处理TCP套接字，因为信号产生的过与频繁，在TCP中，连接请求完成、断开连接发起、断开连接完成、数据到达、数据送走。。。都会产生SIGIO。但是我们真正只需要它在数据到达或者数据送走的时候才产生信号。  
对于UDP套接字：SIGIO信号在数据报到达套接字以及套接字上发生异步错误才会发生。（UDP套接字推荐使用）。  
对于一个套接字使用信号驱动式IO，要求进程执行以下三个步骤：  
（1）建立SIGIO信号的信号处理函数。  
（2）设置该套接字的属主，通常使用fcntl的F\_SETOWN命令设置。  
（3）开启该套接字的信号驱动式IO，通常使用fcntl的F\_SETFL命令打开O\_ASYNC标志完成。

五、异步IO  
 当一个异步过程调用发出后，调用者不能立刻得到结果。实际处理这个调用的部件在完成后，通过状态、通知和回调来通知调用者的输入输出操作。

调用aio\_read函数（POSIX异步IO函数一aio\_或者lio\_开头），给内核传递描述符、缓冲区指针、缓冲区大小（和read相同的三个参数）和文件偏移（与lseek类似），告诉内核当整个操作完成时，如何通知我们。该系统调用立刻返回，而且在等待IO完成期间，我们的进程不被阻塞。

信号驱动式IO和异步IO的区别：  
信号驱动式IO是进程事先建立SIGIO的信号处理程序（用sigaction设置IO信号的处理方式），有如果有数据到来，内核会给进程发一个信号，通知进程，进程捕获到这个信号就会去执行处理函数部分，一般在这个函数中执行IO操作（信号发生在IO之前，IO由进程完成）。  
异步IO是有进程请求异步读操作，会把套接字描述符，缓冲区指针、缓冲区大小和文件偏移一起发给内核，如果有数据到来，内核会把数据拷到相应的位置，然后给进程发一个信号，如果数据没有来，也必须等数据来了，内核把数据拷完之后，才给进程发一个信号，由内核通知我们IO操作何时完成（信号发生在IO之后，IO由内核完成）

阻塞与非阻塞的区别：  
阻塞和非阻塞关注的是进程在等待调用结果（消息、返回值）时的状态。阻塞是指调用结果返回之前，当前进程会被挂起。调用进程只有在得到结果才会返回。非阻塞调用指不能立刻得到结果，该调用不会阻塞当前进程。

同步与异步的区别：  
同步与异步关注的是进程之间的协作方式，同步是A进程必须得到B进程通知才能去执行某件事（A执行），异步是指A进程通知B进程去执行然后立刻得到返回，然后就可以去做自己的事，B完成之后会给A发一个通知（B执行）

】[https://blog.csdn.net/a987073381/article/details/52201200][https_blog.csdn.net_a987073381_article_details_52201200]

[http://blog.chinaunix.net/uid-28458801-id-4464639.html][http_blog.chinaunix.net_uid-28458801-id-4464639.html]

*  **select，poll，epoll的区别**

**select：**是最初解决IO阻塞问题的方法。用结构体fd\_set来告诉内核监听多个文件描述符，该结构体被称为描述符集。由数组来维持哪些描述符被置位了。对结构体的操作封装在三个宏定义中。通过轮寻来查找是否有描述符要被处理，如果没有返回\*\*  
存在的问题：   
1. 内置数组的形式使得select的最大文件数受限与FD\_SIZE；   
2. 每次调用select前都要重新初始化描述符集，将fd从用户态拷贝到内核态，每次调用select后，都需要将fd从内核态拷贝到用户态；   
3. 轮寻排查当文件描述符个数很多时，效率很低；

**poll：**通过一个可变长度的数组解决了select文件描述符受限的问题。数组中元素是结构体，该结构体保存描述符的信息，每增加一个文件描述符就向数组中加入一个结构体，结构体只需要拷贝一次到内核态。poll解决了select重复初始化的问题。轮寻排查的问题未解决。\*\*

**epoll：**轮寻排查所有文件描述符的效率不高，使服务器并发能力受限。因此，epoll采用只返回状态发生变化的文件描述符，便解决了轮寻的瓶颈。  
\- 为什么使用IO多路复用，最主要的原因是什么？   
\- epoll有两种触发模式？这两种触发模式有什么区别？编程的时候有什么区别？   
\- 上一题中编程的时候有什么区别，是在边缘触发的时候要把套接字中的数据读干净，那么当有多个套接字时，在读的套接字一直不停的有数据到达，如何保证其他套接字不被饿死(面试网易游戏的时候问的一个问题，答不上来，印象贼深刻)。

1.  [select/poll/epoll区别][select_poll_epoll]
2.  [几种网络服务器模型的介绍与比较][Link 19]
3.  [epoll为什么这么快][epoll](搞懂这篇文章，关于IO复用的问题就信手拈来了)

### 线程池，内存池 自己动手实现一遍 ###

【

池的概念

由于服务器的硬件资源“充裕”，那么提高服务器性能的一个很直接的方法就是以空间换时间，即“浪费”服务器的硬件资源，以换取其运行效率。这就是池的概念。池是一组资源的集合，这组资源在服务器启动之初就完全被创建并初始化，这称为静态资源分配。当服务器进入正式运行阶段，即开始处理客户请求的时候，如果它需要相关的资源，就可以直接从池中获取，无需动态分配。很显然，直接从池中取得所需资源比动态分配资源的速度要快得多，因为分配系统资源的系统调用都是很耗时的。当服务器处理完一个客户连接后，可以把相关的资源放回池中，无需执行系统调用来释放资源。从最终效果来看，池相当于服务器管理系统资源的应用设施，它避免了服务器对内核的频繁访问。

池可以分为多种，常见的有内存池、进程池、线程池和连接池。

内存池

内存池是一种内存分配方式。通常我们习惯直接使用new、malloc等系统调用申请分配内存，这样做的缺点在于：由于所申请内存块的大小不定，当频繁使用时会造成大量的内存碎片并进而降低性能。

内存池则是在真正使用内存之前，先申请分配一定数量的、大小相等(一般情况下)的内存块留作备用。当有新的内存需求时，就从内存池中分出一部分内存块，若内存块不够再继续申请新的内存。这样做的一个显著优点是，使得内存分配效率得到提升。

进程池和线程池

进程池和线程池相似，所以这里我们以进程池为例进行介绍。如没有特殊声明，下面对进程池的描述也适用于线程池。

进程池是由服务器预先创建的一组子进程，这些子进程的数目在 3~10 个之间（当然这只是典型情况）。线程池中的线程数量应该和 CPU 数量差不多。

进程池中的所有子进程都运行着相同的代码，并具有相同的属性，比如优先级、 PGID 等。

当有新的任务来到时，主进程将通过某种方式选择进程池中的某一个子进程来为之服务。相比于动态创建子进程，选择一个已经存在的子进程的代价显得小得多。至于主进程选择哪个子进程来为新任务服务，则有两种方法：

1）主进程使用某种算法来主动选择子进程。最简单、最常用的算法是随机算法和 Round Robin （轮流算法）。

2）主进程和所有子进程通过一个共享的工作队列来同步，子进程都睡眠在该工作队列上。当有新的任务到来时，主进程将任务添加到工作队列中。这将唤醒正在等待任务的子进程，不过只有一个子进程将获得新任务的“接管权”，它可以从工作队列中取出任务并执行之，而其他子进程将继续睡眠在工作队列上。

当选择好子进程后，主进程还需要使用某种通知机制来告诉目标子进程有新任务需要处理，并传递必要的数据。最简单的方式是，在父进程和子进程之间预先建立好一条管道，然后通过管道来实现所有的进程间通信。在父线程和子线程之间传递数据就要简单得多，因为我们可以把这些数据定义为全局，那么它们本身就是被所有线程共享的。

线程池主要用于：

1）需要大量的线程来完成任务，且完成任务的时间比较短。 比如WEB服务器完成网页请求这样的任务，使用线程池技术是非常合适的。因为单个任务小，而任务数量巨大。但对于长时间的任务，比如一个Telnet连接请求，线程池的优点就不明显了。因为Telnet会话时间比线程的创建时间大多了。

2）对性能要求苛刻的应用，比如要求服务器迅速响应客户请求。

3）接受突发性的大量请求，但不至于使服务器因此产生大量线程的应用

】[https://blog.csdn.net/ywcpig/article/details/52557080][https_blog.csdn.net_ywcpig_article_details_52557080]【Linux进程池的实现[https://blog.csdn.net/Al\_xin/article/details/39258067][https_blog.csdn.net_Al_xin_article_details_39258067]

# \[C++\]\[线程池\]\[完整实现\] 转：线程池原理及创建（C++实现） #

[https://blog.csdn.net/yfcheng\_yzc/article/details/54291817][https_blog.csdn.net_yfcheng_yzc_article_details_54291817]

】

### Linux的API ###

*  **fork与vfork区别**   
    fork和vfork都用于创建子进程。但是vfork创建子进程后，父进程阻塞，直到子进程调用exit()或者excle()。   
    对于内核中过程fork通过调用clone函数，然后clone函数调用do\_fork()。do\_fork()中调用copy\_process()函数先复制task\_struct结构体，然后复制其他关于内存，文件，寄存器等信息。fork采用写时拷贝技术，因此子进程和父进程的页表指向相同的页框。但是vfork不需要拷贝页表，因为父进程会一直阻塞，直接使用父进程页表。[https://blog.csdn.net/jianchi88/article/details/6985326][https_blog.csdn.net_jianchi88_article_details_6985326]
 *  **exit()与\_exit()区别**   
    exit()清理后进入内核，\_exit()直接陷入内核。

1.  孤儿进程与僵死进程

孤儿进程是怎么产生的？

【

.僵死进程与孤儿进程

僵死进程：进程已经退出，但是没有回收内核 PCB 资源的进程叫僵死进程。

孤儿进程：父亲进程先于子进程退出后，这个子进程就是孤儿进程，父亲进程会被转移为 init(pid=1)进程。

】[https://blog.csdn.net/deyuzhi/article/details/52295452][https_blog.csdn.net_deyuzhi_article_details_52295452]

[https://blog.csdn.net/believe\_s/article/details/77040494][https_blog.csdn.net_believe_s_article_details_77040494]

1.  僵死进程是怎么产生的？
2.  僵死进程的危害？
3.  如何避免僵死进程的产生？

【一个进程在调用exit命令结束自己的生命的时候，其实它并没有真正的被销毁， 而是留下一个称为僵死进程（Zombie）的数据结构（系统调用exit，它的作用是使进程退出，但也仅仅限于将一个正常的进程变成一个僵死进程，并不能将其完全销毁）。  
“**僵死进程的产生**在每个进程退出的时候，内核释放该进程所有的资源，包括打开的文件，占用的内存等，但是仍然为其保留一定的信息(包括进程号the process ID，退出状态the   
termination status of the process，运行时间the amount of CPU time taken by the process等)， 直到父进程通过wait/waitpid来取时才释放。此时该进程处于僵死状态，该进程成为僵死进程(Zombie Process)。 这保证了父进程可以获取到子进程结束时的状态信息。  
在Linux进程的状态中，僵死进程是非常特殊的一种，它已经放弃了几乎所有内存空间，没有任何可执行代码，也不能被调度，仅仅在进程列表中保留一个位置，记载该进程的退出状态等信息供其他进程收集，除此之外，僵死进程不再占有任何内存空间。它需要它的父进程来为它收尸，如果他的父进程没安装SIGCHLD信号处理函数调用wait或waitpid()等待子进程结束，又没有显式忽略该信号，那么它就一直保持僵死状态，如果这时父进程结束了，僵死的子进程成为"孤儿进程"，过继给1号进程init，init始终会负责清理僵死进程，它产生的所有僵死进程也跟着消失（每个进程结束的时候，系统都会扫描当前系统中所运行的所有进程， 看有没有哪个进程是刚刚结束的这个进程的子进程，如果是的话，就由Init来接管他，成为他的父进程）。但是如果如果父进程是一个循环，不会结束，那么子进程就会一直保持僵死状态，这就是为什么系统中有时会有很多的僵死进程。怎么查看僵死进程，利用命令ps，可以看到有标记为Z的进程就是僵死进程。  
“**僵死进程的危害**如果父进程不调用wait/waitpid的话， 那么保留的那段信息就不会释放，其进程号会一定被占用，但是系统所能使用的进程号是有限的，如果产生了大量的僵死进程，将因为没有可用的进程号而导致系统不能产生新的进程。  
“**僵死进程的避免 **

1.  父进程通过wait和waitpid等函数等待子进程结束，这会导致父进程挂起 
2.  如果父进程很忙，那么可以用signal函数为SIGCHLD安装信号处理函数。子进程结束后，父进程会收到该信号，可以在信号处理函数中调用wait回收 。
3.  如果父进程不关心子进程什么时候结束，那么可以用signal(SIGCHLD, SIG\_IGN)通知内核，自己对子进程的结束不感兴趣，那么子进程结束后，内核会回收， 并不再给父进程发送信号。

或用sigaction函数为SIGCHLD设置SA\_NOCLDWAIT，这样子进程结束后，就不会进入僵死状态**struct sigaction sa;  
 sa.sa\_handler = SIG\_IGN;  
 sa.sa\_flags = SA\_NOCLDWAIT;  
 sigemptyset(&sa.sa\_mask);  
 sigaction(SIGCHLD, &sa, NULL); ** 
4.fork两次，父进程fork一个子进程，然后继续工作，子进程fork一个孙进程后退出，那么孙进程被init接管，孙进程结束后，init会回收。不过子进程的回收还要父进程来做。** int nStatus;****    pid\_t pid;** 
**    ** 
**    pid = vfork();            //生成子进程** 
**    if (pid > 0)            //父进程** 
**    \{** 
**        waitpid(pid, &nStatus, 0);    //等待子进程结束,否则子进程会成为僵死进程,一直存在,即便子进程已结束执行** 
**    \}** 
**    else if (0 == pid)        //子进程** 
**    \{** 
**        pid = vfork();        //生成孙进程** 
**        if (pid > 0) ** 
**        \{** 
**            exit(0);        //子进程退出,孙进程过继给init进程,其退出状态也由init进程处理,与原有父进程无关** 
**        \}** 
**        else if (0 == pid)    //孙进程** 
**        \{** 
**            if (execlp("ls", "ls", NULL) < 0)** 
**            \{** 
**                perror("execlp");** 
**                exit(-1);** 
**            \}** 
**        \}** 
**        else** 
**        \{ ** 
**            perror("vfork(child)"); ** 
**        \} ** 
**    \}** 
**    else** 
**    \{ ** 
**        perror("vfork(parent)"); ** 
**    \} ** 
**\}**】

*  **Linux是如何避免内存碎片的**
    
    1.  伙伴算法，用于管理物理内存，避免内存碎片;
    2.  高速缓存Slab层用于管理内核分配内存，避免碎片。
 *  **共享内存的实现原理？**   
    共享内存实现分为两种方式一种是采用mmap，另一种是采用XSI机制中的共享内存方法。mmap是内存文件映射，将一个文件映射到进程的地址空间，用户进程的地址空间的管理是通过vm\_area\_struct结构体进行管理的。mmap通过映射一个相同的文件到两个不同的进程，就能实现这两个进程的通信，采用该方法可以实现任意进程之间的通信。mmap也可以采用匿名映射，不指定映射的文件，但是只能在父子进程间通信。XSI的内存共享实际上也是通过映射文件实现，只是其映射的是一种特殊文件系统下的文件，该文件是不能通过read和write访问的。

二者区别：

> 1、 系统V共享内存中的数据，从来不写入到实际磁盘文件中去；而通过mmap()映射普通文件实现的共享内存通信可以指定何时将数据写入磁盘文件中。注：前面讲到，系统V共享内存机制实际是通过映射特殊文件系统shm中的文件实现的，文件系统shm的安装点在交换分区上，系统重新引导后，所有的内容都丢失。
> 
> 2、 系统V共享内存是随内核持续的，即使所有访问共享内存的进程都已经正常终止，共享内存区仍然存在（除非显式删除共享内存），在内核重新引导之前，对该共享内存区域的任何改写操作都将一直保留。
> 
> 3、 通过调用mmap()映射普通文件进行进程间通信时，一定要注意考虑进程何时终止对通信的影响。而通过系统V共享内存实现通信的进程则不然。注：这里没有给出shmctl的使用范例，原理与消息队列大同小异。

*  系统调用与库函数(open, close, create, lseek, write, read)
 *  同步方法有哪些？
    
    1.  互斥锁，自旋锁，信号量，读写锁，屏障
    2.  互斥锁与自旋锁的区别：互斥锁得不到资源的时候阻塞，不占用cpu资源。自旋锁得不到资源的时候，不停的查询，而然占用cpu资源。
    3.  [死锁][Link 18]

### 其他 ###

*  \++i是否是原子操作   
    明显不是，++i主要有三个步骤，把数据从内存放在寄存器上，在寄存器上进行自增，把数据从寄存器拷贝会内存，每个步骤都可能被中断。
 *  判断大小端

union un
 {
 int i;
 char ch;
 };
 
 void fun()
 {
 union un test;
 test.i = 1;
 if(ch == 1)
 cout << "小端" << endl;
 else
 cout << "大端" << endl;
 }

## 设计模式 ##

*  [单例模式线程安全的写法][Link 20]

[https://www.cnblogs.com/qiaoconglovelife/p/5851163.html][https_www.cnblogs.com_qiaoconglovelife_p_5851163.html]

[https://blog.csdn.net/cselmu9/article/details/51366946][https_blog.csdn.net_cselmu9_article_details_51366946]

*  STL里的迭代器使用了迭代器模式

[https://blog.csdn.net/Dawn\_sf/article/details/77929225][https_blog.csdn.net_Dawn_sf_article_details_77929225]

[https://blog.csdn.net/hyman\_yx/article/details/51982488][https_blog.csdn.net_hyman_yx_article_details_51982488]

*  MVC的理解

[https://blog.csdn.net/zch501157081/article/details/51967549][https_blog.csdn.net_zch501157081_article_details_51967549]

【

MVC简介：

MVC全名是Model View Controller，如图，是模型(model)－视图(view)－控制器(controller)的缩写，一种软件设计典范，用一种业务逻辑、数据、界面显示分离的方法组织代码，在改进和个性化定制界面及用户交互的同时，不需要重新编写业务逻辑。  
其中M层处理数据，业务逻辑等；V层处理界面的显示结果；C层起到桥梁的作用，来控制V层和M层通信以此来达到分离视图显示和业务逻辑层。

Android中的MVC：

视图层(View)  
一般采用XML文件进行界面的描述，这些XML可以理解为Android App的View。使用的时候可以非常方便的引入。同时便于后期界面的修改。逻辑中与界面对应的id不变化则代码不用修改，大大增强了代码的可维护性。  
控制层(Controller) ------ Activity  
Android的控制层的重任通常落在了众多的Activity的肩上。这句话也就暗含了不要在Activity中写代码，要通过Activity交割Model业务逻辑层处理，这样做的另外一个原因是Android中的Actiivity的响应时间是5s，如果耗时的操作放在这里，程序就很容易被回收掉。  
模型层(Model)  
我们针对业务模型，建立的数据结构和相关的类，就可以理解为AndroidApp的Model，Model是与View无关，而与业务相关的（感谢@Xander的讲解）。对数据库的操作、对网络等的操作都应该在Model里面处理，当然对业务计算等操作也是必须放在的该层的。就是应用程序中二进制的数据。

MVC的缺点：  
在Android开发中，Activity并不是一个标准的MVC模式中的Controller，它的首要职责是加载应用的布局和初始化用户 界面，并接受并处理来自用户的操作请求，进而作出响应。随着界面及其逻辑的复杂度不断提升，Activity类的职责不断增加，以致变得庞大臃肿。

总结：  
视图（View）：用户界面。  
控制器（Controller）：业务逻辑  
模型（Model）：数据保存  
View 传送指令到 Controller  
Controller 完成业务逻辑后，要求 Model 改变状态  
Model 将新的数据发送到 View，用户得到反馈

![Image 1][]

Q~NVG2FU~\`1UGAPBC64MO\}5.png

】

## 分布式系统 ##

*  [map\_reduce原理][map_reduce] （这篇文章讲的很通俗易懂）
 *  负载均衡

【

负载均衡(Load Balance，简称LB)是一种服务器或网络设备的集群技术。负载均衡将特定的业务(网络服务、网络流量等)分担给多个服务器或网络设备，从而提高了业务处理能力，保证了业务的高可用性。负载均衡基本概念有：实服务、实服务组、虚服务、调度算法、持续性等，其常用应用场景主要是服务器负载均衡，链路负载均衡。

**一 服务器负载均衡**

服务器负载均衡根据LB设备处理到的报文层次，分为四层服务器负载均衡和七层负载均衡，四层处理到IP包的IP头，不解析报文四层以上载荷(L4 SLB);七层处理到报文载荷部分，比如HTTP，RTSP，SIP报文头，有时也包括报文内容部分(L7 SLB)。

**1.四层服务器负载均衡技术**

客户端将请求发送给服务器群前端的负载均衡设备，负载均衡设备上的虚服务接收客户端请求，通过调度算法，选择真实服务器，再通过网络地址转换，用真实服务器地址重写请求报文的目标地址后，将请求发送给选定的真实服务器;真实服务器的响应报文通过负载均衡设备时，报文的源地址被还原为虚服务的VSIP，再返回给客户，完成整个负载调度过程。报文交互流程如下：

![新一代负载均衡产品技术实现 图1][_1]

NAT方式的服务器负载均衡报文交互流程图报文交互流程说明：

(1)Host发送服务请求报文，源IP为Host IP、目的IP为VSIP

(2)LB Device接收到请求报文后，借助调度算法计算出应该将请求分发给哪台Server

(3)LB Device使用DNAT技术分发报文，源IP为Host IP、目的IP为Server IP

(4)Server接收并处理请求报文，返回响应报文，源IP为Server IP、目的IP为Host IP

(5)LB Device接收响应报文，转换源IP后转发，源IP为VSIP、目的IP为Host IP

**2.七层服务器负载均衡技术**

七层负载均衡和四层负载均衡相比，只是进行负载均衡的依据不同，而选择确定的实服务器后，所做的处理基本相同，下面以HTTP应用的负载均衡为例来说明。

由于在TCP握手阶段，无法获得HTTP真正的请求内容，因此也就无法将客户的TCP握手报文直接转发给服务器， 必须由负载均衡设备先和客户完成TCP握手，等收到足够的七层内容后，再选择服务器，由负载均衡设备和所选服务器建立TCP连接。

七层负载均衡组网和四层负载均衡组网有一个显著的区别：四层负载均衡每个虚服务对应一个实服务组，实服务组内的所有实服务器提供相同的服务;七层负载均衡每个虚服务对应多个实服务组，每组实服务器提供相同的服务。根据报文内容选择对应的实服务组，然后根据实服务组调度算法选择某一个实服务器。

![新一代负载均衡产品技术实现 图2][_2]

七层负载均衡组网图

上图中描述了基于HTTP的URI目录信息进行的七层负载均衡部署，报文交互流程图如下：

![新一代负载均衡产品技术实现 图3][_3]

七层负载均衡报文交互流程图报文交互流程说明：

(1)-(3)：Client和LB建立TCP连接;

(4)：Client发送HTTP请求，目的IP为虚IP;

(5)：LB设备分析报文，根据调度算法选择实服务器，注意此时会缓存该报文;

(6)：LB设备向实服务器发Syn报文，序列号为Client的Syn报文序列号

(7)：Server发送Syn/Ack报文，目的IP为Client;

(8)：LB接收Server的Syn/Ack报文后，回应ACK报文

(9)：修改步骤(5)中缓存的报文目的IP和TCP序列号，然后发给Server;

(10)：Server发送响应报文到LB;

(11)：LB修改步骤(9)中的报文的源地址和TCP序列号后转发给Client。

**二 链路负载均衡**

在企业网、运营商链路出口需要部署LB设备以优化链路选择，提升访问体验，链路负载均衡按照流量发起方向分为Inbound负载均衡和Outbound负载均衡

**1.Inbound入方向负载均衡**

Inbound负载均衡技术是DNS智能解析的一种，外网用户通过域名访问内部服务器时，Local DNS的地址解析请求到达LB设备，LB根据对Local DNS的就近性探测结果响应一个最优的IP地址，外网用户根据这个最优的IP响应进行对内部服务器的访问。

![新一代负载均衡产品技术实现 图4][_4]

Inbound链路负载均衡组网图

![新一代负载均衡产品技术实现 图5][_5]

入方向负载均衡

流程简述如下：

(1)外部用户进行资源访问前先进行DNS解析，向其本地DNS服务器发送DNS请求。

(2)本地DNS服务器将DNS请求的源IP地址替换为自己的IP地址，并转发给域名对应的权威服务器——LB device。

(3)LB device根据DNS请求的域名和配置的Inbound链路负载均衡规则进行域名解析。

(4)LB device按照域名解析的结果，将DNS应答发送给本地DNS服务器。

(5)本地DNS服务器将解析结果转发给用户。

(6)用户使用解析结果选择的链路，直接对LB device进行资源访问。

**2.Outbound出方向负载均衡**

内网用户访问Internet上其他服务器。 Outbound链路负载均衡中VSIP为内网用户发送报文的目的网段。用户将访问VSIP的报文发送到负载均衡设备后，负载均衡设备依次根据策略、持续性功能、就近性算法、调度算法选择最佳的链路，并将内网访问外网的业务流量分发到该链路。

![新一代负载均衡产品技术实现 图6][_6]

Outbound链路负载均衡组网图

Outbound负载均衡报文交互流程如下：

![新一代负载均衡产品技术实现 图7][_7]

Outbound 链路负载均衡流程图

Outbound负载均衡报文交互流程说明：

(1)LB Device接收内网用户流量 -

(2)LB Device依次根据策略、持续性功能、就近性算法、调度算法进行链路选择 在Outbound链路负载均衡组网中，通常使用就近性算法或带宽调度算法实现流量分发

(3)LB device按照链路选择的结果将流量转发给选定的链路 -

(4)LB Device接收外网用户流量 -

(5)LB Device将流量转发给内网用户

**三 负载均衡优化及应用**

**1.TCP连接复用**

连接复用功能通过使用连接池技术，可以将前端大量的客户的HTTP请求复用到后端与服务器建立的少量的TCP长连接上，大大减小服务器的性能负载，减小与服务器之间新建TCP连接所带来的延时，并最大限度减少后端服务器的并发连接数，降低服务器的资源占用。

![新一代负载均衡产品技术实现 图8][_8]

TCP连接复用示意图上图给出了TCP连接复用的简单过程描述。由Client端发送的Req1/ Req2/ Req3三个HTTP请求，经过LB设备后，复用了LB设备和Server端已经建立好的连接，将Client端的三个请求通过两个TCP连接发送给了服务器端。

**2.SSL卸载**

为了避免明文传输出现的安全问题，对于敏感信息，一般采用SSL协议，如HTTPS，对HTTP协议进行加密，以保证整个HTTP传输过程的安全性。SSL是需要耗费大量CPU资源的一种安全技术，如果由后端的服务器来承担，则会消耗很大的处理能力。应用交付设备为了提升用户的体验，分担服务器的处理压力，将SSL加解密集中在自身的处理上，相对于服务器来说LB能提供更高的SSL处理性能，还能够简化对证书的管理，减少日常管理的工作量，LB的该功能又称为SSL卸载。

下图中Client端发送给Server的所有的HTTPS流量都被LB设备终结，LB设备将SSL终结后，与Server之间可采用HTTP或者弱加密的HTTPS进行通讯。LB设备承担了SSL的卸载工作，从而极大的减小了服务器端对SSL处理的压力，将服务器的处理能力释放出来，更加专注于处理服务器本身承担的业务逻辑。

![新一代负载均衡产品技术实现 图9][_9]

SSL卸载示意图

SSL卸载的处理流程如下：

![新一代负载均衡产品技术实现 图10][_10]

SSL卸载过程

(1)客户端向服务器端发送SSL握手请求。

(2)LB设备作为中间的卸载设备，代替服务器端和客户端交互，完成SSL握手过程。

(3)客户端发送SSL加密后的请求数据。

(4)LB设备解密数据。

(5)LB设备将解密后的明文发送给Server。

(6)服务器返回给LB设备回应报文。

(7)LB设备将返回的应答报文加密。

(8)LB设备将加密后的应答报文传给客户端。

**3.DRX云环境应用交付**

业务负载监控平台通过H3C负载均衡设备的参数设定和监控可以动态感知业务负载变化，并通知云管理平台动态调整业务资源。由此实现用户业务资源的实时动态调整、业务资源优化调配。

当业务负载监控平台发现业务资源需要调整时：业务负载超限—增加资源;业务资源过剩——回收资源，云管理平台通过自动创建、启动或者删除停止虚拟机的方式为业务进行资源动态调整。

**四 结束语**

负载均衡技术不管应用于用户访问服务器资源，还是应用于多链路出口，均大大提高了对资源的高效利用，显著降低了用户的网络布署成本，提升了用户的网络使用体验。随着云计算的发展，负载均衡的技术实现还将与云计算相结合，在虚拟化和NFV软件定义网关等方面持续发展。

】

*  CDN

[https://www.zhihu.com/question/36514327?rf=37353035][https_www.zhihu.com_question_36514327_rf_37353035]

**部分问题只是列出思考的概要，去书中和实践中找到这些问题的答案才能真正的消化**

[https://blog.csdn.net/joeyon1985/article/details/38775971][https_blog.csdn.net_joeyon1985_article_details_38775971]

[extern]: https://www.cnblogs.com/Lunais/p/5991135.html
[https_www.jianshu.com_p_5d2eeeb93590]: https://www.jianshu.com/p/5d2eeeb93590
[static]: http://blog.csdn.net/shanghairuoxiao/article/details/72904292
[new_malloc]: http://blog.csdn.net/shanghairuoxiao/article/details/70337890
[C]: http://blog.csdn.net/hackbuteer1/article/details/7475622
[Link 1]: http://blog.csdn.net/u013630349/article/details/48009815
[Link 2]: http://blog.csdn.net/haoel/article/details/1948051/
[Link 3]: http://www.cnblogs.com/xiehongfeng100/p/4645555.html
[C 1]: http://www.jellythink.com/archives/205
[Link 4]: http://blog.csdn.net/thefutureisour/article/details/7964682/
[Link 5]: http://www.cnblogs.com/skynet/archive/2011/02/20/1959162.html
[Hash]: http://blog.csdn.net/shanghairuoxiao/article/details/73693458
[Link 6]: http://blog.csdn.net/shanghairuoxiao/article/details/73752446
[http_blog.csdn.net_xiajun07061225_article_details_12760493]: http://blog.csdn.net/xiajun07061225/article/details/12760493
[Trie]: http://blog.csdn.net/hackbuteer1/article/details/7964147
[Link 7]: https://www.cnblogs.com/yxzfscg/p/4782421.html
[81b78497tw1eesdi7bb2kj20d403qaa0.jpg]: /images/20220414/29cd625d27a54aeaa734bb448ff42c95.png
[2]: /images/20220414/5be70cc35f8a4ba9a2a46a6bcafbca51.png
[copycode.gif]: /images/20220414/aa4271c8c2fb4d88ae38f0867046ab8f.png
[Link 8]: http://blog.csdn.net/shanghairuoxiao/article/details/74063684
[Link 9]: http://blog.csdn.net/shanghairuoxiao/article/details/75386508
[TCP_UDP]: http://blog.csdn.net/shanghairuoxiao/article/details/68927070
[https_blog.csdn.net_shanghairuoxiao_article_details_68927070]: https://blog.csdn.net/shanghairuoxiao/article/details/68927070
[https_blog.csdn.net_ch1406285246_article_details_55504330]: https://blog.csdn.net/ch1406285246/article/details/55504330
[TCP]: http://blog.csdn.net/shanghairuoxiao/article/details/68927100
[TCP 1]: http://blog.csdn.net/shanghairuoxiao/article/details/69803044
[UDP]: http://blog.csdn.net/shanghairuoxiao/article/details/69951345
[ARP_RARP]: http://blog.csdn.net/shanghairuoxiao/article/details/68926923
[HTTP]: https://github.com/semlinker/awesome-http#bs-%E7%BB%93%E6%9E%84%E5%AE%9A%E4%B9%89
[http2.0]: http://www.cnblogs.com/frankyou/p/6145485.html
[Link 10]: http://blog.csdn.net/shanghairuoxiao/article/details/76888423
[https_blog.csdn.net_qq_37307063_article_details_70141679]: https://blog.csdn.net/qq_37307063/article/details/70141679
[http_www.runoob.com_w3cnote_mysql-index.html]: http://www.runoob.com/w3cnote/mysql-index.html
[https_www.cnblogs.com_zhaobingqing_p_7071331.html]: https://www.cnblogs.com/zhaobingqing/p/7071331.html
[https_www.2cto.com_database_201804_740181.html]: https://www.2cto.com/database/201804/740181.html
[https_www.cnblogs.com_y-rong_p_8110596.html]: https://www.cnblogs.com/y-rong/p/8110596.html
[http_www.cnblogs.com_malaikuangren_archive_2012_04_06_2434760.html]: http://www.cnblogs.com/malaikuangren/archive/2012/04/06/2434760.html
[https_blog.csdn.net_mfl0315_article_details_51981792]: https://blog.csdn.net/mfl0315/article/details/51981792
[https_www.cnblogs.com_suncan0_p_4767894.html]: https://www.cnblogs.com/suncan0/p/4767894.html
[https_blog.csdn.net_ywl470812087_article_details_78533020]: https://blog.csdn.net/ywl470812087/article/details/78533020
[https_blog.csdn.net_u012091092_article_details_53377607]: https://blog.csdn.net/u012091092/article/details/53377607
[https_blog.csdn.net_qq_33936481_article_details_73531671]: https://blog.csdn.net/qq_33936481/article/details/73531671
[https_blog.csdn.net_youthsunshine_article_details_53465847]: https://blog.csdn.net/youthsunshine/article/details/53465847
[https_blog.csdn.net_zwz2011303359_article_details_63262541]: https://blog.csdn.net/zwz2011303359/article/details/63262541
[sql]: https://edu.aliyun.com/jiaocheng/1043
[Link 11]: https://developer.aliyun.com/index
[Link 12]: https://yq.aliyun.com/wenji
[Link 13]: https://yq.aliyun.com/wenji/list
[https_www.cnblogs.com_codeAB_p_6387148.html]: https://www.cnblogs.com/codeAB/p/6387148.html
[https_www.cnblogs.com_sunny3096_p_8595058.html]: https://www.cnblogs.com/sunny3096/p/8595058.html
[https_blog.csdn.net_mingover_article_details_71108852]: https://blog.csdn.net/mingover/article/details/71108852
[Link 14]: http://blog.csdn.net/shanghairuoxiao/article/details/74012512
[https_blog.csdn.net_shanghairuoxiao_article_details_74012512]: https://blog.csdn.net/shanghairuoxiao/article/details/74012512
[Link 15]: http://www.cnblogs.com/CheeseZH/p/5264465.html
[Link 16]: http://blog.csdn.net/shanghairuoxiao/article/details/70256247
[Link 17]: https://github.com/oscarwin/MemoryPool
[https_blog.csdn.net_qq_38847853_article_details_80554515]: https://blog.csdn.net/qq_38847853/article/details/80554515
[Link 18]: http://blog.csdn.net/shanghairuoxiao/article/details/70444940
[LINUX]: https://www.cnblogs.com/sallyliu/p/6387302.html
[https_blog.csdn.net_GUI1259802368_article_details_80992815]: https://blog.csdn.net/GUI1259802368/article/details/80992815
[https_blog.csdn.net_bluehawksky_article_details_39804551]: https://blog.csdn.net/bluehawksky/article/details/39804551
[201308230906245.jpg]: http://files.jb51.net/file_images/article/201308/201308230906245.jpg
[201308230906246.jpg]: http://files.jb51.net/file_images/article/201308/201308230906246.jpg
[201308230906247.jpg]: http://files.jb51.net/file_images/article/201308/201308230906247.jpg
[cmd find]: https://www.cnblogs.com/liangxiaofeng/p/5028477.html
[http_hi.baidu.com_bs0_D0_A1_B3_C2_blog_item_3f9c39ee0d29c0cbd439c94a.html]: http://hi.baidu.com/bs0%D0%A1%B3%C2/blog/item/3f9c39ee0d29c0cbd439c94a.html
[https_blog.csdn.net_hi_kevin_article_details_8983746]: https://blog.csdn.net/hi_kevin/article/details/8983746
[https_www.jb51.net_article_101272.htm]: https://www.jb51.net/article/101272.htm
[https_blog.csdn.net_a987073381_article_details_52201200]: https://blog.csdn.net/a987073381/article/details/52201200
[http_blog.chinaunix.net_uid-28458801-id-4464639.html]: http://blog.chinaunix.net/uid-28458801-id-4464639.html
[select_poll_epoll]: https://segmentfault.com/a/1190000003063859
[Link 19]: https://www.ibm.com/developerworks/cn/linux/l-cn-edntwk/index.html?ca=drs-
[epoll]: http://www.jianshu.com/p/b5bc204da984
[https_blog.csdn.net_ywcpig_article_details_52557080]: https://blog.csdn.net/ywcpig/article/details/52557080
[https_blog.csdn.net_Al_xin_article_details_39258067]: https://blog.csdn.net/Al_xin/article/details/39258067
[https_blog.csdn.net_yfcheng_yzc_article_details_54291817]: https://blog.csdn.net/yfcheng_yzc/article/details/54291817
[https_blog.csdn.net_jianchi88_article_details_6985326]: https://blog.csdn.net/jianchi88/article/details/6985326
[https_blog.csdn.net_deyuzhi_article_details_52295452]: https://blog.csdn.net/deyuzhi/article/details/52295452
[https_blog.csdn.net_believe_s_article_details_77040494]: https://blog.csdn.net/believe_s/article/details/77040494
[Link 20]: http://www.jellythink.com/archives/82
[https_www.cnblogs.com_qiaoconglovelife_p_5851163.html]: https://www.cnblogs.com/qiaoconglovelife/p/5851163.html
[https_blog.csdn.net_cselmu9_article_details_51366946]: https://blog.csdn.net/cselmu9/article/details/51366946
[https_blog.csdn.net_Dawn_sf_article_details_77929225]: https://blog.csdn.net/Dawn_sf/article/details/77929225
[https_blog.csdn.net_hyman_yx_article_details_51982488]: https://blog.csdn.net/hyman_yx/article/details/51982488
[https_blog.csdn.net_zch501157081_article_details_51967549]: https://blog.csdn.net/zch501157081/article/details/51967549
[Image 1]: 
[map_reduce]: http://blog.jobbole.com/80619/
[_1]: /images/20220414/d8dac422964c4972bef978d9ac419574.png
[_2]: /images/20220414/91b90d5a2f2b4f958f4258a4c920d091.png
[_3]: /images/20220414/677c2b1e145b407787e86f85ba36c066.png
[_4]: /images/20220414/d5bab9229f9b40d882e9c6233ccd6e86.png
[_5]: /images/20220414/cc097f95198340298b5b13642ec0aa41.png
[_6]: /images/20220414/639dc5b4d9134b9c8c58709ccbf5de57.png
[_7]: /images/20220414/cead4263f51f4b269ee69085e6c6722a.png
[_8]: /images/20220414/0720f0ade30c43579fe6b4de0e3f80cd.png
[_9]: /images/20220414/19f661626265458db75b1deddd215d5d.png
[_10]: /images/20220414/16347fafd0d44a329cf28b4ca926ea1c.png
[https_www.zhihu.com_question_36514327_rf_37353035]: https://www.zhihu.com/question/36514327?rf=37353035
[https_blog.csdn.net_joeyon1985_article_details_38775971]: https://blog.csdn.net/joeyon1985/article/details/38775971