别人面试的题，借鉴

1、设计模式

数据库面试题

1.1创建型模式：

工厂方法模式，抽象工厂模式，单例模式（一个类只有一个实例），建造者模式，原型模式，

线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机，但只能有一个Printer Spooler，以避免两个打印作业同时输出到打印机中。

1.2结构型模式

适配器模式，装饰器模式，桥接模式，代理模式

1.3行为型模式

策略模式，模版模式，备忘录模式，命令模式，解释器模式，中介者模式

2、六大原则

开闭原则 ：支持扩展增量不支持修改
1、单一职责原则：一个类只完成单一职责，

2、里氏替换原则，能使用基类的地方就能用子类
3、依赖倒转原则：面向接口编程，
4、接口隔离原则：每个接口不存在子类用不到却必须实现的方法，
5、知道最少原则：一个类对自己依赖的类知道的越少越好，依赖类的封装，减少依赖类改变而造成的影响
6、合成复用原则：少用继承

1、单例模式中怎么防止别的线程new单例对象？
恶汉式不需要，
懒汉式加锁：每次去获取对象，如果没有实例化对象则加锁创建，如果已经实例化了，则不需要加锁，直接获取实例
2、stl中栈使用什么设计模式?
适配器模式
3、map底层实现，map和avl相比的优点？
平衡检索二叉树，即红黑树。红黑树与一般的平衡二叉树相比，红黑树基本上是平衡的，而AVL树是完全平衡的。而为什么map和set的底层使用红黑树呢？那是因为红黑树是平衡二叉树，其插入和删除的效率都是logn，与AVL树相比，红黑树的插入和删除最多只需要3次旋转，而AVL树为了维持其完全平衡性，在最坏的情况下要旋转的次数太多。
4、虚函数实现，构造函数和析构函数能否定义为虚函数，析构函数里能否调用虚函数？
虚函数表，
构造函数不能为虚函数，而析构函数可以且常常是虚函数。
首先，分配一块内存；其次，调用构造函数。好，问题来了，如果构造函数是虚函数，那么就需要通过vtable 来调用，但此时面对一块 raw memeory，到哪里去找 vtable 呢？毕竟，vtable 是在构造函数中才初始化的啊，而不是在其之前。因此构造函数不能为虚函数。

不要在析构函数中调用虚函数的原因：析构函数是用来销毁一个对象的，在销毁一个对象时，先调用子类的析构函数，然后再调用基类的析构函数。 所以在调用基类的析构函数时，派生类对象的数据成员已经“销毁”，这个时再调用子类的虚函数已经没有意义了。

析构函数常常是虚函数：为了多态的时候父类指针调用子类方法时候，能够释放子类独有的成员。

5、数据库 acid，宕机恢复

6、tcp头部，校验码怎么计算？

7、B树，B+树
红黑树，平衡二叉树，几乎平衡。map,set红黑树是一种近似于平衡的二叉搜索树，里面的数据是有序的
ALV完全平衡二叉树，
数据库相关：
B树，平衡多叉树
B+树，平衡多叉树，数据只存在叶子节点，
8、内存管理
链接

2、第二个

1、const的作用
const是C语言的一种关键字，它所限定的变量是不允许被改变的，从而起到保护的作用！ const关键字可以用于修饰变量，参数，返回值,甚至函数体。 const可以提高程序的健壮性，减少程序出错
2、define
预处理，展开，宏定义
两个##的时候可以定义字符串连接
3、C++11新特性
for语句
auto类型推断
匿名函数 Lambda
后置返回类型（tailng-return-type）
显示重写(覆盖)override和final
空指针常量 nullptr
long long int类型
模板的别名
允许sizeof运算符可以再类型数据成员上使用，无需明确对象。
struct p {otherClass member;};
sizeof(p::member);
线程支持
参考

4、智能指针
5、stl中vector和list的区别？
STL中的vector特点是： 其容量在需要时可以自动分配，本质上是数组形式的存储方式。即在索引可以在常数时间内完成。缺点是在插入或者删除一项时，需要线性时间。但是在尾部插入或者删除，是常数时间的。

STL的 list 是双向链表：如果知道位置，在其中进行插入和删除操作时，是常数时间的。索引则需要线性时间（和单链表一样）。

6、stl中的hash表
STL中，map 对应的数据结构是 红黑树。红黑树是一种近似于平衡的二叉查找树，里面的数据是有序的。在红黑树上做查找操作的时间复杂度为 O(logN)。而 unordered_map 对应 哈希表，哈希表的特点就是查找效率高，时间复杂度为常数级别 O(1)， 而额外空间复杂度则要高出许多。所以对于需要高效率查询的情况，使用 unordered_map 容器。而如果对内存大小比较敏感或者数据存储要求有序的话，则可以用 map 容器。

7、epoll的了解，与select的区别？
select轮询时间复杂度：（N)
epoll事件驱动，时间复杂度O(1)

链接
8、从浏览器输入url到返回3开头的http码，中间发生了什么？

DNS解析

TCP连接

发送HTTP请求

服务器处理请求并返回HTTP报文

浏览器解析渲染页面

连接结束
链接

