常见C++面试问题总结1

来源:互联网 发布:世界十大网络病毒 编辑:程序博客网 时间:2024/03/28 20:33

转自http://blog.csdn.net/fly_yr/article/details/51912667

【1】同步通信和异步通信的区别?

(1)同步通信要求接收端时钟频率和发送端时钟频率一致,发送端发送连续的比特流;异步通信时不要求接收端时钟和发送端时钟同步,发送端发送完一个字节后,可经过任意长的时间间隔再发送下一个字节。

(2)同步通信效率高;异步通信效率低。

(3)同步通信较复杂,双方时钟的允许误差较小;异步通信简单,双方时钟可允许一定误差。


【2】TCP协议的作用?三次握手通过什么方法保证通信双方确认的正确?


       TCP提供的可靠数据传输服务是依靠接收端TCP软件按序号对收到的数据分组进行逐一确认实现的。这个过程在TCP收发端开始通信时,被称为三次握手初化。

三次握手过程:

第一次握手:client端首先向server端发送一个SYN包,值为1。这是第一个封包,告知server端client端想与server建立TCP连接;

第二次握手:server端接收到client端发送的SYN包后,会回复一个SYN/ACK包,SYN值加1,ACK值随机产生。告知client端server端已收到client端发送的SYN包;

第三次握手:client端收到server端答复的SYN/ACk包后,又会回复一个ACK,ACK值是server端发送来的SYN/ACK包中的ACK值加1。告知server端client端已收到SYN/ACK包。到此为止,三次握手完成,client端和server端可以开始传送数据。

四次挥手过程:

断开TCP连接,要传送四个封包。比建立TCP连接时多了一次。主要原因是,断开TCP连接是在client端和server端分别发生的。

例设第一个封包由client端发送,则client端会发送一个FIN封包,值为1。告知server端client端要结束连接。

server端收到client端发送的FIN包后,知道client端已完成数据的传送要请求断开TCP连接。server端会发送一个ACK包给client端。告知client端server端已知道正常收到FIN包。

server端把未传送完的数据传送给client端后,也会给client端发送一个FIN,告知client端server端已完成数据传送,可以断开TCP连接。

client端收到server端发送的FIN封包后,会向server端回复一个ACK包,表示已确认server端的FIN封包。至此,TCP连接断开。

 

【3】操作系统执行可执行程序时,内存分配是怎样的?


一个由C/C++编译的程序占用的内存分为以下几个部分:

(1)栈区,由编译器自动分配释放,存放函数的参数值,局部变量的值等。其操作方法类似于数据结构中的栈。

(2)堆区,一般由程序员分配和释放,若程序员不释放,程序结束时可能由OS回收。注意,它和数据结构中的堆是两回事,分配方式倒是类似于链表。

(3)全局区(静态区),全局变量和静态变量的存储是放在一块的,初始化的全局变量和静态变量在一块区域,未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。程序结束后由系统释放。

(4)文字常量区,常量字符串都存放这里,程序结束后由系统释放。

(5)程序代码区,存放函数体的二进制代码。


【4】重载和覆盖的区别是什么?


(1)方法的覆盖是子类和父类之间的关系,是垂直关系。方法的重载是同一个类中方法之间的关系,是水平关系。

(2)覆盖只能由一个方法,或只能由一对方法产生关系;方法的重载是多个方法之间的关系。

(3)覆盖要求参数列表相同,重载要求参数列表不同。

(4)覆盖关系中,调用那个方法体,是根据对象的类型(对象对应存储空间类型)来决定;重载关系是根据调用时的实参表与形参表来选择方法体的。


【5】数据库的读脏数据,存放数据库的磁盘出现灾难性事故,有什么方法可以避免?


       使用并发控制技术的封锁技术可以避免读数据的不一致。

 

【6】Windows编程中,消息机制如何实现?


自定义消息一共分为三步,

(1)自定义消息:#define WM_MYMSGWM_USER+ 1

(2)在头文件中声明函数:afx_msgvoid myMsg();

(3)在消息映射中添加对应关系:ON_MESSAGE(WM_MYMSG,onMyMsg);

核心:函数原型、关联消息与消息响应函数的宏、函数实现。

 

【7】写一个病毒。


       while(1)  { int *p = new int[10000000];  } 


【8】两个数相乘,小数点后位数没有限制,请写一个高精度算法。


~~~

【9】找出1-10w中没有出现的两个数字。


(1)位图,申请10w个bit的空间,每个bit代表一个数字是否出现过。开始时将这10w个bit都初始化为0,表示所有数字都没有出现过。然后依次读入已经打乱循序的数字,并将对应的bit设为1。当处理完所有数字后,根据为0的bit得出没有出现的数字。

(2)首先计算1到10w的和,平方和。然后计算给定数字的和,平方和。两次的到的数字相减,可以得到这两个数字的和,平方和。所以我们有x + y = n  x^2 + y^2 = m  解方程可以得到x和y的值。


【10】需要多少只小白鼠才能在24小时内找到毒药有1000瓶水,其中有一瓶有毒,小白鼠只要尝一点带毒的水24小时后就会死亡,至少要多少只小白鼠才能在24小时时鉴别出那瓶水有毒?


       最容易想到的就是用1000只小白鼠,每只喝一瓶。但显然这不是最好答案。既然每只小白鼠喝一瓶不是最好答案,那就应该每只小白鼠喝多瓶。那每只应该喝多少瓶呢?首先让我们换种问法,如果x小白鼠,那么24小时内可以从多少瓶水中找出那瓶有毒的?由于每只小白鼠都只有死或者活这两种结果,所以x只小白鼠最大可以表示2^x种结果。如 果让每种结果都对应到某瓶水有毒,那么也就可以从2^x瓶水中找到有毒的那瓶水。那如何来实现这种对应关系呢? 第一只小白鼠喝第1到2^(x-1)瓶,第二只小白鼠喝第1到第2^(x-2)和第2^(x-1)+1到第2^(x-1) + 2^(x-2)瓶。。。。以此类推。回到此题,总过1000瓶水,所以需要最少10只小白鼠。

 

【11】判断数字是否出现在40亿个数中?给40亿个不重复的unsignedint的整数,没排过序的,然后再给几个数,如何快速判断这几个数是否在那40亿个数当中?


       unsignedint 的取值范围是0到2^32-1。我们可以申请连续的2^32/8=512M的内存,用每一个bit对应一个unsigned int数字。首先将512M内存都初始化为0,然后每处理一个数字就将其对应的bit设置为1。当需要查询时,直接找到对应bit,看其值是0还是1即可。


【12】两个整数集合A和B,求其交集两个整数集合A和B,求其交集。


(1)读取整数集合A中的整数,将读到的整数插入到map中,并将对应的值设为1。

(2)读取整数集合B中的整数,如果该整数在map中并且值为1,则将此数加入到交集当中,并将在map中的对应值改为2。通过更改map中的值,避免了将同样的值输出两次。


【13】从10G个数中找到中数 在一个文件中有10G 个整数,乱序排列,要求找出中位数。内存限制为2G。


       不妨假设10G个整数是64bit的。 2G内存可以存放256M个64bit整数。我们可以将64bit的整数空间平均分成256M个取值范围,用2G的内存对每个取值范围内出现整数个数进行统计。这样遍历一边10G整数后,我们便知道中数在那个范围内出现,以及这个范围内总共出现了多少个整数。如果中数所在范围出现的整数比较少,我们就可以对这个范围内的整数进行排序,找到中数。如果这个范围内出现的整数比较多,我们还可以采用同样的方法将此范围再次分成多个更小的范围(256M=2^28,所以最多需要3次就可以将此范围缩小到1,也就找到了中数)。


【14】统计论坛在线人数分布。求一个论坛的在线人数,假设有一个论坛,其注册ID有两亿个,每个ID从登陆到退出会向一个日志文件中记下登陆时间和退出时间,要求写一个算法统计一天中论坛的用户在线分布,取样粒度为秒。


       一天总共有3600*24 = 86400秒。定义一个长度为86400的整数数组int delta[86400],每个整数对应这一秒的人数变化值,可能为正也可能为负。开始时将数组元素都初始化为0。然后依次读入每个用户的登录时间和退出时间,将与登录时间对应的整数值加1,将与退  出时间对应的整数值减1。

这样处理一遍后数组中存储了每秒中的人数变化情况。

      定义另外一个长度为86400的整数数组int online_num[86400],每个整数对应这一秒的论坛在线人数。

假设一天开始时论坛在线人数为0,则第1秒的人数online_num[0] = delta[0]。第n+1秒的

人数online_num[n]= online_num[n-1] + delta[n]。

      这样我们就获得了一天中任意时间的在线人数。


【15】用UDP协议通讯时怎样得知目标机是否获得了数据包用UDP协议通讯时怎样得知目标机是否获得了数据包?


       可以在每个数据包中插入一个唯一的ID,比如timestamp或者递增的int。发送方在发送数据时将此ID和发送时间记录在本地。

