竞技世界C++开发一面

#面经#

不知道是客户端还是服务端，B**S上投递的，职位描述上也没有说是客户端还是服务端，整体面试挺难，问了很多细节上的问题。

整体面试总结：盯着简历问的，简历上写什么就问什么。狠狠拷打。感觉已凉。

对话录音转文字：

00:00 说话人1（第一个面试官，对着简历上的专业技能一个一个拷打，但凡写上去的都问多，啥也没放过）

虚函数、纯虚函数有什么区别？

00:05 说话人2（我自己）

虚函数的话就是。嗯，有实现体。嗯，纯虚函数就是等于0的，就是呃类似于一个。嗯，接口吧，如果一个类实现了纯虚函数。然后，另外一个类继承了这个实现纯虚函数的类。那，另外一个类如果不实现这个纯虚函数，嗯，那它就没有办法实例化啊，必须实现纯虚函数才能实例化。嗯。

00:39 说话人1

在什么样的情况下，析构函数必须声明为虚函数？

00:45 说话人2

呃。多态情况下，因为呃，如果虚构函数不声明为虚的啊，那么在使用。嗯。父类的指针去销毁子类对象的时候就不会调用。就不会正确的调用子类的析构函数，然后这个时候就会导致内存泄露。

01:14 说话人1

在什么样的场景下面，我们需要使用虚基类？

01:19 说话人2

书集类，嗯。是指，呃，我记得class是没有办法用virtual关键字的吧。

01:33 说话人1

没有学到这一块是吧。

01:37 说话人2

顶多可能多继承的时候，可能会用虚继承吧。虚基类我好像还没有听说过。

01:43 说话人1

不是吗？

01:45 说话人2

这叫虚基类啊，那算是我们没有了解到。

02:04 说话人1

内心里提到的类型推导是。

02:08 说话人2

怎么？凹凸就是简单使用的话，就是凹凸嘛。嗯，就是变量定义或者声明的时候，一般是定义就是给它赋值的时候可以用凹凸。嗯，然后如果是函数的话，我可以把凹凸写在返回值的位置，然后这个时候我需要用。呃，一个P关键字啊。就告诉这个编译器，我要返回的这个类型，因为我不确定它返回什么类型。这个应该是在模板里面会用的比较多。

02:39 说话人1

如果你不告诉他呢？如果你不告诉他呢？

02:45 说话人2

呃，因为我用auto的情况下，就是我不知道它具体会返回什么类型。啊，一般来说就是用在模板的那个地方。这个时候需要去根据实际情况，就告诉他我的这个类型是从哪儿可以推导出来的。

03:00 说话人1

那如果说是这样的，你返回的类型里面，你不告诉他显式的返回类型，这个时候编译器如何去判断是什么类型

03:11 说话人2

嗯。我好像还没这么用过，我一般都是两个一起用的。

03:22 说话人1

智能指针。

03:25 说话人2

嗯，智能指针主要是3个，呃，Unique p tr, share p tr跟微PTR。Unique p tr是，嗯，不允许拷贝的，但是可以移动，它是独占所有权。嗯，然后PR它是通过内部的，呃，应用技术去。嗯。就是说保存现在嗯，有几个实例在引用它所管理的那块内存，如果归零的话，那它就去释放这块内存。嗯，但是会出现自己用的问题，比如说A里面有一个she p, TR指向B。B里面有个share p tr指向A，那这个时候啊，两个人都会等待对方去减少引用技术，但自己又不去释放内存。

04:10 说话人2

这个时候就是内存泄露，然后可以用weak_ptr去解决，因为weak_ptr是弱引用。嗯，就比如说我把B类里面指向A类那个share_ptr改成weak_ptr，那这个时候就可以解决自应用的问题。

04:29 说话人1

unique_ptr和share_ptr可以互相转换吗？如果可以转换的话，是单向转换还是双向转换？谁转换为谁？

04:45 说话人2