9、http与https的区别
加密的详细内容就需要SSL。
http是超文本传输协议，信息是明文传输，https则是具有安全性的ssl加密传输协议。
http和https使用的是完全不同的连接方式，用的端口也不一样，前者是80，后者是443。

3、第3个

1、什么是野指针，悬空指针？
野指针(wild pointer)就是没有被初始化过的指针。
悬空指针是指针最初指向的内存已经被释放了的一种指针。
2、struct与union的区别？
结构体struct：不同之处，stuct里每个成员都有自己独立的地址。sizeof(struct)是内存对齐后所有成员长度的加和。

共同体union： 当共同体中存入新的数据后，原有的成员就失去了作用，新的数据被写到union的地址中。sizeof(union)是最长的数据成员的长度。
只能存放一个数据。会覆盖。
3、什么是内存对齐？

4

1、new和malloc区别
1、关键字，编译器支持，库函数，头文件
2、delete 数组[], free
3、构造析构函数， malloc没有构造析构
4、new不必指定内存大小，根据类型推断，malloc必须指定开辟的内存大小
5、返回确定的类型指针，malloc返回（void *）还得强制类型转换
6、失败了：new返回bad_alloc malloc返回null
7、malloc使用红黑树组织分配了的内存块，
8、如果不够了，malloc会在分配地方后面检查还有没有空地方，如果有连续的空内存，就接上，如果没有就重新分配并拷贝数据，而new没有这个机制，

2、空类实例化一个对象需要多大内存？如果类中有虚函数呢？
1字节的内存，
如果有虚函数就是4字节，

#include<iostream.h>

class a {};
class b{};
class c:public a{
 virtual void fun()=0;
};
class d:public b,public c{};
int main()
{
 cout<<"sizeof(a)"<<sizeof(a)<<endl;
 cout<<"sizeof(b)"<<sizeof(b)<<endl;
 cout<<"sizeof(c)"<<sizeof(c)<<endl;
 cout<<"sizeof(d)"<<sizeof(d)<<endl;
 return  0;}

程序执行的输出结果为：

sizeof(a) =1

sizeof(b)=1

sizeof(c)=4

sizeof(d)=8  // 内存对齐，

3、内存泄漏如何解决？
参考链接
* 1、单例模式的对象，存在普通对象的引用，普通对象在使用完事了，需要被回收，但是不能被回收。
* 2、静态变量对象存在 外部非静态变量对象引用，说白了，就是一个生命周期的问题，生命周期长的对象存在生命周期短的对象引用，或指针，就会导致生命周期短的对象不能被及时的回收。
解决：
* 1、程序员保持对对象变量生命周期的敏感。特别注意单例模式，静态变量，
* 2、不再使用的对象，显示的设置为NULL。
* 3、使用弱引用。

5、商汤科技

1、了解STL吗，说一下再STL中链表（list）是如何实现的
双向循环链表
vector动态数组，

other1:
vector动态数组，移动构造函数。reserve()预留。保证capacity的大小，但是直接vec[index],index虽然小于capacity，仍可以是无效的。而resize()函数，下标小于参数时都是有效的。大于参数时都是无效的。
othe2：map以红黑树实现。插入删除等操作都可以在O(log n)时间内完成
set也是红黑树，实现。
红黑树：近似平衡搜索二叉树，有排序，
svl,完全平衡二叉树，只从平衡角度说的，没有排序。
B+树：平衡多路搜索树

2、STL的六个组件都是哪些
容器（containers）

迭代器(iterator)：泛型指针，是一种智能指针

算法（algorithm）：一种function template，常用的有sort、search、copy、erase等

仿函数(functor)：行为类似函数，就是使一个类的使用看上去象一个函数，具有可配接性。

适配器(adapter)：一种用来修饰容器(container)或仿函数(functor)或迭代器(iterator)接口的东西。如queue和stack。

配置器(allocator)：负责空间配置与管理。是一个实现了动态空间配置、空间管理、空间释放的class template。一般SGI STL为每一个容器都指定其缺省的空间配置器为alloc（SGI配置器）

3、联合查询，join，left join right join，一般的join是选取什么样的数据呢
1、永远用小结果集驱动大结果集(其本质就是减少外层循环的数据数量)

2、为匹配的条件增加索引(减少内层表的循环匹配次数)

3、增大join buffer size的大小（一次缓存的数据越多，那么内层包的扫表次数就越少）

4、减少不必要的字段查询（字段越少，join buffer 所缓存的数据就越多）

4、redis IO的单线程处理模式是怎么满足高并发的需求的呢
redis是基于内存的，内存的读写速度非常快；
核心是基于非阻塞的IO多路复用机制；
redis是单线程的，反而省去了很多上下文切换线程的时间；

5、平时项目中有用到设计模式吗，说说你对单例模式的理解吧，还有哪些实现方式
参考1，：文章开头
参考2

6、手写LRU

Least Recentily Used的缩写，即最近最少使用
自己写的链接

7、手写单例模式

参考别人
自己写的
懒汉式：线程不安全：想要线程安全就得加锁：
3个成员：
一个私有的构造函数
一个私有的静态的指针。
一个共有的静态外部访问接口函数。
使用时机：访问量不大，使用懒汉时，以时间换空间。
饿汉式：访问量大，多线程。以空间换时间。