接收方在收到数据后将ID再发给发送方作为回应。发送方如果收到回应,则知道接收方已经收到相应的数据包;如果在指定时间内没有收到回应,则数据包可能丢失,需要重复上面的过程重新发送一次,直到确定对方收到。

 

【16】栈(stack)和堆(heap)具体的区别。


(1)在申请方式上,

栈(stack):现在很多人都称之为堆栈,这个时候实际上还是指的栈。它由编译器自动管理,无需我们手工控制。 例如,声明函数中的一个局部变量int b 系统自动在栈中为b开辟空间;在调用一个函数时,系统自动的给函数的形参变量在栈中开辟空间。

堆(heap): 申请和释放由程序员控制,并指明大小。容易产生memory leak。

在C中使用malloc函数。

如:p1 = (char *)malloc(10);

在C++中用new运算符。

如:p2 = new char[20];//(char *)malloc(10);

但是注意p1本身在全局区,而p2本身是在栈中的,只是它们指向的空间是在堆中

(2)申请后系统的响应上,

栈(stack):只要栈的剩余空间大于所申请空间,系统将为程序提供内存,否则将报异常提示栈溢出。

堆(heap): 首先应该知道操作系统有一个记录空闲内存地址的链表,当系统收到程序的申请时,会遍历该链表,寻找第一个空间大于所申请空间的堆结点,然后将该结点从空闲结点链表中删除,并将该结点的空间分配给程序。另外,对于大多数系统,会在这块内存空间中的首地址处记录本次分配的大小,这样,代码中的delete或free语句才能正确的释放本内存空间。另外,由于找到的堆结点的大小不一定正好等于申请的大小,系统会自动的将多余的那部分重新放入空闲链表中。

(3)申请大小的限制

栈(stack):在Windows下,栈是由高向低地址扩展的数据结构,是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的,在WINDOWS下,栈的大小是2M(也有的说是1M,总之是一个编译时就确定的常数),如果申请的空间超过栈的剩余空间时,将提示overflow。因此,能从栈获得的空间较小。例如,在VC6下面,默认的栈空间大小是1M(好像是,记不清楚了)。当然,我们可以修改:打开工程,依次操作菜单如下:Project->Setting->Link,在Category 中选中Output,然后在Reserve中设定堆栈的最大值和commit。

注意:reserve最小值为4Byte;commit是保留在虚拟内存的页文件里面,它设置的较大会使栈开辟较大的值,可能增加内存的开销和启动时间。

堆(heap): 堆是向高地址扩展的数据结构,是不连续的内存区域(空闲部分用链表串联起来)。正是由于系统是用链表来存储空闲内存,自然是不连续的,而链表的遍历方向是由低地址向高地址。一般来讲在32位系统下,堆内存可以达到4G的空间,从这个角度来看堆内存几乎是没有什么限制的。由此可见,堆获得的空间比较灵活,也比较大。

(4)分配空间的效率上

栈(stack):栈是机器系统提供的数据结构,计算机会在底层对栈提供支持:分配专门的寄存器存放栈的地址,压栈出栈都有专门的指令执行,这就决定了栈的效率比较高。但程序员无法对其进行控制。

堆(heap):是C/C++函数库提供的,由new或malloc分配的内存,一般速度比较慢,而且容易产生内存碎片。它的机制是很复杂的,例如为了分配一块内存,库函数会按照一定的算法(具体的算法可以参考数据结构/操作系统)在堆内存中搜索可用的足够大小的空间,如果没有足够大小的空间(可能是由于内存碎片太多),就有可能调用系统功能去增加程序数据段的内存空间,这样就有机会分到足够大小的内存,然后进行返回。这样可能引发用户态和核心态的切换,内存的申请,代价变得更加昂贵。显然,堆的效率比栈要低得多。

(5)堆和栈中的存储内容

栈(stack):在函数调用时,第一个进栈的是主函数中子函数调用后的下一条指令(子函数调用语句的下一条可执行语句)的地址,然后是子函数的各个形参。在大多数的C编译器中,参数是由右往左入栈的,然后是子函数中的局部变量。注意:静态变量是不入栈的。 当本次函数调用结束后,局部变量先出栈,然后是参数,最后栈顶指针指向最开始存的地址,也就是主函数中子函数调用完成的下一条指令,程序由该点继续运行。

堆(heap):一般是在堆的头部用一个字节存放堆的大小,堆中的具体内容有程序员安排。

(6)存取效率的比较

这个应该是显而易见的。拿栈上的数组和堆上的数组来说:

void main()

{

   int arr[5]={1,2,3,4,5};

   int *arr1;

   arr1=new int[5];

   for (int j=0;j<=4;j++)

   {

   arr1[j]=j+6;

   }

   int a=arr[1];

   int b=arr1[1];

}

上面代码中,arr1(局部变量)是在栈中,但是指向的空间确在堆上,两者的存取效率,当然是arr高。因为arr[1]可以直接访问,但是访问arr1[1],首先要访问数组的起始地址arr1,然后才能访问到arr1[1]。


【17】写string类的构造,析构,拷贝函数


class String

{

public:

       String(const char* str = NULL)      //构造函数

       {

              if (str == NULL)

              {

                     m_data = new char[1];  //即使为空字符串也有一个‘\0’

                     m_data = '\0';

              }

              else

              {

                     int length = strlen(str);

                     m_data = new char[length + 1];

                     strcpy(m_data, str);

              }

       }

       ~String()

       {

              delete[] m_data;

       }

       String(const String& other)

       {

              int length = strlen(other.m_data);

              m_data = new char[length + 1];

              strcpy(m_data, other.m_data);

       }

       String& operator=(const String& other)

       {

              if (this == &other)  //防止自复制

              {

                     return *this;

              }

              delete[] m_data;  //释放原有资源

              int length = strlen(other.m_data);

              m_data = new char[length + 1]; //加分点:对m_data加NULL 判断

              strcpy(m_data, other.m_data);

              return *this; //得分点:返回本对象的引用 

       }

private:

       char* m_data;

};

 

【18】Linux和OS


netstat :显示网络状态 

tcpdump:主要是截获通过本机网络接口的数据,用以分析。能够截获当前所有通过本机网卡的数据包。它拥有灵活的过滤机制,可以确保得到想要的数据。

ipcs:检查系统上共享内存的分配

ipcrm:手动解除系统上共享内存的分配

cpu 内存 硬盘 等等与系统性能调试相关的命令必须熟练掌握,设置修改权限 tcp网络状态查看 各进程状态 抓包相关等相关命令 必须熟练掌握 awk sed需掌握。


【19】共享内存的使用实现原理(共享内存段被映射进进程空间之后,存在于进程空间的什么位置?共享内存段最大限制是多少?)


共享内存定义:共享内存是最快的可用IPC(进程间通信)形式。它允许多个不相关的进程去访问同一部分逻辑内存。共享内存是由IPC为一个进程创建的一个特殊的地址范围,它将出现在进程的地址空间中。其他进程可以把同一段共享内存段“连接到”它们自己的地址空间里去。所有进程都可以访问共享内存中的地址。如果一个进程向这段共享内存写了数据,所做的改动会立刻被有访问同一段共享内存的其他进程看到。因此共享内存对于数据的传输是非常高效的。

共享内存的原理:共享内存是最有用的进程间通信方式之一,也是最快的IPC形式。两个不同进程A、B共享内存的意思是,同一块物理内存被映射到进程A、B各自的进程地址空间。进程A可以即时看到进程B对共享内存中数据的更新,反之亦然。C++进程内存空间分布(注意各部分的内存地址谁高谁低,注意栈从高到低分配,堆从低到高分配)。


【20】ELF是什么?其大小与程序中全局变量的是否初始化有什么关系(注意未初始化的数据放在bss段)

 

可执行文件:包含了代码和数据。具有可执行的程序。 

可重定位文件:包含了代码和数据(这些数据是和其他重定位文件和共享的  object文件一起连接时使用的) 

共享object文件(又可叫做共享库):包含了代码和数据(这些数据是在连接  时候被连接器ld和运行时动态连接器使用的)。 

使创建共享库容易,使动态装载和共享库的结合更加容易。在ELF下,在C++  中,全局的构造函数和析构函数在共享库和静态库中用同样方法处理。


【21】如何定位内存泄漏?


内存泄漏是指堆内存的泄漏。堆内存是指程序从堆中分配的、大小任意的(内存块的大小可以在程序运行期决定)、使用完后必须显示释放的内存。应用程序一般使用malloc、realloc、new等函数从堆中分配到一块内存,使用完后,程序必须负责相应的调用free或delete释放该内存块。否则,这块内存就不能被再次使用,我们就说这块内存泄漏了。  

C++程序缺乏相应的手段来检测内存信息,只能使用top指令观察进程的动态内存总额。而且程序退出时,我们无法获知任何内存泄漏信息 