（没这么玩过，犹豫了一下）嗯，应该是单向转换是。嗯，unique_ptr转share_ptr。

04:56 说话人1

怎么样从weak_ptr中获取到share_ptr？

05:04 说话人2

嗯。这个我还不清楚。没有用过是吧？对。

05:13 说话人1

Lamdba里面的捕捉器里面的引用。有什么注意事项。

05:27 说话人2

呃，就是lambda表达式对吧。

05:34 说话人1

嗯。

05:40 说话人2

（这个多少有点懵逼了，）这个。我目前没有遇到特别要注意的。

05:55 说话人1

捕捉的是一个指针。

05:58 说话人2

呃，引用捕捉一个指针吗？还是就单纯捕捉一个指针？

06:05 说话人2

单纯捕获一个指针。

06:09 说话人2

如果是局部变量的话，可能会出问题。

06:13 说话人1

局部变量出问题是吗？

06:19 说话人1

如果说我在现在当前的线程一你。

06:27 说话人1

去升。就是去执行了那个。

06:39 说话人2

嗯，那这不就是我这个提示。

06:42 说话人1

你猜猜。

06:51 说话人2

嗯，你是在一个线程里面创建了兰姆达表达式，然后丢到了另外一个线程。嗯，那你。嗯。啊，那也就是病发了。那就需要注意考虑问题。

07:05 说话人1

不考虑并发。这个问题聚焦到。问题聚焦到lamdba捕获的注意事项上面。

07:17 说话人2

嗯。如果你之前的那个线程它结束了的话，那那块儿内存不就已经释放掉了吗？就是你引用捕捉的，或者是用指针的那块儿。那这个时候再去访问，不就会出问题？

07:34 说话人1

嗯，所以就是这个。移动语义。

07:42 说话人1

Std::forward()和std::move()分别使用在什么？

07:46 说话人2

嗯，move是把一个左值转换为右值。forward是啊，完美转发就是说啊，我用了forward之后，那么这个参数它是左值就会保持保持左值的属性啊，右值就会保持右值的属性。

08:09 说话人1

如果说给他。给他加了右值了以后。

08:21 说话人2

嗯，右值的话更相当于一个临时的变量或者说。嗯，没有办法取地址的。嗯，而且它本身只能出现在等号的右边，不能出现在左边，就是你没有办法把另外的值赋给一个右边个例吧。

08:38 说话人1

我举个实际的场景，一个函数有两个参数。第二个参数是又子。在函数的内部使用它有区别吗？

08:52 说话人2

呃，左直引用和右直引用本身都是左直。嗯。

08:59 说话人1

有区别吗？在这个函数的内部去使用这两个。

09:05 说话人2

嗯。没有区别。

09:09 说话人1

那他为什么要有一个。

09:14 说话人2

如果是左直引用的话，那他就可以修，嗯，也不一定说可以去修改。

09:24 说话人2

（应该是想问左值引用和右值引用的区别，但是这里已经开始紧张了，完全没get到意思）嗯，那这块我还不太了解，我还是没有很清楚你说的那种情况。

09:35 说话人3

好吧。

09:37 说话人1

模板你学到什么程度？

09:40 说话人2

嗯。

09:41 说话人1

是简单了解，还是很熟悉，还是说精通。

09:44 说话人2

还是精通？也不能说精通吧？嗯，差不多算熟悉。

09:53 说话人1

嗯，知道是吧？

09:59 说话人2

嗯，对。

09:59 说话人1

那匹配失败不是一种错误，怎么理解？

09:59 说话人2

（已经不知道在问什么了。。。开始瞎猜）嗯。因为我可以有很多个，比如说对一个模板我可以去。嗯，特化它，比如全特化或者偏特化，这个时候匹配的时候应该是优先匹配。嗯，全套话版本，然后再去匹配偏套话版本，然后都没匹配到，再去匹配默认的那个版本。然后如果这个时候再匹配不到的话，那就是那就是有问题了。

10:26 说话人1