class Singleton{
private:

    static Singleton* p;  // 一个私有静态变量，确保只有一个实例
    SingleLeton(){}  // 私有的构造函数，确保只能单例类自己创建实例

public:
    static Singleton* getUniqueInstance();    
};
Singleton* Singleton::p = nullptr;
Singleton* Singleton::getUniqueInstance(){
    if(p == nullptr){
        p = new Singleton();
    }    
    return p;    
}

饿汉式：

class Singleton{
private:
    static Singleton* p;  // 一个私有静态变量，确保只有一个实例
    SingleLeton(){}  // 私有的构造函数，确保只能单例类自己创建实例

public:
    static Singleton* getUniqueInstance();    
};
Singleton* Singleton::p = new Singleton();  // 这里
Singleton* Singleton::getUniqueInstance(){
     
    return p;    
}

3、返回局部静态变量会有什么问题吗
没问题。因为局部的静态变量也是存储在全局区的。只会在程序结束以后才销毁。所以可以返回局部静态变量的值，指针，引用。
返回局部变量没问题，返回的时局部变量的拷贝。
返回局部变量的地址就会有问题。局部变量存储在栈上，函数返回，局部变量内存回收。局部变量指针指向不确定了。

字符串：
返回一个指向常量字符串的指针（存储在常量区）是可行的，但是返回一个指向局部字符串变量的指针是不行的。

4、微信聊天、传文件用的什么协议，为什么
udp,tcp
5、如何让UDP实现可靠的连接
通过应用层来实现，模仿tcp,
1、添加seq/ack机制，确保数据发送到对端
2、添加发送和接收缓冲区，主要是用户超时重传。
3、添加超时重传机制。

5、epoll的底层结构
红黑树，+双向链表

6、mysql索引优化
哪些情况需要创建索引，那些情况不需要创建索引

2、频繁作为查询条件的字段应建立索引
3、查询中与其他表关联的字段，外键关系建立索引

4、频繁更新的字段不适合创建索引
5、where子句里用不到的字段不要创建索引
6、单值/复合索引？（在高并发下倾向于复合索引）
7、查询中排序字段，排序字段若通过索引去访问，将大大提高排序速度
8、查询中统计或分组的字段，
不建：
1、表记录太少（300万）
2、经常增删改的表，不建
3、数据重复，且分布平均的表字段。

7、mysql索引结构
B+Tree

8、redis有哪些数据结构，redis和Kafka相比有什么优点，是由什么样的特性决定的
一个链接
五大数据类型
5.1、string类型
5.2、list
5.3、set
5.4、hash
5.5、zset有序集合
6、3种特殊数据类型
6.1、geo
6.2、hyperloglog
6.3、Bitmaps

Kafka 是一个高吞吐、分布式、基于发布订阅的消息系统。
存储介质不同：
redis queue数据是存储在内存，虽然有AOF和RDB的持久化方式，但是还是以内存为主。
kafka是存储在硬盘上

通常只有一些高并发场景下需要用redis queue，比如发红包，可以先将红包预先拆解然后push到redis queue，在抢的一瞬间可以很好的支撑并发。

成本不同。
一个时内存一个是硬盘。

如果有以下场景可以考虑使用Redis作为消息队列

如果你的需求是快产快消的即时消费场景,并且生产的消息立即被消费者消费掉
　如果速度是你十分看重的,比如慢了一秒好几千万这种
　如果允许出现消息丢失的场景
　如果你不需要系统保存你发送过的消息,做到来无影去无踪
　如果需要处理的数据量并不是那么巨大
当有一下场景的时候你可以考虑使用KafKa作为消息队列

如果你想要稳定的消息队列
　如果你想要你发送过的消息可以保留一定的时间,并不是无迹可寻的时候
　如果你无法忍受数据的丢失
　如果速度不需要那么的快
　如果需要处理数据量巨大的时候
　
9、IO单线程的情况下，为什么redis还能保证并发量，底层的结构是什么
redis 单线程指的是网络请求模块使用了一个线程，即一个线程处理所有网络请求，其他模块仍用了多个线程。
因为CPU不是Redis的瓶颈.
避免了不必要的上下文切换和竞争条件
非阻塞IO多路复用

7、阿里，云

1、TCP 连接过程是怎么样的？
3次握手4次挥手
2、假如说有一个恶意的客户端，要是想耗尽服务器的资源，要怎么做？

8、c++面试题：

1、
C++ 11 有什么新特性
2、
C++ 的 vector 和 list 中，如果删除末尾的元素，其指针和迭代器如何变化？若删除的是中间的元素呢
3
C++ 的多态是如何实现的？
4、
C++ 中什么是菱形继承问题
5、
C++ 中类模板和模板类的区别
6、
C++ 是如何进行内存管理的？
7、
C++ 中虚函数与纯虚函数的区别
8、
C++ 的重载和重写是如何实现的?
9、
C++ 中哪些函数不能被声明为虚函数？
10、
C++ 中智能指针和指针的区别是什么？

11、
C++的四种强制转换