使用Linux命令回收内存,可以使用ps、kill两个命令检测内存使用情况和进行回收。在使用超级用户权限时使用命令“ps”,它会列出所有正在运行的程序名称和对应的进程号(PID)。kill命令的工作原理是向linux操作系统的内核送出一个系统操作信号和程序的进程号(PID)。


【22】动态链接和静态链接的区别?


动态链接是指在生成可执行文件时不将所有程序用到的函数链接到一个文件,因为有许多函数在操作系统带的dll文件中,当程序运行时直接从操作系统中找。 而静态链接就是把所有用到的函数全部链接到exe文件中。 动态链接是只建立一个引用的接口,而真正的代码和数据存放在另外的可执行模块中,在运行时再装入;而静态链接是把所有的代码和数据都复制到本模块中,运行时就不再需要库了。


【23】多进程和多线程的区别?


必须从cpu调度,上下文切换,数据共享,多核cup利用率,资源占用,等等各方面回答,然后有一个问题必须会被问到:哪些东西是一个线程私有的?答案中必须包含寄存器,否则悲催。}

程序是指令的集合,进程是程序的真正执行,进程是系统进行资源调度和分配的基本单位;线程是CPU调度和分派的基本单位,也称为轻量级进程。

同一进程中的多个线程共享该线程的全部系统资源,如堆、虚拟地址空间、文件描述符和信号等,但是线程私有栈和寄存器。

在多核和多CPU,在多核或多CPU,或支持Hyper-threading的CPU上使用多线程程序设计的好处是显而易见,即提高了程序的执行吞吐率。在单CPU单核的计算机上,使用多线程技术,也可以把进程中负责IO处理、人机交互而常备阻塞的部分与密集计算的部分分开来执行,编写专门的workhorse线程执行密集计算,从而提高了程序的执行效率。

进程是资源分配的最小单位,线程是CPU调度的基本单位。线程和进程的区别在于多进程之间有不同的代码和数据空间,而多线程之间共享数据空间,有独立的栈和寄存器,为其执行上下文。

多进程: 进程是程序在计算机上的一次执行活动。当你运行一个程序,你就启动了一个进程。显然,程序是死的(静态的),进程是活的(动态的)。进程可以分为系统进程和用户进程。凡是用于完成操作系统的各种功能的进程就是系统进程,它们就是处于运行状态下的操作系统本身;所有由用户启动的进程都是用户进程。进程是操作系统进行资源分配的单位。 进程又被细化为线程,也就是一个进程下有多个能独立运行的更小的单位。在同一个时间里,同一个计算机系统中如果允许两个或两个以上的进程处于运行状态,这便是多任务。现代的操作系统几乎都是多任务操作系统,能够同时管理多个进程的运行。多任务带来的好处是明显的,比如你可以边听mp3边上网,与此同时甚至可以将下载的文档打印出来,而这些任务之间丝毫不会相互干扰。那么这里就涉及到并行的问题,俗话说,一心不能二用,这对计算机也一样,原则上一个CPU只能分配给一个进程,以便运行这个进程。我们通常使用的计算机中只有一个CPU,也就是说只有一颗心,要让它一心多用,同时运行多个进程,就必须使用并发技术。实现并发技术相当复杂,最容易理解的是“时间片轮转进程调度算法”,它的思想简单介绍如下:在操作系统的管理下,所有正在运行的进程轮流使用CPU,每个进程允许占用CPU的时间非常短(比如10毫秒),这样用户根本感觉不出来 CPU是在轮流为多个进程服务,就好象所有的进程都在不间断地运行一样。但实际上在任何一个时间内有且仅有一个进程占有CPU。 如果一台计算机有多个CPU,情况就不同了,如果进程数小于CPU数,则不同的进程可以分配给不同的CPU来运行,这样,多个进程就是真正同时运行的,这便是并行。但如果进程数大于CPU数,则仍然需要使用并发技术。 进行CPU分配是以线程为单位的,一个进程可能由多个线程组成,这时情况更加复杂,但简单地说,有如下关系:

总线程数<= CPU数量:并行运行

总线程数> CPU数量:并发运行

并行运行的效率显然高于并发运行,所以在多CPU的计算机中,多任务的效率比较高。但是,在多CPU计算中只运行一个进程(线程),不能发挥CPU的优势。一个采用了多线程技术的应用程序可以更好地利用系统资源。其主要优势在于充分利用了CPU的空闲时间片,可以用尽可能少的时间来对用户的要求做出响应,使得进程的整体运行效率得到较大提高,同时增强了应用程序的灵活性。更为重要的是,由于同一进程的所有线程是共享同一内存,所以不需要特殊的数据传送机制,不需要建立共享存储区或共享文件,从而使得不同任务之间的协调操作与运行、数据的交互、资源的分配等问题更加易于解决。

进程间通信(IPC,Inter-Process Communication),指至少两个进程间传送数据或信号的一些技术或方法。进程是计算机系统分配资源的最小单位。每个进程都有自己的一部分独立的系统资源,彼此是隔离的。为了能使不同的进程互相访问资源并进行协调工作,才有了进程间通信。这些进程可以运行在同一计算机上或网络连接的不同计算机上。

进程间通信技术包括消息传递、同步、共享内存和远程过程调用。IPC是一种标准的Unix通信机制。

============================================

进程优点:编程、调试简单,可靠性较高。

进程缺点:创建、销毁、切换速度慢,内存、资源占用大。

线程优点:创建、销毁、切换速度快,内存、资源占用小。

线程缺点:编程、调试复杂,可靠性较差。

============================================

进程的优点:

1)顺序程序的特点:具有封闭性和可再现性;

2)程序的并发执行和资源共享。多道程序设计出现后,实现了程序的并发执行和资源共享,提高了系统的效率和系统的资源利用率。

进程的缺点:

操作系统调度切换多个线程要比切换调度进程在速度上快的多。而且进程间内存无法共享,通讯也比较麻烦。

线程之间由于共享进程内存空间,所以交换数据非常方便;在创建或撤消进程时,由于系统都要为之分配和回收资源,导致系统的开销明显大于创建或撤消线程时的开销。

 

线程的优点:

1)它是一种非常"节俭"的多任务操作方式。在Linux系统下,启动一个新的进程必须分配给它独立的地址空间,建立众多的数据表来维护它的代码段、堆栈段和数据段,这是一种"昂贵"的多任务工作方式。而运行于一个进程中的多个线程,它们彼此之间使用相同的地址空间,共享大部分数据,启动一个线程所花费的空间远远小于启动一个进程所花费的空间,而且,线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。当然,在具体的系统上,这个数据可能会有较大的区别;

2)线程间方便的通信机制,由于同一进程下的线程之间共享数据空间,所以一个线程的数据可以直接为其它线程所用,这不仅快捷,而且方便;

3)使多CPU系统更加有效。操作系统会保证当线程数不大于CPU数目时,不同的线程运行于不同的CPU上;

4)改善程序结构。一个既长又复杂的进程可以考虑分为多个线程,成为几个独立或半独立的运行部分,这样的程序会利于理解和修改。

线程的缺点:

1)调度时, 要保存线程状态,频繁调度, 需要占用大量的机时;

2)程序设计上容易出错(线程同步问题)。

============================================

多线程的优点:

无需跨进程边界;

程序逻辑和控制方式简单;

所有线程可以直接共享内存和变量等;

线程方式消耗的总资源比进程方式好;

多线程缺点:

每个线程与主程序共用地址空间,受限于2GB地址空间;

线程之间的同步和加锁控制比较麻烦;

一个线程的崩溃可能影响到整个程序的稳定性;

到达一定的线程数程度后,即使再增加CPU也无法提高性能,例如Windows Server 2003,大约是1500个左右的线程数就快到极限了(线程堆栈设定为1M),如果设定线程堆栈为2M,还达不到1500个线程总数;

线程能够提高的总性能有限,而且线程多了之后,线程本身的调度也是一个麻烦事儿,需要消耗较多的CPU

 

多进程优点:

每个进程互相独立,不影响主程序的稳定性,子进程崩溃没关系;

通过增加CPU,就可以容易扩充性能;

可以尽量减少线程加锁/解锁的影响,极大提高性能,就算是线程运行的模块算法效率低也没关系;

每个子进程都有2GB地址空间和相关资源,总体能够达到的性能上限非常大

多进程缺点:

逻辑控制复杂,需要和主程序交互;

需要跨进程边界,如果有大数据量传送,就不太好,适合小数据量传送、密集运算

多进程调度开销比较大;

最好是多进程和多线程结合,即根据实际的需要,每个CPU开启一个子进程,这个子进程开启多线程可以为若干同类型的数据进行处理。当然你也可以利用多线程+多CPU+轮询方式来解决问题……

方法和手段是多样的,关键是自己看起来实现方便有能够满足要求,代价也合适。

 

【24】列出常见的信号,信号怎么处理?