嗯，我这我给你举个时间案例，比如说。嗯，一个类似。每一个构造的板都模的形，他都有可能不一样。我如何去，呃，通过参数去找到正确的？还一个Co函数。

10:48 说话人2

呃，是参数个数不一样吗？

10:51 说话人1

嗯，都有可能。假设，假设参数各是一样的情况下。假设就一个参数啊。

10:59 说话人2

嗯，就是说我有多个构造函数，然后他们给你简化一下。

11:04 说话人1

简化一下。两个构造函数，两个构造函数，一个是布尔小布尔类型的，一个是int类型的。啊嗯，你在外面去传一个传参的时候，如何去正确的匹配到这对应的构造函上面？

11:23 说话人2

嗯。指定类型要么就是指定类型，或者是谁指定啊？外面指定肯定是外面使用的时候还要去指定吗？呃，你传的变量的类型应该是确定的。

11:37 说话人1

嗯，然后呢，在模板里面怎么样去判断。嗯，怎么样去匹配。

11:44 说话人2

啊，你是一个类，生成了两个模板，然后对应两个构造函数。嗯。那你如果传布尔型的话，其实他也能跟int型进行匹配。为什么呢？因为布尔可以转T，但是会优。

11:59 说话人1

就代表着它是一样的嘛。

12:01 说话人2

呃，但是会肯定会优先匹配布尔，因为已经有呃已有的实限了，那就会优先匹配布尔。如果没有布尔类型的这个版本啊，它就会匹配int。

12:11 说话人1

你能肯定吗？嗯。

12:13 说话人2

那肯定。

12:15 说话人1

你能肯定小布和英特尔，它都是属于英特？

12:21 说话人2

嗯。

12:25 说话人2

负尔值不就是0和1嘛，那本质上不还是int？

12:29 说话人1

我说这是小波，不是大波。

12:32 说话人2

小布洱。

12:36 说话人2

小布尔C加加里面不就一种布尔类型吗？

12:43 说话人1

行，你可以理解为就只有一个小布偶的，你确定他一定就是类型吗？

12:48 说话人2

呃，也就是在。

12:52 说话人1

在匹配的时候，他一定会去那么匹配吗？

12:56 说话人2

嗯。嗯，他肯定会先匹配布尔类型，然后再去尝试匹配int类型。

13:01 说话人4

嗯。

13:07 说话人1

他这个时候匹配会出现歧义吗？

13:10 说话人2

嗯。

13:13 说话人2

会有歧义。

13:15 说话人1

那既然是有歧义的话，那如何去那如何做到精确匹配呢？

13:20 说话人2

嗯，精确匹配。

13:26 说话人2

那你就要判断类型吧。

13:29 说话人1

啊，这些。

13:30 说话人2

嗯。但是C加加里面好像没有判断类型的方法。嗯。

13:35 说话人1

没有判断类型的方法吗？（被面试官质疑了，应该是有的，但是用的少，没想到）

13:38 说话人2

嗯。加个中间层吧，加个中间层萃取一下。（还想说类型萃取呢，也是胡言乱语）

13:44 说话人1

加一个什么样的。

13:46 说话人2

嗯，加一个。封装过的中间层就是。嗯。匹配你传的那个参数。

13:57 说话人1

匹配什么呢？嗯。

14:00 说话人2

比如说你传入的参数如果是。嗯，布尔类型的就是一个，嗯。中间层就是一个嗯单的模板类，这个模板类里面有一个。嗯，怎么说呢。嗯，布尔或者int。就是有两个实现，两个模板，两个实现。嗯，然后你要是传int，那就匹配int那个。你要是传布尔，就匹配布尔那个。

14:33 说话人1

还有别的思路吗？

14:34 说话人2

嗯，目前没有别的思路了。

14:42 说话人1

std::bind。呃，绑定的那个参数，他的那个站位有严格的要求吗？

14:54 说话人2

嗯。有顺序要求

14:59 说话人1