12、
C++的调用惯 例简单一点C++函数调用的压栈过程
2222
333
13、
C++的智能指针有哪些，都有什么特点
14、
C/C++内存存储区有哪几种类型？
15、
STL 中 vector 与 list 具体是怎么实现的？常见操作的时间复杂度是多少？
list 容器实际上就是一个带有头节点的双向循环链表
16、
STL 中的内存分配器原理
正确使用+内存管理的实现
17、
STL中排序算法的实现是什么
18、
const、static 关键字有什么区别

19、
#define和const的区别
const一份拷贝 ----> define多分拷贝，用的时候就替换，
const存在符号表中，快，------->寻址，慢
类型检查 --------> 只是替换，
可以调试 ------> 不能调试

20、
delete和delete[]的区别
21、
lambda 函数的特点，和普通函数相比有什么优点？
使用一次，简单，回调，
22、
简述 C++ 的内存分区
23、
简述 C++ 的内联函数
符号表

24、
简述 C++ 编译的过程
.c源文件---->预处理—>.i文件—>编译---->汇编语言源代码.s文件，---->汇编—>.o文件，------>链接—>可执行文件

25、
简述 C++ 右值引用与转移语义
在动态分配内存时，设计类库，和有机会重构代码时积极使用。

26、
简述 C++ 中内存对齐的使用场景
两个规则，1、当前变量和系统指定的大小，取小的，2，整体是整数倍。
2222
27、
简述 C++ 中智能指针的特点
简述 new 与 malloc 的区别
28、同24
简述 C++ 从代码到可执行二进制文件的过程
.c源文件---->预处理—>.i文件—>编译---->汇编语言源代码.s文件，---->汇编—>.o文件，------>链接—>可执行文件

29、
简述 STL 中的 map 的实现原理
30、
简述 STL 中的 set 的实现原理
31、
简述 vector 的实现原理
32、
结构体struct和共同体union（联合）的区别
33、
指针和引用的区别是什么？
34、
简述程序编译和链接的过程
35、
类默认的构造函数是什么？
36、
内存中堆与栈的区别是什么？
37、
基类为什么需要虚析构函数？
38、
变量的声明和定义有什么区别？
39、
对象复用的了解，零拷贝的了解
2222
40、
父类和子类是不是在同一个虚函数表?
不同

41、
什么是内存泄漏，怎么确定内存泄漏？Valgrind
怎么确定内存泄漏？
42、
什么是字节对齐，为什么要采用这种机制？
43、
虚函数表，虚函数指针，虚函数的实现原理
44、
只定义析构函数，会自动生成哪些构造函数？
45、
构造函数和析构函数可以被声明为虚函数吗？
46、
介绍面向对象的三大特性，并且举例说明每一个。
47、
成员初始化列表的概念，为什么用成员初始化列表会快一些
48、
编译时链接有几种方式？静态链接和动态链接的区别是什么？

• 1、静态链接
• 2、装入时动态链接（边装入内存，边链接）
  • 1 绝对装入
  • 2 可重定位装入
  • 3 运行时装入
• 3、运行时动态链接
  222
  49、
  如果在构造函数和析构函数中抛出异常会发生什么？什么是栈展开？
  栈展开22222222
  构造函数中：抛出异常，就不会执行析构函数了，很可能会内存泄漏，
  析构函数中：抛出异常，程序过早结束，和发生不明确的行为。应该另外搞一个处理异常的函数，让用户有处理错误的机会。

50、
常用的实现隐式类类型转换的方式是什么？如何避免隐式类型转换？
2222如何避免隐式类型转换？ 使用explicit可以避免隐式转换

9、go面试题

9.1、另外一个题目集合汇总链接
9.2、go面试题汇总22
1、简述go垃圾回收机制
参考
首先将对象用三种颜色表示，分别是白色、灰色和黑色。
最开始所有对象都是白色的，然后把其中全局变量和函数栈里的对象置为灰色。
第二步把灰色的对象全部置为黑色，然后把原先灰色对象指向的变量都置为灰色，以此类推。
等发现没有对象可以被置为灰色时，所有的白色变量就一定是需要被清理的垃圾了。

2、简述GMP模型

3、简述go伪抢占式调度

4、简述goroutine的调度流程

5、简述defer执行顺序
defer的执行顺序为：后defer的先执行。
defer的执行顺序在return之后，但是在返回值返回给调用方之前，所以使用defer可以达到修改返回值的目的。

6、简述slice的底层原理，slice的扩容机制？
和c++中的vector一样。

7、简述map的底层原理，map的扩容机制是什么？
链接
哈希表，链地址法解决冲突。
go语言中数组、字符串、结构体都是值传递
切片、map、chan是引用传递。

8、简述go断言实现原理？

9、简述go接口实现原理？
上下游解耦，细节隐藏，
go:一组方法的签名
10、简述闭包实现原理？
闭包的主要应用场景？
函数计数器，装饰函数，创建中间件

11、http库实现原理？怎么做到连接池和长连接？
分层

12、Maps是线程安全的吗？怎么解决它的并发安全问题？
不是，读写锁，分片，降低加锁的粒度，把数据按读写需求分离

13、golang的beego/gin框架？

14、goconvey框架？

15、goStub框架？

16、Array类型的值作为函数参数是引用传递还是值传递?
值传递
17、Channels怎么保证线程安全？
发送一个数据到Channel 和 从Channel接收一个数据 都是 原子性的。