信号(Signals )是Unix系统中使用的最古老的进程间通信的方法之一。操作系统通过信号来通知进程系统中发生了某种预先规定好的事件(一组事件中的一个),它也是用户进程之间通信和同步的一种原始机制。一个键盘中断或者一个错误条件(比如进程试图访问它的虚拟内存中不存在的位置等)都有可能产生一个信号。Shell也使用信号向它的子进程发送作业控制信号。

信号是在Unix SystemV中首先引入的,它实现了15种信号,但很不可靠。BSD4.2解决了其中的许多问题,而在BSD4.3中进一步加强和改善了信号机制。但两者的接口不完全兼容。在Posix1003.1标准中做了一些强行规定,它定义了一个标准的信号接口,但没有规定接口的实现。目前几乎所有的Unix变种都提供了和Posix标准兼容的信号实现机制。

在 Linux 中,信号的种类和数目与硬件平台有关。内核用一个字代表所有的信号,每个信号占一位,因此一个字的位数就是系统可以支持的最多信号种类数。i386 平台上有32 种信号,而AlphaAXP 平台上最多可有 64 种信号。系统中有一组定义好的信号,它们可以由内核产生,也可以由系统中其它有权限的进程产生。可以使用kill命令列出系统中的信号集。

下面是几个常见的信号。

SIGHUP: 从终端上发出的结束信号;

SIGINT: 来自键盘的中断信号(Ctrl-C);

SIGQUIT:来自键盘的退出信号(Ctrl-\);

SIGFPE: 浮点异常信号(例如浮点运算溢出);

SIGKILL:该信号结束接收信号的进程;

SIGALRM:进程的定时器到期时,发送该信号;

SIGTERM:kill 命令发出的信号;

SIGCHLD:标识子进程停止或结束的信号;

SIGSTOP:来自键盘(Ctrl-Z)或调试程序的停止执行信号;


【25】说出你所知道的linux系统的各类同步机制(重点),什么是死锁?如何避免死锁?


死锁的条件。

1、互斥条件(Mutual exclusion):资源不能被共享,只能由一个进程使用。

2、请求与保持条件(Hold and wait):已经得到资源的进程可以再次申请新的资源。

3、非剥夺条件(No pre-emption):已经分配的资源不能从相应的进程中被强制地剥夺。4、循环等待条件(Circular wait):系统中若干进程组成环路,该环路中每个进程都在等待相邻进程正占用的资源。

处理死锁的策略:

1、忽略该问题。例如鸵鸟算法,该算法可以应用在极少发生死锁的的情况下。为什么叫鸵鸟算法呢,因为传说中鸵鸟看到危险就把头埋在地底下,可能鸵鸟觉得看不到危险也就没危险了吧。跟掩耳盗铃有点像。

2、检测死锁并且恢复。

3、仔细地对资源进行动态分配,以避免死锁。

4、通过破除死锁四个必要条件之一,来防止死锁产生。


【26】exit()与_exit()的区别?


_exit终止调用进程,但不关闭文件,不清除输出缓存,也不调用出口函数。

exit函数将终止调用进程。在退出程序之前,所有文件关闭,缓冲输出内容将刷新定义,并调用所有已刷新的“出口函数”(由atexit定义)。 

exit()与_exit()有不少区别在使用fork(),特别是vfork()时变得很突出。

exit()与_exit()的基本区别在于前一个调用实施与调用库里用户状态结构(user-mode constructs)有关的清除工作(clean-up),而且调用用户自定义的清除程序。


【27】守护进程?


守护进程(Daemon)是运行在后台的一种特殊进程。它独立于控制终端并且周期性地执行某种任务或等待处理某些发生的事件。守护进程是一种很有用的进程。它常常在系统引导装入时开始,仅在系统关闭时终止。

Linux的大多数服务器就是用守护进程实现的。比如,Internet服务器inetd,Web服务器httpd等。同时,守护进程完成许多系统任务。比如,作业规划进程crond,打印进程lpd等。大多数守护进程都以超级用户(root)特权运行,所有守护进程都没有控制终端,其中端名设置为问号。

守护进程最重要的特性是后台运行。在这一点上DOS下的常驻内存程序TSR与之相似。其次,守护进程必须与其运行前的环境隔离开来。这些环境包括未关闭的文件描述符,控制终端,会话和进程组,工作目录以及文件创建掩模等。这些环境通常是守护进程从执行它的父进程(特别是shell)中继承下来的。最后,守护进程的启动方式有其特殊之处。它可以在Linux系统启动时从启动脚本/etc/rc.d中启动,可以由作业规划进程crond启动,还可以由用户终端(shell)执行。 

总之,除开这些特殊性以外,守护进程与普通进程基本上没有什么区别。因此,编写守护进程实际上是把一个普通进程按照上述的守护进程的特性改造成为守护进程。


【28】Linux的内存管理机制?


Linux虚拟内存的实现需要6种机制的支持:地址映射机制、内存分配回收机制、缓存和刷新机制、请求页机制、交换机制和内存共享机制 。

内存管理程序通过映射机制把用户程序的逻辑地址映射到物理地址。当用户程序运行时,如果发现程序中要用的虚地址没有对应的物理内存,就发出了请求页要求。如果有空闲的内存可供分配,就请求分配内存(于是用到了内存的分配和回收),并把正在使用的物理页记录在缓存中(使用了缓存机制)。如果没有足够的内存可供分配,那么就调用交换机制;腾出一部分内存。另外,在地址映射中要通过TLB(翻译后援存储器)来寻找物理页;交换机制中也要用到交换缓存,并且把物理页内容交换到交换文件中,也要修改页表来映射文件地址。


【29】Linux的任务调度机制?


 

 

【30】标准库函数和系统调用的区别?


内核的接口被称为系统调用,各种UNIX实现都提供良好定义、数量有限、直接进入内核的入口点,这些入口点称为系统调用。公共函数库构建在系统调用之上,应用程序即可使用公共函数库,也可使用系统调用。

1、系统调用和库函数的关系 

系统调用通过软中断int 0x80从用户态进入内核态。 函数库中的某些函数调用了系统调用。函数库中的函数可以没有调用系统调用,也可以调用多个系统调用。 编程人员可以通过函数库调用系统调用。 

高级编程也可以直接采用int 0x80进入系统调用,而不必通过函数库作为中介。 如果是在核心编程,也可以通过int 0x80进入系统调用,此时不能使用函数库。因为函数库中的函数是内核访问不到的。  

应用程序即可以调用系统调用也可以调用库函数。很多库函数则会调用系统调用。

两者区别,举例如下图所示:

另一个区别,系统调用通常提供一种最小接口,而库函数则提供比较复杂的功能。如,进程控制系统调用(fork、exec、wait)通常由用户应用程序直接调用。

2、从用户调用库函数到系统调用执行的流程。 

1) 假设用户调用ssize_t write (int fields, cont void *buff, size_t nbytes);库函数。

2) 库函数会执行int 0x80中断。因为中断使得进程从用户态进入内核态,所以参数通过寄存器传送。 

3) 0x80中断对应的中断例程被称为system call handler。其工作是:

i.  存储大多数寄存器到内核堆栈中。这是汇编代码写的。 

ii.  执行真正的系统调用函数――system call service routine。这是C代码。  

iii. 通过ret_from_sys_call ()返回,回到用户态的库函数。这是汇编代码。 

 

1、系统调用 

系统调用提供的函数如open, close, read, write, ioctl等,需包含头文件unistd.h。以write为例:其函数原型为 size_t write(int fd, const void *buf, size_t nbytes),其操作对象为文件描述符或文件句柄fd(file descriptor),要想写一个文件,必须先以可写权限用open系统调用打开一个文件,获得所打开文件的fd,例如 fd=open(/"/dev/video/", O_RDWR)。fd是一个整型值,每新打开一个文件,所获得的fd为当前最大fd加1。Linux系统默认分配了3个文件描述符值:0-standard input,1-standard output,2-standard error。 系统调用通常用于底层文件访问(low-level file access),例如在驱动程序中对设备文件的直接访问。 

系统调用是操作系统相关的,因此一般没有跨操作系统的可移植性。 

系统调用发生在内核空间,因此如果在用户空间的一般应用程序中使用系统调用来进行文件操作,会有用户空间到内核空间切换的开销。事实上,即使在用户空间使用库函数来对文件进行操作,因为文件总是存在于存储介质上,因此不管是读写操作,都是对硬件(存储器)的操作,都必然会引起系统调用。也就是说,库函数对文件的操作实际上是通过系统调用来实现的。例如C库函数fwrite()就是通过write()系统调用来实现的。 