就是有序要求是吧？

15:00说话人2

对。

15:02说话人1

你确定吗？

15:04 说话人2

呃，因为你绑嗯，办的绑定的时候不是可以传固定的参数值吗？嗯，然后你在那个位置传固定参数值的话，那么这个位置的参数就固定下来了。然后你可以在呃那个需要呃空余的那个位置呃去塞一个占位符。嗯，那这个不就是有顺序要求的。

15:27 说话人1

呃，在绑定位置的同时，还能携带其他的参数吗？

15:31 说话人2

嗯。另外加参数是吧？

15:33 说话人1

对。可以在任意位置加吗？

15:40 说话人2

嗯，我还没试过另外加参数呢。应该是不能加的吧。

15:48 说话人1

Std::function()。它支持。里面来支持哪一些可以传入的参数啊？

15:59 说话人2

嗯，Lambda或者是已经有的函数。嗯。嗯，仿函数。

16:08 说话人1

啊，还有呢，嗯。

16:11 说话人2

其他的好像没了吧。三种对，嗯。

16:16 说话人1

那你，嗯。现在用function多还是用lamdba多？

16:22 说话人2

呃，lamdba西。因为lamdba更方便。

16:28 说话人1

多线程。做线程和做进程有什么区别？

16:33 说话人2

嗯。多线程和多进程啊，如果是多进程的话。嗯，应该是通过fork，然后就是在Linux下，那就是通过fork去呃分离出来一个子进程。然后这个是候通过判断它的呃返回值，通过判断fork的返回值是确定父进程还是子进程。然后，嗯。多进程的话，应该是每个进程都有一份自己的变量。嗯，如果是多线程，那么多个线程共享进程内的一些变量。

17:09 说话人1

嗯。然后多，如果是多线程之间，线程与线程之间要。消息发送怎么办？

17:20 说话人2

嗯。可以通过临界区。啊，县城的通信可以通过临界区。

17:30 说话人1

你那你说的是资源共享。

17:32 说话人2

还是说的是什么？呃，资源共享，资源共享也差不多可以用来腾讯。

17:39 说话人1

我说的是从进程A。发生的某一件事情。然后呢，他要将这个事件。发给事件啊。和数据发给指定的某个线程。

17:55 说话人2

嗯。

17:59 说话人2

要发送数据，嗯，消息队列。

18:04 说话人1

要将数据发给指定的线程怎么办？

18:07 说话人2

发给指定的线程（思考。。。不知道怎么回答了）。

18:11 说话人1

嗯，就是只知道对端的线程ID。

18:17 说话人2

我还没这么玩过。嗯，对。

18:21 说话人1

那进程之间怎么通信呢？

18:27 说话人2

可以通过socket，然后也可以通过信号。嗯嗯，也可以通过信号量啊，然后共享内存。嗯，管道。对，目前就已知这些，你你用过哪种。嗯，管道用过，然后。啊，其他的应该都没用过。

18:51 说话人1

嗯。你能介绍一下你使用的管道是怎么用的吗？

18:56 说话人2

管道的话，就是在linux下创建，呃，我记得有一个系统调用可以创嗯，创建一个管道，就是一个数组，你需要提供一个已经。呃，Int类型的初始化好的数组，这个数组长度只有2，呃，然后去使用那个系统调用。啊，这个时候就会把数组初始化成管道，嗯，0和1两个位置，一个是读端，一个是写端。然后，通过你初始化好的这个呃之后的这个管道，然后后面你fork了之后，你可以往管道里面读写数据。

19:28 说话人4

嗯。

19:29 说话人1

通过管道来进行多进程之间的通讯是吧？如果说你刚才提到了，你反复的提到了几次，一个fork。嗯，如果说主进程。如果说子进程崩了怎么办？

19:46 说话人2

嗯，子进程崩了。嗯。

20:02 说话人2

（问懵了，其实可以用信号处理函数处理的，但是已经紧张想不起来了）我目前还不知道到底要怎么处理。