18、Data Race 问题怎么检测？怎么解决？

19、go的协程通信方式有哪些？
通道（缓冲），信号量

20、go的协程可以自己主动出让cpu吗？
可以

21、go的内存模型？为什么小对象多了会造成gc压力？
通常小对象过多会导致GC三色法消耗过多的GPU。优化思路是，减少对象分配.
go的内存模型？

22、go中指针运算有哪些？
只能取地址，解引用，不能 ++ ，–

23、go中的引用类型包含哪些？
值类型
基本数据类型，int,float,bool,string, 以及数组和 struct 特点：变量直接存储值，内存通常在栈中分配，栈在函数调用完会被释放

slice切片，map,chan通道，
引用类型
变量存储的是一个地址，这个地址存储最终的值。内存通常在 堆上分配。通过 GC 回收。

引用类型： 指针、slice 切片、管道 channel、接口 interface、map、函数等

24、go触发异常的场景有哪些？
空指针解析

下标越界

除数为0

调用panic函数

25、go中局部变量和全局变量的缺省值是什么？
都是0，

26、go中有没有this指针？
没有，方法施加的对象显式传递，没有被隐藏起来

27、goroutinue什么时候会被挂起？
1、time.sleep
2、socket循环读取消息
3、channel痛道阻塞
4、对同一个mutex，当routine A调用了mutex.Lock()后，rontine B再调用mutex.Lock()时会挂起，直到routine A调用mutex.Unlock()释放掉锁资源后，routine B才会执行mutex.Lock()继续往下执行

28、new和make的区别有哪些？
结构体可以分配到堆上也可以分配到栈上，go编译器逃逸分析
如果有用到这个地址，就分配到堆上，如果用不到，就会在栈上分配。

29、range迭代map是有序的吗？
不是。
for遍历slice，和遍历map,底层实现是不一样的。

遍历map生成一个随机数，每次重新 for range map，你见到的结果都是不一样的。那是因为它的起始位置根本就不固定！

for range map 在开始处理循环逻辑的时候，就做了随机播种…

30、go的一个协程能保证绑定在一个内核线程上吗？
能，GMP模型。

31、select 可以用于实现哪些功能？
随机执行一个case,case是信道操作

32、string的实现原理？类型的值可以修改吗？
字符串类型的值是不可变的。类型C++中指向字符串字面量，轻量级
string底层一个结构体，包含首指针，和一个长度，
[] byte来表示可变的字符串。

33、switch中如何强制执行下一个case代码块？
执行完上一个，go语言会停下来。通过fallthrough 关键字强制执行后面一条

34、两次GC周期重叠会发生什么？GC触发机制是什么样？
这个新的运行 GC 的 Goroutine 就会在开始标记阶段前去协助完成剩余的清理工作
GC触发机制是什么样？
GC触发机制是什么样？

35、解析json数据时，默认将数值当作哪种类型？
Go 默认会将数值当做 float64 处理

36、什么是goroutine泄露？
goroutine一直在等待，或者是阻塞着。

37、如何从paic中恢复？
recover

38、使用值为nil的slice,map会发生什么？
直接打印map会返回0值，外部引用slice会死机，但是可以访问slice的size和cap都是0，

39、在循环内执行defer语句会发生什么？

40、你是否主动关闭过http链接？为什么要这样做？

41、有缓存的管道和没有缓存的管道区别是什么？
异步，同步，

42、协程与进程，线程的区别是什么？协程有什么优势？
轻量级，用户态线程，完全由用户调度，使用内核线程执行，主动出让cpu。

10、计算机网络面试题

1、
Cookie 和 Session 的关系和区别是什么？
22222
2、
DNS 查询服务器的基本流程是什么？DNS 劫持是什么？
3、
HTTP 中 GET 和 POST 区别
4、
HTTP 与 HTTPS 有哪些区别？
5、
HTTP 的方法有哪些？