这样的话,使用库函数也有系统调用的开销,为什么不直接使用系统调用呢?这是因为,读写文件通常是大量的数据(这种大量是相对于底层驱动的系统调用所实现的数据操作单位而言),这时,使用库函数就可以大大减少系统调用的次数。这一结果又缘于缓冲区技术。在用户空间和内核空间,对文件操作都使用了缓冲区,例如用fwrite写文件,都是先将内容写到用户空间缓冲区,当用户空间缓冲区满或者写操作结束时,才将用户缓冲区的内容写到内核缓冲区,同样的道理,当内核缓冲区满或写结束时才将内核缓冲区内容写到文件对应的硬件媒介。

2、库函数调用 

标准C库函数提供的文件操作函数如fopen, fread, fwrite, fclose, fflush, fseek等,需包含头文件stdio.h。以fwrite为例,其函数原型为

size_t fwrite(const void *buffer, size_t size, size_t item_num, FILE *pf),其操作对象为文件指针FILE *pf,要想写一个文件,必须先以可写权限用fopen函数打开一个文件,获得所打开文件的FILE结构指针pf,例如pf=fopen(/"~/proj/filename/", /"w/")。实际上,由于库函数对文件的操作最终是通过系统调用实现的,因此,每打开一个文件所获得的FILE结构指针都有一个内核空间的文件描述符fd与之对应。同样有相应的预定义的FILE指针:stdin-standard input,stdout-standard output,stderr-standard error。 库函数调用通常用于应用程序中对一般文件的访问。 库函数调用是系统无关的,因此可移植性好。 由于库函数调用是基于C库的,因此也就不可能用于内核空间的驱动程序中对设备的操作。

 

【31】关于C语言:


宏定义和展开(必须精通) 位操作(必须精通)  指针操作和计算(必须精通) 内存分配(必须精通) sizeof必考 各类库函数必须非常熟练的实现 哪些库函数属于高危函数,为什么?(strcpy等等)。


【32】虚函数的作用和实现原理


有虚函数的类内部有一个称为“虚表”的指针(有多少个虚函数就有多少个指针),这个就是用来指向这个类虚函数。也就是用它来确定调用该那个函数。 实际上在编译的时候,编译器会自动加入“虚表”。虚表的使用方法是这样的:如果派生类在自己的定义中没有修改基类的虚函数,就指向基类的虚函数;如果派生类改写了基类的虚函数(就是自己重新定义),这时虚表则将原来指向基类的虚函数的地址替换为指向自身虚函数的指针。那些被virtual关键字修饰的成员函数,就是虚函数。虚函数的作用,用专业术语来解释就是实现多态性(Polymorphism),多态性是将接口与实现进行分离;用形象的语言来解释就是实现以共同的方法,但因个体差异而采用不同的策略。 

每个类都有自己的vtbl,vtbl的作用就是保存自己类中虚函数的地址,我们可以把vtbl形象地看成一个数组,这个数组的每个元素存放的就是虚函数的地址, 虚函数的效率低,其原因就是,在调用虚函数之前,还调用了获得虚函数地址的代码。

 

【33】sizeof求类大小。


注意:成员变量,函数,虚函数,继承等等对大小的影响。


【34】指针和引用的区别?


相同点:

1、都是地址的概念; 

2、指针指向一块内存,它的内容是所指内存的地址;引用是某块内存的别名。

 区别:

1、 指针是一个实体,而引用仅是个别名;

2、 引用使用时无需解引用(*),指针需要解引用; 

3、引用只能在定义时被初始化一次,之后不可变;指针可变; 

4、引用没有 const,指针有 const; 

5、引用不能为空,指针可以为空; 

6、“sizeof 引用”得到的是所指向的变量(对象)的大小,而“sizeof 指针”得到的是指针本身(所指向的变量或对象的地址)的大小;

7、 指针和引用的自增(++)运算意义不一样; 

8、从内存分配上看:程序为指针变量分配内存区域,而引用不需要分配内存区域。 

 

【35】extern C的作用?


必须将编译器的函数名修饰的机制解答的很透彻。

extern "C"的主要作用就是为了能够正确实现C++代码调用其他C语言代码。加上extern "C"后,会指示编译器这部分代码按c语言的进行编译,而不是C++的。由于C++支持函数重载,因此编译器编译函数的过程中会将函数的参数类型也加到编译后的代码中,而不仅仅是函数名;而C语言并不支持函数重载,因此编译C语言代码的函数时不会带上函数的参数类型,一般只包括函数名。

extern "C"包含双重含义,从字面上可以知道,首先,被它修饰的目标是"extern"的;其次,被它修饰的目标代码是"C"的,按照C语言方式进行编译和链接的!!!

由于C++支持函数重载,而C语言不支持,因此函数被C++编译后在符号库中的名字是与C语言不同的;C++编译后的函数需要加上参数的类型才能唯一标定重载后的函数,而加上extern"C"后,是为了向编译器指明这段代码按照C语言的方式进行编译。


【36】volatile的作用?


必须将cpu的寄存器缓存机制回答的很透彻

volatile的本意是“易变的”。

因为访问寄存器要比访问内存单元快的多,所以编译器一般都会作减少存取内存的优化,但有可能会读脏数据。当要求使用volatile声明变量值的时候,系统总是重新从它所在的内存读取数据,即使它前面的指令刚刚从该处读取过数据。精确地说就是,遇到这个关键字声明的变量,编译器对访问该变量的代码就不再进行优化,从而可以提供对特殊地址的稳定访问;如果不使用volatile,则编译器将对所声明的语句进行优化。(简洁的说就是:volatile关键词影响编译器编译的结果,用volatile声明的变量表示该变量随时可能发生变化,与该变量有关的运算,不要进行编译优化,以免出错)。

volatile的本质:

1> 编译器的优化。

在本次线程内, 当读取一个变量时,为提高存取速度,编译器优化时有时会先把变量读取到一个寄存器中;以后,再取变量值时,就直接从寄存器中取值;当变量值在本线程里改变时,会同时把变量的新值copy到该寄存器中,以便保持一致。  当变量在因别的线程等而改变了值,该寄存器的值不会相应改变,从而造成应用程序读取的值和实际的变量值不一致。  当该寄存器在因别的线程等而改变了值,原变量的值不会改变,从而造成应用程序读取的值和实际的变量值不一致。 

2> volatile应该解释为“直接存取原始内存地址”比较合适,“易变的”这种解释简直有点误导人

 

【37】select服务器端的实现,select与epoll的区别?


select的本质是采用32个整数的32位,即32*32= 1024来标识,fd值为1-1024。当fd的值超过1024限制时,就必须修改FD_SETSIZE的大小。这个时候就可以标识32*max值范围的fd。 

对于单进程多线程,每个线程处理多个fd的情况,select是不适合的。

1、所有的线程均是从1-32*max进行扫描,每个线程处理的均是一段fd值,这样做有点浪费。 

2、1024上限问题,一个处理多个用户的进程,fd值远远大于1024。

 

所以这个时候应该采用poll,  poll传递的是数组头指针和该数组的长度,只要数组的长度不是很长,性能还是很不错的,因为poll一次在内核中申请4K(一个页的大小来存放fd),尽量控制在4K以内。

 

epoll还是poll的一种优化,返回后不需要对所有的fd进行遍历,在内核中维持了fd的列表。select和poll是将这个内核列表维持在用户态,然后传递到内核中。但是只有在2.6的内核才支持。 

epoll更适合于处理大量的fd ,且活跃fd不是很多的情况,毕竟fd较多还是一个串行的操作。

epoll哪些触发模式,有啥区别?(必须非常详尽的解释水平触发和边缘触发的区别,以及边缘触发在编程中要做哪些更多的确认)

epoll可以同时支持水平触发和边缘触发(Edge Triggered,只告诉进程哪些文件描述符刚刚变为就绪状态,它只说一遍,如果我们没有采取行动,那么它将不会再次告知,这种方式称为边缘触发),理论上边缘触发的性能要更高一些,但是代码实现相当复杂。 

epoll同样只告知那些就绪的文件描述符,而且当我们调用epoll_wait()获得就绪文件描述符时,返回的不是实际的描述符,而是一个代表就绪描述符数量的值,你只需要去epoll指定的一个数组中依次取得相应数量的文件描述符即可,这里也使用了内存映射(mmap)技术,这样便彻底省掉了这些文件描述符在系统调用时复制的开销。 

另一个本质的改进在于epoll采用基于事件的就绪通知方式。在select/poll中,进程只有在调用一定的方法后,内核才对所有监视的文件描述符进行扫描,而epoll事先通过epoll_ctl()来注册一个文件描述符,一旦基于某个文件描述符就绪时,内核会采用类似callback的回调机制,迅速激活这个文件描述符,当进程调用epoll_wait()时便得到通知。

 

【38】大规模连接上来说,并发模型怎么设计?


三种并发服务器实现方法:一个好的服务器,一般都是并发服务器。并发服务器设计技术一般有:多进程服务器、多线程服务器、I/O复用服务器等。

1 多进程并发服务器