20:06 说话人1

那如果主进程崩了呢？

20:10 说话人2

主进程，嗯。

20:11 说话人1

主进程了会产生什么后果？嗯，然后应该怎么处理？

20:15 说话人2

主进程崩了，如果子进程不收尸的话，那就是。啊，孤儿进程。孤儿指定成孤儿，因为父亲进程崩溃了。

20:28 说话人1

有谁会接管他们吗？

20:29 说话人2

呃，会呃，linux下的话会有一个。呃。ID为0的进程吧，好像是，嗯。

20:37 说话人1

ID为0的进程，这个进程是谁呢？

20:40 说话人2

嗯。Systemd.我如果没记错的话。

20:45 说话人1

能确认吗？

20:47 说话人2

嗯，确认吧。

20:49 说话人1

嗯。

20:52 说话人1

看过一些linux下面这些书籍吧。

20:55 说话人2

对对。

20:56 说话人1

是不是看过这一些方面的一些资料对吧。

20:59 说话人2

嗯，看过一些。

21:06 说话人3（另一个面试官，开始拷打项目）

太。我看您有一个项目是基于任务流的网络框架，嗯，这个是从头到尾自己写的吗？

21:17 说话人2

嗯，对。

21:19 说话人3

这个写这个框架。是想解决什么问题啊？

21:24 说话人2

嗯，主要是学习Linux下的，它那个网络就是网络操作，包括数据的收发。嗯，因为如果是。单纯Linux加变长的话，就要用那个socket嘛。就是那个提供的系统调用啊，这个时候其实也挺麻烦的。啊，然后还需要处理他的。呃，各种各样的参数，然后有这个。啊，TCPDP啊，这种的还需要做区分。然后我就自己封装了一遍。嗯。

21:57 说话人3

那您这个框架，您觉得比较适合做哪一类的业务呀？

22:03 说话人2

（已经）

嗯。因为是基于任务流的啊，如果是确定性的任务的话，是可以嗯，使用这个框架的，就是。呃，它可以嗯，自己去设置任务的先后顺序，包括并行和串行。嗯，对对，设计好了之后，就可以让他直接呃，整个的所有任务一起执行。它就会按照顺序执行。嗯。

22:29 说话人3

能举个具体的例子吗？

22:31 说话人2

嗯。比如说，呃，就单纯的HTTP吧。嗯，如果我要使用HTP去传文件的话。呃，文文文件比较小，那么单个ATP应该就是可以实现，嗯，就是可以去把单个文件传上去啊。如果是文件比较大的话，还需要设计一段连续传。啊，那这个时候我就可以创建一个任务。啊然后啊当有请求，比如说他要上传文件的时候啊，我去接收它上传上来的文件，然后它还有断点续传啊，我需要去记录它当前传了多少。啊，这是啊一个任务。然后这个任务它嗯，由于它接收到网络了之后，它会创建一个就是封装好的任务，然后给上层。

23:20 说话人2

啊，然后上层往这个任务里面去添加逻辑。嗯，然后这个任务执行完成了之后，它会嗯可以设置另外一个任务，嗯，去接收下一个嗯，就是分片儿的文件。嗯，对。

23:39 说话人3

它和普通的上传文件上传的这种。请求应答式的区别在哪儿？

23:49 说话人2

（问懵了，胡言乱语中）

嗯。普通的文件上传的话，嗯，因为你是要接收数据的嘛。嗯，然后啊，你不知道这个文件，嗯，就是下一次它那个断点来是什么时候，然后嗯是能监听到的，但是嗯需要去不停的访问，就是呃上传之后这个断点的它这个信息啊，就是我肯定有一个变量要存在，现在存存嗯就是传了多少。啊，然后是哪个IP传的。那这个需要绑定的。啊，如果使用任务的话，那么这个呃任务本身它携带这些数据。啊就不需要去啊当然也是需要设置的。啊，就不需要去，呃，就是底层那么麻烦。