6、
HTTP 是无状态的吗？需要保持状态的场景应该怎么做？
7、
RestFul 与 RPC 的区别是什么？RestFul 的优点在哪里？
8、
RestFul 是什么？RestFul 请求的 URL 有什么特点？
9、
TCP 中 SYN 攻击是什么？如何防止？
10、
TCP 与 UDP 在网络协议中的哪一层，他们之间有什么区别？
11、
TCP 的 keepalive 了解吗？说一说它和 HTTP 的 keepalive 的区别？
12、
TCP 挥手时出现大量 CLOSE_WAIT 或 TIME_WAIT 怎么解决？
13、
TCP 怎么保证可靠传输？
14、
TCP 如何实现数据有序性？
15、
TCP 中常见的拥塞控制算法有哪些？
16、
TCP的拥塞控制具体是怎么实现的？UDP有拥塞控制吗？
17、
TCP长连接和短连接有那么不同的使用场景？
18、
traceroute 有什么作用？
19、
简述 BGP 协议和 OSPF 协议的区别
20、
简述 DDOS 攻击原理，如何防范它？
21、
简述 HTTP 1.0，1.1，2.0 的主要区别
22、
简述 HTTP 的 keepalive 的原理和使用场景
23、
简述 HTTP 报文头部的组成结构
24、
简述 HTTP 短链接与长链接的区别
25、
简述 HTTPS 的加密与认证过程
26、
简述 JWT 的原理和校验机制
27、
简述 OSI 七层模型，TCP，IP 属于哪一层？
28、
简述 RPC 的调用过程
rpc与grpc2222
29、
简述 TCP 的 TIME_WAIT 和 CLOSE_WAIT
30、
简述 TCP 协议的延迟 ACK 和累计应答
2222
31、
简述 TCP 半连接发生场景
32、
简述 TCP 的报文头部结构
33、
简述 TCP 滑动窗口以及重传机制
34、
简述 TCP 三次握手以及四次挥手的流程。为什么需要三次握手以及四次挥手？
35、
简述 WebSocket 是如何进行传输的
36、
简述 iPv4 和 iPv6 的区别
37、
什么是 ARP 协议？简述其使用场景
38、
什么是 SYN flood，如何防止这类攻击？
39、
什么是 TCP 粘包和拆包？
40、
从输入 URL 到展现页面的全过程
41、
如何设计 API 接口使其实现幂等性？
42、
如何解决 TCP 传输丢包问题？
43、
简述常见的 HTTP 状态码的含义（301，304，401，403）
44、
从系统层面上，UDP 如何保证尽量可靠？
45、
如何防止传输内容被篡改？
46、
简述对称与非对称加密的概念
47、
什么是中间人攻击？如何防止攻击？
48、
为什么需要序列化？有什么序列化的方式？
49、
什么是跨域，什么情况下会发生跨域请求？
50、
简述在四层和七层网络协议中负载均衡的原理

11、操作系统面试题

1、
BIO、NIO 有什么区别？怎么判断写文件时 Buffer 已经写满?
2、
LVS 的 NAT、TUN、DR 原理及区别
3、
Linux 下如何排查 CPU 以及 内存占用过多？
4、
Linux 下如何查看 CPU 荷载，正在运行的进程，某个端口对应的进程？
2222
5、
Linux 页大小是多少？

可以用 getconf PAGESIZE 命令查看,数值单位是字节
一般默认是 4k（4096），也有 8k，16k 的，但比较少见

6、
Linux 如何查看实时的滚动日志？

以下以Tomcat为例子，其他WEB服务器目录自己灵活修改即可：
1、先切换到：cd usr/local/tomcat5/logs
2、tail -f catalina.out
3、这样运行时就可以实时查看运行日志了

7、
Linux 下如何查看端口被哪个进程占用？

两种方法:
1、lsof -i:端口号
2、netstat -tunlp|grep 端口号

8、
Linux 中虚拟内存和物理内存有什么区别？有什么优点？

8.1、
地址映射：把主存中的地址映射到cache中，
地址变换：程序访问主存中地址时候，根据对应关系去cache中寻找。
地址映射3种方式：
1、直接相连：主存按cache大小滑动。实现简单，cache利用率不高，适合大cache
2、全相连：主存和cache任意映射。数据结构复杂，映射关系开销大，适合小cache
3、组相连：结合二者，cache和主存都分组。组间直接映射，组内全相连映射（可以任意对应）。
参考

9、
malloc 创建的对象在堆还是栈中？

堆区。

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

10、
简述 CPU L1, L2, L3 多级缓存的基本作用
11、
简述 Linux 的 IO模型
12、
简述 Linux 零拷贝的原理
13、
简述 Linux 进程调度的算法
14、
简述 Linux 虚拟内存的页面置换算法
15、
简述 Linux 系统态与用户态，什么时候会进入系统态？
16、
简述 mmap 的使用场景以及原理
17、
简述 select, poll, epoll 的使用场景以及区别，epoll 中水平触发以及边缘触发有什么不同？
18、
简述 traceroute 命令的原理
19、
简述几个常用的 Linux 命令以及他们的功能
20、
简述操作系统中 malloc 的实现原理
21、
简述创建进程的流程
222
22、
进程有多少种状态？
23、
信号量是如何实现的？
222
24、
共享内存是如何实现的？
222
25、
创建线程有多少种方式？
222
26、
线程间有哪些通信方式？
27、
进程间有哪些通信方式？
28、
简述操作系统中的缺页中断
29、
进程和线程之间有什么区别？
30、
两个线程交替打印一个共享变量
31、
什么情况下，进程会进行切换？
32、
多线程和多进程的区别是什么？
33、
简述操作系统如何进行内存管理
34、
简述自旋锁与互斥锁的使用场景
35、
为什么进程切换慢，线程切换快？
36、
什么时候会由用户态陷入内核态？
37、
进程空间从高位到低位都有些什么？
38、
进程通信中的管道实现原理是什么？

39、如何调试服务器内存占用过高的问题
如何调试服务器内存占用过高的问题？

40、线程有多少种状态，状态之间如何转换
线程有多少种状态，状态之间如何转换

41、简述同步与异步的区别，阻塞与非阻塞的区别
简述同步与异步的区别，阻塞与非阻塞的区别

42、操作系统中，虚拟地址与物理地址之间如何映射？
操作系统中，虚拟地址与物理地址之间如何映射？