在Linux环境下多进程的应用很多,其中最主要的就是网络/客户服务器。多进程服务器是当客户有请求时 ,服务器用一个子进程来处理客户请求。父进程继续等待其它客户的请求。这种方法的优点是当客户有请求时 ,服务器能及时处理客户 ,特别是在客户服务器交互系统中。对于一个 TCP服务器,客户与服务器的连接可能并不马上关闭 ,可能会等到客户提交某些数据后再关闭 ,这段时间服务器端的进程会阻塞 ,所以这时操作系统可能调度其它客户服务进程。比起循环服务器大大提高了服务性能。

TCP多进程并发服务器

TCP并发服务器的思想是每一个客户机的请求并不由服务器直接处理,而是由服务器创建一个子进程来处理。

socket(...);

bind(...);

listen(...);

while(1)

{

   accpet(...);

   if(fork(...) == 0)

   {

     process(...);

     close(...);

     exit(...);

   }

   close(...);

}

2多线程服务器

多线程服务器是对多进程的服务器的改进 ,由于多进程服务器在创建进程时要消耗较大的系统资源 ,所以用线程来取代进程 ,这样服务处理程序可以较快的创建。据统计 ,创建线程与创建进程要快 10100 倍 ,所以又把线程称为“轻量级”进程。线程与进程不同的是:一个进程内的所有线程共享相同的全局内存、全局变量等信息。这种机制又带来了同步问题。

以下是多线程服务器模板:

socket(...);

bind(...);

listen(...);

while(1)

{

   accpet(...);

   if((pthread_create(...))!==-1)

   {

      process(...);

      close(...);

      exit(...);

   }

   close(...);

}

2.3 I/O复用服务器

I/ O复用技术是为了解决进程或线程阻塞到某个 I/ O系统调用而出现的技术 ,使进程不阻塞于某个特定的I/ O系统调用。它也可用于并发服务器的设计,常用函数select、poll、epoll来实现。

socket(...);

bind(...);

listen(...);

while(1)

{

  if(select(...)>0)

    if(FD_ISSET(...)>0)

    {

accpet(...);

        process(...);

}

    close(...);

}

以上都是TCP服务器端的程序,TCP客户端的程序可以通用:

socket(...);

connect(...);

listen(...);

process(...);

close(...);

 

【39】什么是滑动窗口?


滑动窗口(Sliding window )是一种流量控制技术。滑动窗口协议是用来改善吞吐量的一种技术,即容许发送方在接收任何应答之前传送附加的包。接收方告诉发送方在某一时刻能送多少包(称窗口尺寸)。TCP中采用滑动窗口来进行传输控制,滑动窗口的大小意味着接收方还有多大的缓冲区可以用于接收数据。发送方可以通过滑动窗口的大小来确定应该发送多少字节的数据。当滑动窗口为0时,发送方一般不能再发送数据报,但有两种情况除外,一种情况是可以发送紧急数据,例如,允许用户终止在远端机上的运行进程。另一种情况是发送方可以发送一个1字节的数据报来通知接收方重新声明它希望接收的下一字节及发送方的滑动窗口大小。滑动窗口协议的基本原理就是在任意时刻,发送方都维持了一个连续的允许发送的帧的序号,称为发送窗口;同时,接收方也维持了一个连续的允许接收的帧的序号,称为接收窗口。发送窗口和接收窗口的序号的上下界不一定要一样,甚至大小也可以不同。不同的滑动窗口协议窗口大小一般不同。发送方窗口内的序列号代表了那些已经被发送,但是还没有被确认的帧,或者是那些可以被发送的帧。

流量控制和拥塞控制?

1、  网络拥塞。是指网络中分组太多,导致大量丢包的现象,此时网络的性能严重下降。拥塞控制就是处理网络拥塞的一种机制。

2、  流量控制。对数据发送方数据发送速度进行控制的措施,避免对方来不及接收数据。

3、  拥塞控制(注意快速重传和快速恢复是对检测到超时或者重复ack分组的处理的改进):

a)    慢启动:按照指数的方式增长发送窗口的大小,直到达到某一个阈值。

b)    拥塞避免:在没有丢包之前,按照线性增长发送窗口。如果遇到重复ACK分组或者超时,那么就把阈值减为原来的一般,发送窗口设置为1,进入慢启动阶段。

c)     快速重传:当接收到3个相同的确认报文或者超时,表示有丢包现象,就马上重传丢失的数据包,然后把发送窗口设置为当前窗口的一半,同时阈值也设置为当前窗口的一半,然后直接进入拥塞避免阶段。

d)    快速恢复:上一步骤重发的数据包,收到ack的时候,拥塞窗口加1。

 

【40】connect会阻塞,怎么解决?


       最通常的方法是加定时器,也可以采用非阻塞模式。

设置非阻塞,返回之后用select检测状态,如果select返回可读,结果只读到0字节,什么情况? 

某个套接字集合中没有准备好,可能会select内存用FD_CLR清该位为0;

keepalive 是什么东东?如何使用?

设置Keepalive参数,检测已中断的客户连接

 

【41】TCP的connect函数与UDP的connect函数区别?


(1)UDP中可以使用connect系统调用。

(2)UDP中connect操作与TCP中connect操作有着本质区别。TCP中调用connect会引起三次握手,client与server建立连接。UDP中调用connect内核仅仅把对端ip&port记录下来。

(3)UDP中可以多次调用connect,TCP只能调用一次connect。UDP多次调用connect有两种用途:1,指定一个新的ip&port连接。2,断开之前的ip&port的连接。指定新连接,直接设置connect第二个参数即可。断开连接,需要将connect第二个参数中的sin_family设置成 AF_UNSPEC即可。

(4)UDP中使用connect可以提高效率。原因如下:普通的UDP发送两个报文内核做了如下:#1:建立连接#2:发送报文#3:断开连接#4:建立连接#5:发送报文#6:断开连接。采用connect方式的UDP发送两个报文内核如下处理:#1:建立连接#2:发送报文#3:发送报文另外一点,每次发送报文内核都可能要做路由查询。5:采用connect的UDP发送接受报文可以调用send,write和recv,read操作。当然也可以调用sendto,recvfrom。调用sendto的时候第五个参数必须是NULL,第六个参数是0。调用recvfrom,recv,read系统调用只能获取到先前connect的ip&port发送的报文。 

(5)UDP中使用connect的好处:1:会提升效率。前面已经描述了。2:高并发服务中会增加系统稳定性。原因:假设client A 通过非connect的UDP与server B,C通信。B,C提供相同服务。为了负载均衡,我们让A与B,C交替通信。A 与 B通信IPa:PORTa <----> IPb:PORTbA 与 C通信IPa:PORTa' <---->IPc:PORTc  假设PORTa 与 PORTa'相同了(在大并发情况下会发生这种情况),那么就有可能出现A等待B的报文,却收到了C的报文。导致收报错误。解决方法内就是采用connect的UDP通信方式。在A中创建两个udp,然后分别connect到B,C。

 

【42】Socket编程中,阻塞与非阻塞的区别?


阻塞:一般的I/O操作可以在新建的流中运用。在服务器回应前它等待客户端发送一个空白的行。当会话结束时,服务器关闭流和客户端socket。如果在队列中没有请示将会出现什么情况呢?那个方法将会等待一个的到来。这个行为叫阻塞。accept()方法将会阻塞服务器线程直到一个呼叫到来。当5个连接处理完闭之后,服务器退出。任何的在队列中的呼叫将会被取消。

非阻塞:非阻塞套接字是指执行此套接字的网络调用时,不管是否执行成功,都立即返回。比如调用recv()函数读取网络缓冲区中数据,不管是否读到数据都立即返回,而不会一直挂在此函数调用上。在实际Windows网络通信软件开发中,异步非阻塞套接字是用的最多的。平常所说的C/S(客户端/服务器)结构的软件就是异步非阻塞模式的。

在blocking model 下:套接字在IO时阻塞应用程序,就是说控制权不会返回给应用程序,也就是说程序执行到此代码时会卡住。分两种情况:1,send函数时,只有把要发送的数据下传至TCP层,send这句代码才继续向下执行,此时可确认自己的数据已经在网络上传输了。2,recv时,只有收到一定数据给应用程序缓冲区时,recv这行代码才会向下执行。如果不想这样做,可以使用多线程,或者选用其他网络IO模型。一般在做服务器程序时,不会使用阻塞套接字,性能低,数据吞吐率也不高。优点是此种模型编写难度较低,可以用来做入门的学习之用。

非阻塞套接字,IO会马上返回。但在send时,如果SOCKET缓冲区已满,会返回错误,使用WSAGetLastError会得到错误码为WSAEWOULDBLOCK,意思是说在一个非阻塞的套接字上,请求没有完成。recv时如果SOCKET缓冲区没有可以读的数据,也会返回WSAEWOULDBLOCK。

Socket 的模式大概分为这么几种:

1、阻塞式的,Socket操作都需要将线程挂起,等待内核完成后才能返回。