24:35 说话人3

负载均衡是怎么做的呀？

24:37 说话人2

啊负载均衡是啊。假如说我是server端，就是啊，我是客户端嘛，就是我连接了其他目标啊。我只能保证我这边到其他目标的这个连接数量是均衡的。嗯，就比如说百度吧，呃，如果是进行百度那个域名的解析的话，会解析到多个IP啊，这个时候我会啊平均分配这个连接数。啊，就是请求它的，呃，不同的I IP的那个连接数大致是均衡的。呃，底层如果要实现的话，大致就是。嗯，连接池，然后呃，每个连接的话，它有当前的连接数。嗯，然后会去均衡它。（这里连接池其实也是胡扯的，应该是负载均衡组，有对应的实现，太紧张已经开始胡言乱语了）

25:26 说话人3

我可以理解，这个框架的server端是可以部署多个的，是吧？

25:31 说话人2

嗯。（这里应该没听清）

25:32 说话人3

如果可以通过负载均衡到不同的server上。

25:37 说话人2

呃，Server端应该是只有一个的。就是如果你是就是。负载的话，只是说连接数量相对均衡的这种负载。

25:49 说话人2

只有一个server，他需要。

25:54 说话人2

呃。我是说，就是你作为客户端的时候，你去连其他的server，这个时候你可以嗯，尽可能的保证对，尽可能保证连接是均衡的。

26:08 说话人3

哦，您的意思是这个负载均衡是在客户端上。不是在这个server的

26:11 说话人2

对。

26:18 说话人3

缓存怎么做的？

26:20 说话人2

嗯，双向链表加一个map。就是链表里面，双向链表里面是有序的。嗯，就是。嗯，使用次数最多的应该是在前面，然后后面是使用次数最少的，或者说是啊，应该是最近的，最近使用的是链表头，然后一直没有使用的会靠近链表尾。啊，然后会有一个map去存，就是我当前的链表节点啊，它的对应的K和value。啊，如果我要获取K的话，那我就先去呃map里面找，找到这个节点之后返回，然后把它移到列表头。啊如果是删除的话，我就需要。

26:58 说话人2

嗯。嗯，正常来说应该是不需要删除。应该是我往里面塞数据的时候，我往缓存里面塞数据，那么缓存满了，这个时候我会把尾部删掉，然后往头部加。大致就是这样。

27:20 说话人3

看您下面提到了一个。Good with group.过读常用的几个API有哪几个？

27:33 说话人2

嗯。首先是创建的时候就是wait group, 然后呃，我需要常用的是wait()和done()，因为wait是等待done() 的话就是我初始化的时候不是给了一个int值嘛，就是说你比如说每个线程。嗯，每个线程都在结束的时候调用done()函数啊，这个时候就会奇数减1。所有线程都执行完了之后，计数数就归零了，那这个时候，Wait(), 嗯，就可以正常执行，否则的话，Wait, 就一直等一直等待。

28:09 说话人3

说一下future和promise。

28:18 说话人3

啥情况？

28:19 说话人2

嗯。?

这里正回答问题呢，突然短线了，还是我这边不知道原因，突然把麦和摄像头全给关了，面试官那边没问题，我能看到也能听到。但是他们看不到我，不知道啥情况。用的钉钉会议，可能是BUG。

然后我又手动打开了麦和摄像头。。。

28:24 说话人2

不知道，我不知道刚刚什么情况，突然就断了。和promise。

28:35 说话人2

嗯，也相当于一种消息传递吧。嗯，就是说我可以在promise里面。我通过promise获取到future，然后把这个promise传给呃需要用的线程。然后这个线程在合适的时机把变量值塞到promise里面，然后我在外面可以用future去get。然后获取到这个变量值。

29:01 说话人3

除了future和promise之外，如果我们想实现类似的机制，还有其他的办法吗？

29:08 说话人2

嗯。

29:12 说话人2