43、系统调用的过程是怎样的？
系统调用的过程是怎样的？

44、操作系统是通过什么机制触发系统调用的？
操作系统是通过什么机制触发系统调用的？

45、简述僵尸进程和孤儿进程及其危害和处理
简述僵尸进程和孤儿进程及其危害和处理

46、死锁产生的条件、死锁避免方法
死锁产生的条件、死锁避免方法

47、进程的三状态模型、五状态模型、七状态模型
进程的三状态模型、五状态模型、七状态模型

48、线程从进程继承了哪些资源？线程独享哪些资源？
线程从进程继承了哪些资源？线程独享哪些资源？

49、简述缓冲区溢出及其危害
简述缓冲区溢出及其危害

50、简述分页与分段，分页与分段的区别
简述分页与分段，分页与分段的区别
222

12、阿里

1、kafka 广播、单播、消息丢失、重复消费？
2、数据库事务四大特性？
原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）、持久性（Durability
3、隔离性原理？
4、redis数据类型？（项目中点赞用到了set）数据量太大了怎么办？……
redis为什么快？
5、常用的设计模式？主要说了双重校验单例模式的细节、观察者、发布-订阅（结合kafka聊了几句）
6、抽象类&接口&多态？
7、cookie和session的区别？
8、实现一个cache？刚开始想用LinkedHashMap，感觉可能要gg 😂 ，就自己写了个双向链表+HashMap实现的
9、并发大的情况下，核心线程池该如何设置参数？大流量进来会不会堵塞整个流程（通过扩容服务器的方式?）

这里解释一个核心线程池里最大线程池的参数，找了好久才找到的，你要看你的项目是IO密集型还是CPU密集型，因为IO密集型的话，需要进行IO操作，在操作的时间，是不消耗CPU的，所以一般这种情况，你的cpu数的倍数即可，如果是cpu密集型，那么最大线程数只能设置为cpu数+1，这样留一个空出来，用来做切换。
2、幂等问题？–项目中的幂等问题–本地消息表（空间换时间的概念）

幂等问题本身就是一个常规化的问题，在一般情况下，都是需要通过各种手段去处理，比如增加冗余字段，比如增加校验逻辑，或者增加补偿逻辑等。这里的核心点就是，需要花费更多的时间和空间去对幂等进行校验，那么亮点应该是如何平衡时间和空间的消耗。

13

redis的string的底层实现
syn关键字底层实现
.redis分布式锁的底层lua setnx

14、阿里java后端

1、说一下hash函数的好处
2、StringBuilder的append方法和“+”有什么区别，底层实现
3、http的常见状态码以及含义
4、tcp和udp的区别
5、udp不面向连接数据怎么传输的呢
6、基于tcp和udp的应用层有哪些（比如http）
TCP支持的应用协议主要有：Telnet、FTP、SMTP等；
UDP支持的应用层协议主要有：NFS（网络文件系统）、SNMP（简单网络管理协议）、DNS（主域名称系统）、TFTP（通用文件传输协议）等。

7、讲一下cookie和session的区别和作用
8、什么是http无状态连接
9、sessionID是在哪里生成的
服务端

10 、说一下动态规划和贪心算法区别
这个
11、动规和贪心有什么相似的地方
16、说一下GC
17、哪些算垃圾
18、引用计数什么情况下有问题，举个例子
19、JVM怎么分代
20、年轻代GC用什么算法，老年代用什么算法
21、你知道什么是幂等吗？
22、InnnoDB、Myisam区别
23、redis （说了优势 处理事件单线程、内存、aof rdb持久化，数据结构丰富：bitmap hyperloglog geo… ps.也没细问）
24、上下文切换消耗cpu时间如何优化
网络io的零拷贝函数，协程主动出让cpu(时间片轮转的化，也得调度，),
25、共享屏幕写个多线程
26、共享屏幕简单写个B+树
27、8. B+树改成hash共享屏幕写

9. redis数据结构

10. redis过期删除&内存淘汰

11. LRU

12. 缓存雪崩&缓存穿透是什么，如何解决

13. 布隆过滤器怎么实现的

15、阿里云

1、项目 + 深挖细节
2、线程数量怎么设定
3、内存访问异常的情况

4、虚函数、多态的实现
5、c++11特性

6、智能指针
7、野指针

8、stl几种容器介绍+使用场景
set
快速查找，不允许重复值
multiset
快速查找，允许重复值

map和unordered_map实现原理

9、单例模式
10、redis几种结构介绍+实现原理、string最大存多少数据
512M

11、redis中数字怎么存储
双向链表

12、redis持久化的方式
Aof文件异常怎么办
redis-check-aof启动，在断电异常的时候，重启之后，再用

13、redis支持事务回滚吗
不支持
mysql事务
索引结构、b+树特性、最左匹配
git代码管理工具会吗
复盘两道笔试题

二面：

项目细节
redis源码中list怎么实现，应用场景，看了有什么收获
redis中hash怎么实现、rehash、渐进式rehash
复盘笔试题，问我第二题没a出来，下来自己有去再思考吗，和同学讨论过吗（思考过，没想出来。。。）

三面：hr
项目上遇到的困难，怎么解决
项目的亮点

15、阿里