如: 调用connect=>进入内核=>Syn包=〉服务器返回SYN ACK 包=〉connect返回。

=〉ACK包发往服务器。

但一般来说,阻塞和非阻塞对于recv来说意义更大。

当在阻塞式的Socket上调用recv时,如果这时网络栈上没有数据给你接收,那么这时线程将会挂起,直到有报文给你接收才返回。

这样就造成你的应用程序在企图接收数据时候,而网络栈上没有数据的时候就会被锁住。

有什么办法解决这个问题呢? IO复用。

2、 IO复用, 就是在企图读写数据的时候先询问下是否可读写,如果不能,可以去干别的事情,不会造成死锁。

但是假如我们有大量的连接需要去频繁的查询可读写状态,每次查询都会和内核交互。这样会造成

效率低下。再介绍一种:

3、 重叠IO. 就是一次查询多个Socket的状态。不用去来来回回的遍历。

另外,在windows socketapi 中还有一种消息机制,就是把Socket状态通知到窗口。然后用消息去处理。

对于重叠IO, 在windows上还有完成端口模型,他和重叠端口相比,不但能捕捉到IO事件,而且内核已经替你完成了Socket IO, 比如read事件,在内核通知你的时候,他已经帮你读好数据了,并放在你指定的缓存中(这里是指在用户态下,事先为每个Socket分配的内存)。

为什么有这么多socket模式呢?哪个更好呢?

阻塞式的比较简单,方便,稳定。适合比较简单的客户端程序。

IO复用我认为它适合Socket IO操作比较少的情况。

重叠IO就适合高性能的服务器的开发,另外完成端口是windows上比较公认的高性能服务器的网络开发模型。当然,windows 的IOCP也有个坏处,就是需要大量的内存,应为前面说了他需要事先指定缓存。不过高性能的 服务器,一般都不用windows平台。 

windows的消息模型就比较适合有UI的应用程序。


【43】进程间通信?


(1)信号

       信号是在软件层次上对中断机制的一种模拟,在原理上,一个进程收到一个信号与处理器收到一个中断请求可以说是一样的。信号是异步的,一个进程不必通过任何操作来等待信号的到达,事实上,进程也不知道信号到底什么时候到达。信号是进程间通信机制中唯一的异步通信机制,可以看作是异步通知,通知接收信号的进程有哪些事情发生了。信号机制经过POSIX实时扩展后,功能更加强大,除了基本通知功能外,还可以传递附加信息。信号事件的发生有两个来源:硬件来源(比如我们按下了键盘或者其它硬件故障);软件来源。

信号用于通知进程发生了某种状况。分为可靠信号和不可靠信号,实时信号和非实时信号。

进程有三种方式响应信号:

忽略信号

捕捉信号

执行缺省操作(系统默认操作—终止该进程)

常用的几种信号:

       SIGABRT – 异常终止abort

       SIGINT – 终端中断符

       SIGKILL – 终止

       …等等。

(2)信号量

       信号量也可以说是一个计数器,用于为多个进程提供对数据对象的访问。它常用来处理进程或线程同步的问题,特别是对临界资源的访问同步问题。临界资源:为某一时刻只能由一个进程或线程操作的资源,当信号量的值大于或等于0时,表示可以供并发进程访问的临界资源数,当小于0时,表示正在等待使用临界资源的进程数。更重要的是,信号量的值仅能由PV操作来改变。

(3)共享内存

       共享内存就是分配一块能被其他进程访问的内存。共享内存可以说是最有用的进程间通信方式,也是最快的IPC形式。首先说下在使用共享内存区前,必须通过系统函数将其附加到进程的地址空间或说为映射到进程空间。两个不同进程A、B共享内存的意思是,同一块物理内存被映射到 进程A、B各自的进程地址空间。进程A可以即时看到进程B对共享内存中数据的更新,反之亦然。由于多个进程共享同一块内存区域,必然需要某种同步机制,互 斥锁和信号量都可以。采用共享内存通信的一个显而易见的好处是效率高,因为进程可以直接读写内存,而不需要任何数据的拷贝。对于像管道和消息队列等通信方式,则需要在内核和用户空间进行四次的数据拷贝,而 共享内存则只拷贝两次数据[1]:一次从输入文件到共享内存区,另一次从共享内存区到输出文件。实际上,进程之间在共享内存时,并不总是读写少量数据后就 解除映射,有新的通信时,再重新建立共享内存区域。而是保持共享区域,直到通信完毕为止,这样,数据内容一直保存在共享内存中,并没有写回文件。共享内存中的内容往往是在解除映射时才写回文件的。因此,采用共享内存的通信方式效率是非常高的。

(4)消息队列

消息队列是存放在内核中的消息链表,存储在内核中,由消息队列标识符标识。与管道不同的是,消息队列存放在内核中,只有在内核重启时才能删除一个消息队列,内核重启也就是系统重启,同样消息队列的大小也是受限制的。Msgget函数用于创建一个新队列或者打开一个现有队列,msdsend将新消息添加到队列尾端,msgrecv用于从队列中取消息。

(5)管道

管道传递数据是单向性的,只能从一方流向另一方,也就是一种半双工的通信方式;只用于有亲缘关系的进程间的通信,亲缘关系也就是父子进程或兄弟进程;没有名字并且大小受限,传输的是无格式的流,所以两进程通信时必须约定好数据通信的格式。管道它就像一个特殊的文件,但这个文件之存在于内存中,在创建管道时,系统为管道分配了一个页面作为数据缓冲区,进程对这个数据缓冲区进行读写,以此来完成通信。其中一个进程只能读一个只能写,所以叫半双工通信,为什么一个只能读一个只能写呢?因为写进程是在缓冲区的末尾写入,读进程是在缓冲区的头部读取,他们各自 的数据结构不同,所以功能不同。

(6)命名管道

命名管道(NamedPipe)是服务器进程和一个或多个客户进程之间通信的单向或双向管道。不同于匿名管道的是:命名管道可以在不相关的进程之间和不同计算机之间使用,服务器建立命名管道时给它指定一个名字,任何进程都可以通过该名字打开管道的另一端,根据给定的权限和服务器进程通信。命名管道提供了相对简单的编程接口,使通过网络传输数据并不比同一计算机上两进程之间通信更困难,不过如果要同时和多个进程通信它就力不从心了。

命名管道不同与管道只能在具有亲缘关系的进程间通信了。它提供了一个路径名与之关联,有了自己的传输格式。

命名管道和管道的不同之处还有一点是,有名管道是个设备文件,存储在文件系统中,没有亲缘关系的进程也可以访问,但是它要按照先进先出的原则读取数据。同样也是单双工的。

(7)套接字

套接字也是一种进程间通信机制,与其他通信机制不同的是,它可用于不同主机间的进程通信。

IPC包括上面三种(消息队列、信号量和共享存储)。


【44】线程间同步方式?


(1)互斥量

互斥量(mutex)本质上说是一把锁,在访问共享资源前对互斥量进行设置(加锁),在访问完成后释放(解锁)互斥量。互斥量使用pthread的互斥接口来保护数据,确保同一时间只有一个线程访问数据。

互斥锁、读写锁、自旋锁

(2)条件变量

       条件变量是线程可用的另一种同步机制。条件变量给多个线程提供了一个会和的场所,条件变量和互斥量一起使用时,允许线程以无竞争的方式等待特定的条件发生。条件本身是由互斥量保护的,线程在改变条件状态之前,必须首先锁住互斥量。

(3)信号量

      

【45】I/O复用技术?


       TCP客户同时处理两个输入:标准输入和TCP套接字。我们遇到的问题就在于客户阻塞于(标准输入)上的fgets调用期间,服务器进程会被杀死。服务器TCP虽然正确的给客户TCP发送了一个FIN,但是既然客户进程正阻塞于从标准输入读入的过程,它将看不到这个EOF,直到从套接字读时为止(可能已经过了很长时间)。这样的进程需要一种预先告知内核的能力,使得内核一旦发现进程指定的一个或者多个I/O条件就绪(也就是说输入已准备好被读取,或者描述符已能承接更多的输出),它就通知进程,这个能力成为I/O复用。

I/O复用应用场合:

a. 当客户处理多个描述符(通常是交互式输入和网络套接字)时,必须使用I/O复用。

b. 一个客户处理多个套接字时可能的,不过少见。

c. 如果一个TCP服务器既要处理监听套接字,又要处理已连接套接字,一般就要使用I/O复用。

d. 如果一个服务器既要处理TCP又要处理UDP,使用I/O复用。

e. 如果一个服务器要处理多个服务或者多个协议,使用I/O复用。



【46】硬链接与符号链接


首先要弄清楚,在Linux系统中,内核为每一个新创建的文件分配一个Inode(索引结点),每个文件都有一个惟一的inode号。文件属性保存在索引结点里,在访问文件时,索引结点被复制到内存在,从而实现文件的快速访问。