就是通过技术了。核心其实是技术。然后。嗯，就是wait down的时候就减一，wait时候加一嘛。

29:29 说话人3

要考虑线程安全吗？

29:32 说话人2

呃，当然是需要考虑线程安全的。

29:38 说话人2

怎么做呢？呃。枷锁，嗯，或者是原子操作。

29:47 说话人3

能具体说过吗？怎么加锁原子操作怎么？

29:51 说话人2

嗯，如果是加锁的话，嗯，因为你假设说我调用了done()，就表示我要计数减1啊，这个时候我应该让那个内部的计数器减1。就嗯，减1的时候肯定是要加锁的。呃，然后。嗯。嗯。初始化的时候，我应该是给了一个初始值。嗯，那wait()的时候就是呃，一直去读取这个计数器的值，然后如果归零的话，就可以继续执行。

30:24 说话人3

你刚提到一直读取这个值，是需要一直占用CPU去循环吗？

30:29 说话人2

嗯。可以用条件变量去。呃，间接的唤醒就是。哦是我去读的时候，我去看它等不等于0，如果不等于0的话，这个时候先。呃，睡眠，然后，嗯，我done() 的时候可以用条件变量去通知这个wait嘛

30:58 说话人3

如果我们要看一个mysql 查询语句的执行计划。（可能是因为简历上写了mysql事务，所以才会这么问）

31:05 说话人2

查询的执行计划。呃，是查询语句对吗？嗯，这个我还没操作过。

31:16 说话人3

MYSQL常见的存储引擎有哪些？

31:20 说话人2

嗯。用过的有InnoDB，然后其他的我还没过。

31:37 说话人3

可是在买斯库里我们希望实现。如果。再见。存在则更新组件存在的数据，不存在则插入用什么一块。

31:51 说话人2

嗯。不存在则插入，存在的话需要更新。Update.?

32:11 说话人3

redis持久化的方式有几种？

32:14 说话人2

嗯。有一个定时的持久化，还有一个是。嗯，具体的名字我不记得了，还有一个，嗯。

32:26 说话人2

嗯，好像是会先存到内存里面，然后再从内存里面啊往磁盘里面去写啊还有一种嗯，混合的就是两种方式一起用。

32:38 说话人3

Redis的集成方案有了解过吗？有哪些啊？

32:43 说话人2

嗯。

32:48 说话人2

具体的我还没有了解过。主要是没有自己部署。

32:55 说话人3

就是我看您有个性能测试，大概是18000加的Q，PS, 这是测的是纯。嗯。

33:05 说话人2

对。HTTP.

33:08 说话人3

对。

33:13 说话人3

12、线程是指服务器有12个处理线程还是有12个客户端线程？嗯。

33:20 说话人2

我是在自己电脑上测，就是起了个服务器，然后再用WRK去测啊。我自己的电脑是6核12线程的。

33:29 说话人3

这个是这个框架的性能的极限了吗？

33:33 说话人2

嗯，目前我测的应该是性能的极限了。

33:36 说话人3

有些分析为什么只能到一个。

33:40 说话人2

呃，还没有分析过。

33:46 说话人3

如果只是单纯本机的请求，应答应该不止一万八吧？

33:51 说话人2

嗯。我因为我只有一台电脑，所以还没有办法分开测。

33:56 说话人3

电脑配置是六核心八GB？

33:56 说话人2

对（其实是6核12线程，面成这样，已经无力反驳了）

34:04 说话人3

行，我的问题差不多了，您有什么想了解或者想问的吗？

34:07 说话人2

嗯，一共是有几面？一共一共几次面试？

34:15 说话人3

3次吧，3次分应该。

34:17 说话人2

那其他的我就没有想要了解了。

34:21 说话人3

那没有其他的，咱今天就先到这儿。

34:24 说话人2

好的。

34:25 说话人3

嗯，好行谢谢，好拜拜拜拜。

34:31 说话人2

拜拜。

挂断会议后：哎。老实了，被问蒙了，老实了。