5. 线程的创建方式，线程池的原理及使用场景

6. 保证线程安全的手段（锁机制）

7. Spring的核心（IOC+AOP）

8. 面向对象编程的五大原则
   文章开头第二个小标题：
   单一职责，
   里斯替换
   依赖倒转
   接口隔离
   知道最少
   合成复用

9. 平常用到的设计模式

10. 算法题：验证二叉搜索树
    题目链接
    中序遍历树保存节点值，再遍历一遍数组，验证各位置大小

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:

    void inOrder(TreeNode * root,vector<int>&nums){
        if(!root) return ;
        if(root->left) inOrder(root->left,nums);
        nums.push_back(root->val);
        if(root->right) inOrder(root->right,nums); 
    }

    bool isValidBST(TreeNode* root) {
        vector<int>res;
        inOrder(root,res);
        int flag = true;
        for(int i =1; i < res.size();i++){
            if(res[i-1] >=res[i]){
                flag = false;
                break;
            }
        }      
        return flag;
    }
};

12. 场景题：请求远程服务器，走的缓存的场景

13. Redis缓存淘汰策略，LRU和LFU的特点、区别
    可见LRU关键是看页面最后一次被使用到发生调度的时间长短,
    而LFU关键是看一定时间段内页面被使用的频率!

16、阿里

作者：牛客649135656号
链接：https://www.nowcoder.com/discuss/705340?type=2&order=3&pos=25&page=0&ncTraceId=&channel=-1&source_id=discuss_tag_nctrack
来源：牛客网

1 线程池
2 怎么优化并发服务器性能
使用内存数据库
3 Linux系统内存分配原理和系统调度
4 malloc怎么实现内存分配
5 多线程怎么维护trunk
6 tcp/ip
7 b+树，hash，红黑树
8大范围数中判断一个数是否存在
9 01背包问题
10多叉树蛇形遍历，现场写

12、阿里

作者：牛客407800558号
链接：https://www.nowcoder.com/discuss/714511?type=2&order=3&pos=9&page=1&ncTraceId=&channel=-1&source_id=discuss_tag_nctrack
来源：牛客网

2.双写是先写旧表还是先写新表，怎么check数据的正确性呢，都check哪些内容
3.类比实习的事情，有多个表，分库分表的情况，在不影响线上业务读写的情况，如何迁移到另外的数据库表中？
4.简历上提到的接口优化都有哪些内容呢
5.索引为什么能提高数据的查询速率
答：b+树 balabala
6.b+树结构 主键索引和非主键索引
7.b+树一般有多少层 可以放多少节点数据呢，怎么计算
8.jvm垃圾回收算法
9.jvm启动时，垃圾回收算法需要传什么参数呢
10. 快速排序的过程
11.快速排序用到了什么思想
答: 递归 分治，不知道还有什么
12.写一个递归需要有什么
13.线程池 常用参数
14.为什么有核心线程数，为什么有最大线程数
15.一个8核处理器，核心线程数要设置为多少

14、美团

1、redis高可用了解吗（不了解）

2、redis哨兵和集群（简单讲了一下）
3、分布式锁（没有用到分布式，不会）
4、kafka原理用法简单讲一下
5、nginx面试题
6、主键和唯一索引的区别

7、服务器部署两个服务，如何做请求的对应
“IP地址+端口号”来区分不同的服务
8、如何自己实现HTTP通信
9、红黑树+AVL平衡树
10、B+树和哈希索引
相应的应用场景，
哈希索引：重复的值比较少，等值查询没有范围查询，没有排序，
11、一条sql的执行过程
12、MVCC实现
13、什么是聚簇索引和非聚簇索引

14不可重复读是怎么实现

15、虾皮

1、全局变量和静态变量
2、volatile 不做优化，
volatile 的意思是让编译器每次操作该变量时一定要从内存中真正取出。
变量，存取两次。和多线程的时候。
3、ca证书验证过程？
公钥公之于众，
自己发东西，使用对方的公钥加密，使用自己的私钥签名。
对方私钥才能解开，又有自己的私钥签名，不可抵赖。
版本2.0：对明文生成密钥A，使用对方的公钥对密钥A加密传过去，再把通过密钥A加密的明文->变成了密文，传过去。 对方先用自己的私钥对密钥解密，然后再用密钥解密文–>得到明文。
4、访问网址的协议？
http,tcp,dns->udp,ip,icmp,arp,
5、mysql锁有哪些？
按粒度：行级锁，表级锁，页所
按类型：共享锁，排他锁
6、mysql一个索引能存多少数据
16K,
mysql一张表到底能存多少数据？
千万级条，
7、合并多个有序链表
8、redis为啥用单线程？？单线程怎么做到并发 ？
IO多路复用，
9、.redis数据类型zset底层结构？为啥用跳表
10、手撕：多线程顺序打印123
11、让你写一个服务器 理论上最多多少连接？实际有多少可能有哪些方面限制了？
固定自己服务器ip和端口，客户端ip（2的32次方）和端口（2的16次方）的乘积。
1、最大打开的文件数，一个连接请求一个socket，内核级，用户级，进程级。
2、分配一个接收缓冲区，最小4K,
3、只维护连接，不处理数据，接受发送。
12、