链接是一种在共享文件和访问它的用户的若干目录项之间建立联系的一种方法。Linux中包括两种链接:硬链接(Hard Link)和软链接(Soft Link),软链接又称为符号链接(Symbolic link)。

一、硬链接

硬链接说白了是一个指针,指向文件索引节点,系统并不为它重新分配inode。可以用:ln命令来建立硬链接。语法:

ln [options] existingfile newfile

ln[options] existingfile-listdirectory

用法: 第一种:为”existingfile”创建硬链接,文件名为”newfile”。第二种:在“directory”目录中,为”existingfile-list”中包含的所有文件创建一个同名的硬链接。常用可选[options]–f 无论”newfile”存在与否,都创建链接。-n 如果”newfile”已存在,就不创建链接。

下面举一些例子:

$ ls –il

13058 -rwx - - - - - - 1 longchenglongcheng 48 8月 5 16:38 file1

13059 -rwx - - - - - - 1 longchenglongcheng 57 8月 5 16:40 file2

$ ln file2 file2hard

$ ls –il

13058 -rwx - - - - - - 1 longchenglongcheng 48 8月 5 16:38 file1

13059 -rwx - - - - - - 2 longchenglongcheng 57 8月 5 16:40 file2

13059 -rwx - - - - - - 2 longchenglongcheng 57 8月 5 16:40 file2hard

注意在创建链接前,file1 显示的链接数目为1,创建链接后(1)file1和file1hard的链接数目都变为2;(2) file1和file1hard在inode号是一样的(3) file1和file1hard显示的文件大小也是一样。可见进行了ln命令的操作结果:file1和file1hard是同一个文件的两个名字,它们具有同样的索引节点号和文件属性,建立文件file1的硬链接,就是为file1的文件索引节点在当前目录上建立一个新指针。如下图,你可以删除其中任何一个,如rmfile2 ,每次只会删除一个指针,

链接数同时减一,只有将所有指向文件内容的指针,也即链接数减为0时,内核才会把文件内容从磁盘上删除。当前目录逻辑结构:(不好意思图没有显示出来)。

还可以在不同目录,但同一文件系统中建立文件的硬链接。设file1、file2在目录/home/longcheng/dir1中,下面的命令,在/home/longcheng中建立file2的硬链接。

ln file2 /home/longcheng/file2hard

下面的程序,是将dir1目录中所有文件,在目录dir2中建立硬链接。

$mkdir dir2

$ln /home/longcheng/dir1/*/home/longcheng/dir2

如果使用了 ln –f existingfile newfile,如果newfile已经存在,则无论原来newfile是什么文件,只用当前用户对它有写权限,newfile就成为exisitngfile的硬链接文件。

尽管硬链接节省空间,也是Linux系统整合文件系统的传统方式,但是存在一下不足之处:(1)不可以在不同文件系统的文件间建立链接(2)只有超级用户才可以为目录创建硬链接。虽然很多树上说root用户可以创建,但是笔者在学习过程中发现即使是root用户也不能创建,我的系统是Redhat,内核2.4、2.6都试过,在其他系统中不知道是不是可以。

二、软链接(符号链接)

符号链接是对一个文件的间接指针。硬链接直接指向文件的i节点。

软链接克服了硬链接的不足,没有任何文件系统的限制,任何用户可以创建指向目录的符号链接。因而现在更为广泛使用,它具有更大的灵活性,甚至可以跨越不同机器、不同网络对文件进行链接。

建立软链接,只要在ln后面加上选项 –s,下面举个例子

$ ls -il

13058 -rwx - - - - - - 1 longchenglongcheng 48 8月 5 16:38 file1

13059 -rwx - - - - - - 2 longchenglongcheng 57 8月 5 16:40 file2

13059 -rwx - - - - - - 2 longchenglongcheng 57 8月 5 16:40 file2hard

$ln –s file1 file1soft

$ls -il

13058 -rwx - - - - - - 1 longchenglongcheng 48 8月 5 16:38 file1

13059 -rwx - - - - - - 2 longchenglongcheng 57 8月 5 16:40 file2

13059 -rwx - - - - - - 2 longchenglongcheng 57 8月 5 16:40 file2hard

13061 lrwxrwxrwx 1 longcheng longcheng5 8月 516:58 file1soft->file1

从上面链接后的结果可以看出来软链接与硬链接,区别不仅仅是在概念上,在实现上也是不同的。区别:硬链接原文件&链接文件公用一个inode号,说明他们是同一个文件,而软链接原文件&链接文件拥有不同的inode号,表明他们是两个不同的文件;在文件属性上软链接明确写出了是链接文件,而硬链接没有写出来,因为在本质上硬链接文件和原文件是完全平等关系;链接数目是不一样的,软链接的链接数目不会增加;文件大小是不一样的,硬链接文件显示的大小是跟原文件是一样的,这用强调,因为是等同的嘛,而这里软链接显示的大小与原文件就不同了,file1大小是48B,而file1soft是5B,这里面的5实际上就是“file1”的大小。

总之,建立软链接就是建立了一个新文件。当访问链接文件时,系统就会发现他是个链接文件,它读取链接文件找到真正要访问的文件。

在不同系统之间建立软链接、对目录建立链接,这里就不举例了,读者可以自己去尝试,我也是在不断实践中学习的。

当然软链接也有硬链接没有的缺点,因为链接文件包含有原文件的路径信息,所以当原文件从一个目录下移到其他目录中,再访问链接文件,系统就找不到了,而硬链接就没有这个缺陷,你想怎么移就怎么移;还有它要系统分配额外的空间用于建立新的索引节点和保存原文件的路径。


【47】tcp与udp的区别?


TCP (Transmission Control Protocol)和UDP(User DatagramProtocol)协议属于传输层协议。其中TCP提供IP环境下的数据可靠传输,它提供的服务包括数据流传送、可靠性、有效流控、全双工操作和多路复用。通过面向连接、端到端和可靠的数据包发送。通俗说,它是事先为所发送的数据开辟出连接好的通道,然后再进行数据发送;而UDP则不为IP提供可靠性、流控或差错恢复功能。一般来说,TCP对应的是可靠性要求高的应用,而UDP对应的则是可靠性要求低、传输经济的应用。TCP支持的应用协议主要有:Telnet、FTP、SMTP等;


UDP是一个简单的面向数据报的传输层协议,UDP不保证可靠性,它把应用程序传给IP层的数据发送出去,但是并不保证它们能到达目的地。UDP支持的应用层协议主要有:NFS(网络文件系统)、SNMP(简单网络管理协议)、DNS(主域名称系统)、TFTP(通用文件传输协议)等。

UDP数据报和TCP段都包含一个12字节长的伪首部,它是为了计算检验和而设置的,伪首部包含IP首部中的一些字段。UDP的校验和是可选的,而TCP的校验和是必须的。

UDP的校验和是一个端到端的校验和,它由发送端计算,然后由接收端验证。其目的是为了发现UDP首部和数据在发送端到接收端之间发生的任何改动。

 

【48】自旋锁与互斥锁的区别?


互斥锁(mutexlock):

最常使用于线程同步的锁;标记用来保证在任一时刻,只能有一个线程访问该对象,同一线程多次加锁操作会造成死锁;临界区和互斥量都可用来实现此锁,通常情况下锁操作失败会将该线程睡眠等待锁释放时被唤醒。

自旋锁(spinlock):

同样用来标记只能有一个线程访问该对象,在同一线程多次加锁操作会造成死锁;使用硬件提供的swap指令或test_and_set指令实现;同互斥锁不同的是在锁操作需要等待的时候并不是睡眠等待唤醒,而是循环检测保持者已经释放了锁,这样做的好处是节省了线程从睡眠状态到唤醒之间内核会产生的消耗,在加锁时间短暂的环境下这点会提高很大效率。

读写锁(rwlock):

高级别锁,区分读和写,符合条件时允许多个线程访问对象。处于读锁操作时可以允许其他线程和本线程的读锁, 但不允许写锁,处于写锁时则任何锁操作都会睡眠等待;常见的操作系统会在写锁等待时屏蔽后续的读锁操作以防写锁被无限孤立而等待,在操作系统不支持情况下可以用引用计数加写优先等待来用互斥锁实现。读写锁适用于大量读少量写的环境,但由于其特殊的逻辑使得其效率相对普通的互斥锁和自旋锁要慢一个数量级;值得注意的一点是按POSIX标准在线程申请读锁并未释放前本线程申请写锁是成功的,但运行后的逻辑结果是无法预测

递归锁(recursivelock):

严格上讲递归锁只是互斥锁的一个特例,同样只能有一个线程访问该对象,但允许同一个线程在未释放其拥有的锁时反复对该锁进行加锁操作;

windows下的临界区默认是支持递归锁的,而linux下的互斥量则需要设置参数PTHREAD_MUTEX_RECURSIVE_NP,默认则是不支持的。



原创粉丝点击