用工程的写法写一个String类，实现内存深拷贝，用char指针和内存分配。
内存深拷贝（Deep Copy）是指在进行对象拷贝时，不仅复制对象本身，还对对象所引用的动态分配的内存进行拷贝，使得拷贝后的对象和原对象完全独立，互不影响。
当一个对象包含指向动态分配内存的指针或引用时，进行浅拷贝（Shallow Copy）只是简单地复制指针或引用的值，指向相同的内存块。
在拷贝构造函数和赋值运算符重载中，同样进行了内存的深拷贝，避免了浅拷贝导致的潜在问题。在析构函数中，使用delete[]操作符释放了分配的内存空间。
#include<cstdio>
#include<cstring>
class String{
private:
char* data; //数组地址
int length; //长度
public:
//默认构造函数
String():data(NULL),length(0){}
//内存深拷贝构造函数1
String(const char* str){
length = strlen(str);
data = new char[length+1];
strcpy(data, str);
}
//内存深拷贝构造函数2
String(const String & others){
length = others.length;
data = new char[length+1];
strcpy(data, others.data);
}
//析构函数
~String(){
delete[] data;
}
//其他函数
int getLength() const {
return length;
}
const char* getData() const {
return data;
}
//内存深拷贝赋值
String& operator=(const String& other) {
delete[] data;
length = other.length;
data = new char[length+1];
strcpy(data, other.data);
return *this;
}
};
int main(){
String a("abcd");
String b("defghijk");
printf("%d\n%s\n", a.getLength(), a.getData());
printf("%d\n%s\n", b.getLength(), b.getData());
b = a;
printf("%d\n%s\n", b.getLength(), b.getData());
return 0;
}
一、基础知识
1、基本语言
2、容器和算法
3、类和数据抽象
4、面向对象与泛型编程
5、编译与底层
6、C++11
静态变量，全局，局部都可。
功能是存到 静态存储区，在整个程序运行期间一直存在，初始化自动赋值0。
作用域保持不变，静态变量在声明他的文件之外是不可见的。
静态函数
只可在本cpp 内使用，不会同其他cpp 中的同名函数引起冲突；
静态类成员：
在类中，静态成员可以实现多个对象之间的数据共享，并且使用静态数据成员还不会破坏隐藏的原则，即保证了安全性。
因此，静态成员是类的所有对象中共享的成员，而不是某个对象的成员。对多个对象来说，静态数据成员只存储一处，供所有对象共用
静态成员函数
和静态数据成员一样，它们都属于类的静态成员，它们都不是对象成员。因此，对静态成员的引用不需要用对象名。
在静态成员函数的实现中不能直接引用类中说明的非静态成员，可以引用类中说明的静态成员（这点非常重要）。
如果静态成员函数中要引用非静态成员时，可通过对象来引用。从中可看出，调用静态成员函数使用如下格式：<类名>::<静态成员函数名>(<参数表>);
1、const_cast
用于将const 变量转为非const
2、static_cast
用于各种隐式转换，比如非const 转const，void*转指针等, static_cast 能用于多态向上转化，如果向下转能成功但是不安全，结果未知；
3、dynamic_cast
用于动态类型转换。只能用于含有虚函数的类，用于类层次间的向上和向下转化。只能转指针或引用。向下转化时，如果是非法的对于指针返回NULL，对于引用抛异常。要深入了解内部转换的原理。
向上转换：指的是子类向基类的转换
向下转换：指的是基类向子类的转换
它通过判断在执行到该语句的时候变量的运行时类型和要转换的类型是否相同来判断是否能够进行向下转换。
4、reinterpret_cast
几乎什么都可以转，比如将int 转指针，可能会出问题，尽量少用；
5、为什么不使用C 的强制转换？
C 的强制转换表面上看起来功能强大什么都能转，但是转化不够明确，不能进行错误检查，容易出错。
C++里面的四个智能指针: auto_ptr, shared_ptr, weak_ptr, unique_ptr
其中后三个是c++11 支持，并且第一个已经被11 弃用。
智能指针的作用是管理一个指针，因为存在以下这种情况：
申请的空间在函数结束时忘记释放，造成内存泄漏。
使用智能指针可以很大程度上的避免这个问题，因为智能指针就是一个类，当超出了类的作用域是，类会自动调用析构函数，析构函数会自动释放资源。
所以智能指针的作用原理就是在函数结束时自动释放内存空间，不需要手动释放内存空间。
智能指针主要用于管理在堆上分配的内存，它将普通的指针封装为一个栈对象。当栈对象的生存周期结束后，会在析构函数中释放掉申请的内存，从而防止内存泄漏。
C++ 11 中最常用的智能指针类型为shared_ptr,它采用引用计数的方法，记录当前内存资源被多少个智能指针引用。该引用计数的内存在堆上分配。当新增一个时引用计数加1，当过期时引用计数减一。只有引用计数为0 时，智能指针才会自动释放引用的内存资源。
对shared_ptr 进行初始化时不能将一个普通指针直接赋值给智能指针，因为一个是指针，一个是类。可以通过make_shared 函数或者通过构造函数传入普通指针。并可以通过get 函数获得普通指针。
Fork：创建一个和当前进程映像一样的进程可以通过fork( )系统调用：
#include <sys/types.h>
#include <unistd.h>
pid_t fork(void);
成功调用fork( )会创建一个新的进程，它几乎与调用fork( )的进程一模一样，这两个进程都会继续运行。在子进程中，成功的fork( )调用会返回0。 在父进程中fork( )返回子进程的pid。如果出现错误，fork( )返回一个负值。
最常见的fork( )用法是创建一个新的进程，然后使用exec( )载入二进制映像，替换当前进程的映像。这种情况下，派生（fork）了新的进程，而这个子进程会执行一个新的二进制可执行文件的映像。这种“派生加执行”的方式是很常见的。
析构函数与构造函数对应，当对象结束其生命周期，如对象所在的函数已调用完毕时，系统会自动执行析构函数。
析构函数名也应与类名相同，只是在函数名前面加一个位取反符 ~，例如~stud( )，以区别于构造函数。它不能带任何参数，也没有返回值（包括void 类型）。只能有一个析构函数，不能重载。
如果用户没有编写析构函数，编译系统会自动生成一个缺省的析构函数（即使自定义了析构函数，编译器也总是会为我们合成一个析构函数，并且如果自定义了析构函数，编译器在执行时
会先调用自定义的析构函数再调用合成的析构函数），它也不进行任何操作。所以许多简单的类
中没有用显式的析构函数。
如果一个类中有指针，且在使用的过程中动态的申请了内存，那么最好显示构造析构函数在
销毁类之前，释放掉申请的内存空间，避免内存泄漏。
类析构顺序：
1）派生类本身的析构函数；2）对象成员析构函数；3）基类析构函数。
__attribute((constructor))void before()
{
printf("before main\n");
}
const char * arr = "123";
//字符串123 保存在常量区，const 本来是修饰arr 指向的值不能通过arr 去修改，但是字符串
“123”在常量区，本来就不能改变，所以加不加const 效果都一样
char * brr = "123";
//字符串123 保存在常量区，这个arr 指针指向的是同一个位置，同样不能通过brr 去修改"123"
的值
const char crr[] = "123";
//这里123 本来是在栈上的，但是编译器可能会做某些优化，将其放到常量区
char drr[] = "123";
//字符串123 保存在栈区，可以通过drr 去修改
const 修饰的成员函数表明函数调用不会对对象做出任何更改，事实上，如果确认不会对对象做更改，就应该为函数加上const 限定，这样无论const 对象还是普通对象都可以调用该函数。
不会，这相当于函数的重载。
不能。如果是这种情况下，调用拷贝构造函数的时候，首先要将实参传递给形参，这个传递的时
候又要调用拷贝构造函数。。如此循环，无法完成拷贝，栈也会满。
静态函数在编译的时候就已经确定运行时机，虚函数在运行的时候动态绑定。虚函数因为用了虚
函数表机制，调用的时候会增加一次内存开销
在C++中，可以用struct 和class 定义类，都可以继承。
区别在于：
structural 的默认继承权限和默认访问权限是public，
而class 的默认继承权限和默认访问权限是private。
另外，class 还可以定义模板类形参，比如template <class T, int i>。
对于C++源文件，从文本到可执行文件一般需要四个过程：
预处理阶段：对源代码文件中文件包含关系（头文件）、预编译语句（宏定义）进行分析和
替换，生成预编译文件。
编译阶段：将经过预处理后的预编译文件转换成特定汇编代码，生成汇编文件
汇编阶段：将编译阶段生成的汇编文件转化成机器码，生成可重定位目标文件
链接阶段：将多个目标文件及所需要的库连接成最终的可执行目标文件
在C++中，虚拟内存分为代码段、数据段、BSS 段、堆区、文件映射区以及栈区六部分。
代码段: 包括只读存储区和文本区，其中只读存储区存储字符串常量，文本区存储程序的机器代码。
数据段：存储程序中已初始化的全局变量和静态变量
bss 段：存储未初始化的全局变量和静态变量（局部+全局），以及所有被初始化为0 的全局变量和静态变量。
堆区： 调用new/malloc 函数时在堆区动态分配内存，同时需要调用delete/free 来手动释放申请的内存。
映射区:存储动态链接库以及调用mmap 函数进行的文件映
段错误通常发生在访问非法内存地址的时候，具体来说分为以下几种情况：
auto 关键字：编译器可以根据初始值自动推导出类型。但是不能用于函数传参以及数组类型的推导
nullptr 关键字：nullptr 是一种特殊类型的字面值，它可以被转换成任意其它的指针类型；而NULL 一般被宏定义为0，在遇到重载时可能会出现问题。
智能指针：C++11 新增了std::shared_ptr、std::weak_ptr 等类型的智能指针，用于解决内存管理的问题。
初始化列表：使用初始化列表来对类进行初始化
右值引用：基于右值引用可以实现移动语义和完美转发，消除两个对象交互时不必要的对象拷贝，节省运算存储资源，提高效率
atomic 原子操作用于多线程资源互斥操作
新增STL 容器array 以及tuple
STL 容器
2.1、std::array
2.2、std::forward_list
2.3、std::unordered_map
2.4、std::unordered_set
C++11 的可变参数模板，对参数进行了高度泛化，可以表示任意数目、任意类型的参数，其
语法为：在class 或typename 后面带上省略号”。
Template<class ... T>
void func(T ... args)
{
cout<<”num is”<<sizeof ...(args)<<endl;
}
func();//args 不含任何参数
func(1);//args 包含一个int 类型的实参
func(1,2.0)//args 包含一个int 一个double 类型的实参
其中T 叫做模板参数包，args 叫做函数参数包
省略号作用如下：
1）声明一个包含0 到任意个模板参数的参数包
2）在模板定义得右边，可以将参数包展成一个个独立的参数
C++11 可以使用递归函数的方式展开参数包，获得可变参数的每个值。通过递归函数展开参
数包，需要提供一个参数包展开的函数和一个递归终止函数。例如：
操作系统主要就是考内存管理和进程管理，其他不怎么考。
熟悉多线程编程技术，对异步、并发技术有深入理解。有大规模高并发系开发和设计经验者优先；
进程是对运行时程序的封装，是系统进行资源调度和分配的的基本单位，实现了操作系统的
并发；
线程是进程的子任务，是CPU 调度和分派的基本单位， 用于保证程序的实时性，实现进程内部的并发；
线程是操作系统可识别的最小执行和调度单位。每个线程都独自占用一个虚拟处理器：独自的寄存器组，指令计数器和处理器状态。 每个线程完成不同的任务，但是共享同一地址空间（也就是同样的动态内存，映射文件，目标代码等等），打开的文件队列和其他内核资源。
2.进程在执行过程中拥有独立的内存单元，而多个线程共享进程的内存
3.进程是资源分配的最小单位，线程是CPU 调度的最小单位；
进程编程调试简单可靠性高，但是创建销毁开销大；
线程正相反，开销小，切换速度快，但是编程调试相对复杂。
进程间通信主要包括管道、系统IPC（包括消息队列、信号量、信号、共享内存等）、以及套接字socket。
1、管道主要包括无名管道和命名管道:
管道可用于具有亲缘关系的父子进程间的通信，有名管道除了具有管道所具有的功能外，它还允许无亲缘关系进程间的通信
2、消息队列
消息队列，是消息的链接表，存放在内核中。一个消息队列由一个标识符（即队列ID）来标记。(消息队列克服了信号传递信息少，管道只能承载无格式字节流以及缓冲区大小受限等特点)
具有写权限得进程可以按照一定得规则向消息队列中添加新信息；对消息队列有读权限得进程则可以从消息队列中读取信息
1)消息队列是面向记录的，其中的消息具有特定的格式以及特定的优先级。
2)消息队列独立于发送与接收进程。进程终止时，消息队列及其内容并不会被删除。
3)消息队列可以实**现消息的随机查询,**消息不一定要以先进先出的次序读取,也可以按消息的类型读取。
2.2 信号量semaphore
信号量（semaphore）与已经介绍过的IPC 结构不同，它是一个计数器，可以用来控制多个进程对共享资源的访问。信号量用于实现进程间的互斥与同步，而不是用于存储进程间通信数据。
1)信号量用于进程间同步，若要在进程间传递数据需要结合共享内存。
2)信号量基于操作系统的PV 操作，程序对信号量的操作都是原子操作。
3)每次对**信号量的PV 操作不仅限于对信号量值加1 或减1，**而且可以加减任意正整数。
4)支持信号量组。
共享内存（Shared Memory）
它使得多个进程可以访问同一块内存空间，不同进程可以及时看到对方进程中对共享内存中数据得更新。这种方式需要依靠某种同步操作，如互斥锁和信号量等
1)共享内存是最快的一种IPC，因为进程是直接对内存进行存取
2)因为多个进程可以同时操作，所以需要进行同步
3)信号量+共享内存通常结合在一起使用，信号量用来同步对共享内存的访问
套接字SOCKET：
socket 也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同主机之间的进程通信。
线程间通信的方式:
虚拟内存的优点：
1.扩大地址空间；
2.内存保护：每个进程运行在各自的虚拟内存地址空间，互相不能干扰对方。虚存还对特定
的内存地址提供写保护，可以防止代码或数据被恶意篡改。
3.公平内存分配。采用了虚存之后，每个进程都相当于有同样大小的虚存空间。
4.当进程通信时，可采用虚存共享的方式实现。
5.当不同的进程使用同样的代码时，比如库文件中的代码，物理内存中可以只存储一份这样
的代码，不同的进程只需要把自己的虚拟内存映射过去就可以了，节省内存
6.虚拟内存很适合在多道程序设计系统中使用，许多程序的片段同时保存在内存中。当一个
程序等待它的一部分读入内存时，可以把CPU 交给另一个进程使用。在内存中可以保留多个进程，
系统并发度提高
虚拟内存的代价：
1.虚存的管理需要建立很多数据结构，这些数据结构要占用额外的内存
2.虚拟地址到物理地址的转换，增加了指令的执行时间。
3.页面的换入换出需要磁盘I/O，这是很耗时的
4.如果一页中只有一部分数据，会浪费内存
一个程序本质上都是由BSS 段、data 段、text 段三个组成的。
可以看到一个可执行程序在存储（没有调入内存）时分为代码段、数据区和未初始化数据区三部分。
malloc()和mmap()等内存分配函数，在分配时只是建立了进程虚拟地址空间，并没有分配虚拟内存对应的物理内存。当进程访问这些没有建立映射关系的虚拟内存时，处理器自动触发一个缺页异常。
缺页中断：
**在请求分页系统中，可以通过查询页表中的状态位来确定所要访问的页面是否存在于内存中。**每当所要访问的页面不在内存是，会产生一次缺页中断，此时操作系统会根据页表中的外存地址在外存中找到所缺的一页，将其调入内存。缺页本身是一种中断，与一般的中断一样，需要经过4 个处理步骤：
1、保护CPU 现场
2、分析中断原因
3、转入缺页中断处理程序进行处理
4、恢复CPU 现场，继续执行
但是缺页中断是由于所要访问的页面不存在于内存时，由硬件所产生的一种特殊的中断，因
此，与一般的中断存在区别：
1、在指令执行期间产生和处理缺页中断信号
2、一条指令在执行期间，可能产生多次缺页中断
3、缺页中断返回是，执行产生中断的一条指令，而一般的中断返回是，执行下一条指令。
页式内存管理，内存分成固定长度的一个个页片。
进程可以使多个程序能并发执行，以提高资源的利用率和系统的吞吐量；但是其具有一些缺点：
因此，操作系统引入了比进程粒度更小的线程，作为并发执行的基本单位，从而减少程序在并发执行时所付出的时空开销，提高并发性。和进程相比，线程的优势如下：
从资源上来讲，线程是一种非常"节俭"的多任务操作方式。在linux 系统下，启动一个新的进程必须分配给它独立的地址空间，建立众多的数据表来维护它的代码段、堆栈段和数据段，这是一种"昂贵"的多任务工作方式。
从切换效率上来讲，运行于一个进程中的多个线程，它们之间使用相同的地址空间，而且线程间彼此切换所需时间也远远小于进程间切换所需要的时间。据统计，一个进程的开销大约是一个线程开销的30 倍左右
使多CPU 系统更加有效。操作系统会保证当线程数不大于CPU 数目时，不同的线程运行于不同的CPU 上。
信号量
信号量是一种特殊的变量，可用于线程同步。它只取自然数值，并且只支持两种操作：
P(SV):如果信号量SV 大于0，将它减一；如果SV 值为0，则挂起该线程。
V(SV)：如果有其他进程因为等待SV 而挂起，则唤醒，然后将SV+1；否则直接将SV+1。
其系统调用为：
sem_wait（sem_t *sem）：以原子操作的方式将信号量减1，如果信号量值为0，则sem_wait将被阻塞，直到这个信号量具有非0 值。
sem_post（sem_t *sem)：以原子操作将信号量值+1。当信号量大于0 时，其他正在调用
sem_wait 等待信号量的线程将被唤醒。
互斥量
互斥量又称互斥锁，主要用于线程互斥，不能保证按序访问，可以和条件锁一起实现同步。当进入临界区时，需要获得互斥锁并且加锁；当离开临界区时，需要对互斥锁解锁，以唤醒其他等待该互斥锁的线程。其主要的系统调用如下：
pthread_mutex_init:初始化互斥锁
pthread_mutex_destroy：销毁互斥锁
pthread_mutex_lock：以原子操作的方式给一个互斥锁加锁，如果目标互斥锁已经被上锁，
pthread_mutex_lock 调用将阻塞，直到该互斥锁的占有者将其解锁。
pthread_mutex_unlock:以一个原子操作的方式给一个互斥锁解锁。
进程是资源分配的最小单位，而线程时CPU 调度的最小单位。
死锁是指两个或两个以上进程在执行过程中，因争夺资源而造成的下相互等待的现象。死锁发生的四个必要条件如下：
互斥条件：进程对所分配到的资源不允许其他进程访问，若其他进程访问该资源，只能等待，直至占有该资源的进程使用完成后释放该资源；
请求和保持条件：进程获得一定的资源后，又对其他资源发出请求，但是该资源可能被其他进程占有，此时请求阻塞，但该进程不会释放自己已经占有的资源
不可剥夺条件：进程已获得的资源，在未完成使用之前，不可被剥夺，只能在使用后自己释放
环路等待条件：进程发生死锁后，必然存在一个进程-资源之间的环形链
解决死锁的方法即破坏上述四个条件之一，主要方法如下：
资源一次性分配，从而剥夺请求和保持条件
可剥夺资源：即当进程新的资源未得到满足时，释放已占有的资源，从而破坏不可剥夺的条件
资源有序分配法：系统给每类资源赋予一个序号，每个进程按编号递增的请求资源，释放则相反，从而破坏环路等待的条件
比较常见的内存替换算法有：FIFO，LRU，LFU，LRU-K，2Q。
1、FIFO（先进先出淘汰算法）
思想：最近刚访问的，将来访问的可能性比较大。
实现：使用一个队列，新加入的页面放入队尾，每次淘汰队首的页面，即最先进入的数据，最先被淘汰。
弊端：无法体现页面冷热信息
2、LFU（最不经常访问淘汰算法）
思想：如果数据过去被访问多次，那么将来被访问的频率也更高。
实现：每个数据块一个引用计数，所有数据块按照引用计数排序，具有相同引用计数的数据块则按照时间排序。每次淘汰队尾数据块。
开销：排序开销。
3、LRU（最近最少使用替换算法）
思想：如果数据最近被访问过，那么将来被访问的几率也更高。
实现：使用一个栈，新页面或者命中的页面则将该页面移动到栈底，每次替换栈顶的缓存页面。优点：LRU 算法对热点数据命中率是很高的。
缺陷：
1）缓存颠簸，当缓存（1，2，3）满了，之后数据访问（0，3，2，1，0，3，2，1。。。）。
2）缓存污染，突然大量偶发性的数据访问，会让内存中存放大量冷数据。
1、临界区：
通过多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问；
2、互斥量Synchronized/Lock：
采用互斥对象机制，只有拥有互斥对象的线程才有访问公共资源的权限。因为互斥对象只有一个，所以可以保证公共资源不会被多个线程同时访问
3、信号量Semphare：
为控制具有有限数量的用户资源而设计的，它允许多个线程在同一时刻去访问同一个资源，但一般需要限制同一时刻访问此资源的最大线程数目。
4、事件(信号)，Wait/Notify：
通过通知操作的方式来保持多线程同步，还可以方便的实现多线程优先级的比较操作
大端是指低字节存储在高地址；
小端存储是指低字节存储在低地址。
我们可以根据联合体来判断该系统是大端还是小端。
因为联合体变量总是从低地址存储。
多线程，线程池，io 复用
使用ps 命令查看
单核cpu，并且开了抢占可以造成这种情况。
1.互斥条件：一个资源每次只能被一个进程使用。
2.请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
3.不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。
4.循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系
1）正常进程
正常情况下，子进程是通过父进程创建的，子进程再创建新的进程。子进程的结束和父进程的运行是一个异步过程，即父进程永远无法预测子进程到底什么时候结束。当一个进程完成它的工作终止之后，它的父进程需要调用wait()或者waitpid()系统调用取得子进程的终止状态。
unix 提供了一种机制可以保证只要父进程想知道子进程结束时的状态信息， 就可以得到：在每个进程退出的时候，内核释放该进程所有的资源，包括打开的文件，占用的内存等。但是仍然为其保一定的信息，直到父进程通过wait / waitpid 来取时才释放。保存信息包括：
1 进程号the process ID
2 退出状态the termination status of the process
3 运行时间the amount of CPU time taken by the process 等
2）孤儿进程
一个父进程退出，而它的一个或多个子进程还在运行，那么那些子进程将成为孤儿进程。孤儿进程将被init 进程(进程号为1)所收养，并由init 进程对它们完成状态收集工作。
3）僵尸进程
一个进程使用fork 创建子进程，如果子进程退出，而父进程并没有调用wait 或waitpid 获取子进程的状态信息，**那么子进程的进程描述符仍然保存在系统中。**这种进程称之为僵尸进程。
僵尸进程是一个进程必然会经过的过程：这是每个子进程在结束时都要经过的阶段。
如果进程不调用wait / waitpid 的话， 那么保留的那段信息就不会释放，其进程号就会一直被占用，但是系统所能使用的进程号是有限的，如果大量的产生僵死进程，将因为没有可用的进程号而导致系统不能产生新的进程。
解决方法：fork 两次，原理是将子进程成为孤儿进程，从而其的父进程变为init 进程
解决方法：kill掉
1.阻塞IO:调用者调用了某个函数，等待这个函数返回，期间什么也不做，不停的去检查这个函数有没有返回，必须等这个函数返回才能进行下一步动作
2.非阻塞IO:非阻塞等待，每隔一段时间就去检测IO 事件是否就绪。没有就绪就可以做其他事。
3.信号驱动IO:信号驱动IO:linux 用套接口进行信号驱动IO，安装一个信号处理函数，进程继续运行并不阻塞，当IO 时间就绪，进程收到SIGIO 信号。然后处理IO 事件。
4.IO 复用/多路转接IO:linux 用select/poll 函数实现IO 复用模型，这两个函数也会使进程阻塞，但是和阻塞IO 所不同的是这两个函数可以同时阻塞多个IO 操作。而且可以同时对多个读操作、写操作的IO 函数进行检测。知道有数据可读或可写时，才真正调用IO 操作函数
5.异步IO:linux 中，可以调用aio_read 函数告诉内核描述字缓冲区指针和缓冲区的大小、文件偏移及通知的方式，然后立即返回，当内核将数据拷贝到缓冲区后，再通知应用程序。
为了安全性。
在cpu 的一些指令中，有的指令如果用错，将会导致整个系统崩溃。分了内核态和用户态后，当用户需要操作这些指令时候，内核为其提供了API，可以通过系统调用陷入内核，让内核去执行这些操作。
这个需要看服务端的编程模型，如果如上一个问题的回答描述的这样，则处于阻塞状态，如果使用了epoll,select 等这样的io 复用情况下，处于运行状态
1.设置一个生产者消费者队列，作为临界资源
2.初始化n 个线程，并让其运行起来，加锁去队列取任务运行
3.当任务队列为空的时候，所有线程阻塞
4.当生产者队列来了一个任务后，先对队列加锁，把任务挂在到队列上，然后使用条件变量去通知阻塞中的一个线程
参考资料：牛客校招面试题库
熟练掌握C/C++语言，熟悉面向对象、设计模式，熟悉LINUX开发环境。
C++的实现有两种，一种通过局部静态变量，利用其只初始化一次的特点，返回对象。
另外一种，则是定义全局的指针，getInstance 判断该指针是否为空，为空时才实例化对象
在单例模式的实现中，如果不采取任何措施，在多线程下是不安全的，可能会同时创建多个实例。
观察者模式：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依
赖于它的对象都得到通知并被自动更新。
工厂模式：工厂模式主要解决接口选择的问题。该模式下定义一个创建对象的接口，让其子
类自己决定实例化哪一个工厂类，使其创建过程延迟到子类进行。
解耦，代码复用，更改功能容易。
装饰器模式：
对已经存在的某些类进行装饰，以此来扩展一些功能，从而动态的为一个对象增加新的功能。
装饰器模式是一种用于代替继承的技术，无需通过继承增加子类就能扩展对象的新功能。使用对象的关联关系代替继承关系，更加灵活，同时避免类型体系的快速膨胀。
1、单一职责原则
2、接口隔离原则
3、开放-封闭原则
4、替换原则
5、依赖倒置原则
分布式系统设计与开发、负载均衡技术，系统容灾设计，高可用系统等知识； 对云原生相关技术有所有了解。
轮询(Round Robin)
请求到达后，将客户端发送到负载均衡器的请求依次轮流地转发给服务集群的某个节点。
随机(Random)
随机选取集群中的某个节点来处理该请求，由概率论的知识可知，随着请求量的变大，随机算法会逐渐演变为轮询算法，即集群各个节点会处理差不多数量的请求。
加权
加权算法主要是根据集群的节点对应机器的性能的差异，给每个节点设置一个权重值，其中性能好的机器节点设置一个较大的权重值，而性能差的机器节点则设置一个较小的权重值。权重大的节点能够被更多的选中。它是和随机、轮训一起使用的。
最小连接数
主要是根据集群的每个节点的当前连接数来决定将请求转发给哪个节点，即每次都将请求转发给当前存在最少并发连接的节点。
hash
将对请求的IP地址或者URL计算一个哈希值，然后与集群节点的数量进行取模来决定将请求分发给哪个集群节点。它不是真正意义上的负载均衡，在某些意义上也是一个单点服务。
负载均衡分类
分布式锁
分布式事务
分布式锁和分布式事务区别：
集群
将多台服务器组成集群，使用负载均衡将请求转发到集群中，避免单一服务器的负载压力过大导致性能降低。
缓存
缓存能够提高性能的原因如下：
缓存数据通常位于内存等介质中，这种介质对于读操作特别快；
缓存数据可以位于靠近用户的地理位置上；
可以将计算结果进行缓存，从而避免重复计算。
异步
某些流程可以将操作转换为消息，将消息发送到消息队列之后立即返回，之后这个操作会被异步处理。
冗余
保证高可用的主要手段是使用冗余，当某个服务器故障时就请求其它服务器。
应用服务器的冗余比较容易实现，只要保证应用服务器不具有状态，那么某个应用服务器故障时，负载均衡器将该应用服务器原先的用户请求转发到另一个应用服务器上，不会对用户有任何影响。
存储服务器的冗余需要使用主从复制来实现，当主服务器故障时，需要提升从服务器为主服务器， 这个过程称为切换。
监控
对 CPU、内存、磁盘、网络等系统负载信息进行监控，当某个信息达到一定阈值时通知运维人员，从而在系统发生故障之前及时发现问题。
服务降级
服务降级是系统为了应对大量的请求，主动关闭部分功能，从而保证核心功能可用。
session cookie 区别 什么时候都要使用
（cookie不是很安全，别人可以分析存放在本地的cookie并进行cookie欺骗，考虑到安全应当使用session。session会在一定时间内保存在服务器上。 当访问增多，会比较占用你服务器的性能，考虑到减轻服务器性能方面，应当使用cookie。）
泛洪攻击
一种拒绝服务(DDoS) 攻击，旨在耗尽可用服务器资源，致使服务器无法传输合法流量。通过重复发送初始连接请求(SYN) 数据包，攻击者将可击垮目标服务器计算机上的所有可用端口，导致目标设备在响应合法流量时表现迟钝乃至全无响应。
sql注入
SQL注入式攻击，把SQL命令插入到Web表单的输入域或页面请求的查询字符串，欺骗服务器执行恶意的
xss 跨站脚本攻击，
利用XSS利用的是用户对网站的信任，指攻击者在网页中嵌入客户端脚本(例如JavaScript), 当用户浏览此网页时，脚本就会在用户的浏览器上执行，从而达到攻击者的目的. 比如获取用户的Cookie，导航到恶意网站,携带木马
crsf, 跨站请求伪造，
CSRF利用的是网站对用户网页浏览器的信任，欺骗用户的浏览器去访问一个自己曾经认证过的网站并运行一些操作（如发邮件，发消息，甚至财产操作如转账和购买商品）。由于浏览器曾经认证过，所以被访问的网站会认为是真正的用户操作而去运行。