Linux下socket设置为非阻塞方式和fcntl系统调用
linux async 异步用法
linux async 异步用法
在Linux中，异步（asynchronous）操作是一种非阻塞的操作方式，可以在执行一个操作时继续执行其他任务，而不需要等待该操作完成。
这种方式可以提高程序的响应速度和并发性。
在Linux中，通常使用以下方法实现异步操作：
1. 使用非阻塞I/O：通过将文件描述符设置为非阻塞模式，可以在读写文件时立即返回，而不是等待数据准备好或者写入完成。
可以使用`fcntl()`函数将文件描述符设置为非阻塞模式，或者使用`O_NONBLOCK`标志在调用`open()`函数时指定。
2. 使用信号（signal）：通过注册信号处理函数，可以在某个事件发生时，立即响应该事件而不需要等待。
可以使用`signal()`函数注册信号处理函数，当指定的信号发生时，执行注册的处理函数。
3. 使用回调函数（callback）：在执行某个操作时，可以指定一个回调函数，当该操作完成时，系统会调用该回调函数。
可以通过函数指针或者函数对象来指定回调函数。
4. 使用多线程或者多进程：可以将耗时的操作放在单独的线程或进程中执行，以避免阻塞主线程或进程的执行。
在多线程或者多进程中，可以使用线程或进程间的同步机制（如锁、条件变量、信号量等）来协调不同线程或进程之间的操作。
5. 使用事件驱动库：可以使用一些基于事件驱动的库，如libevent、libuv 等，来实现异步操作。
这些库提供了一套异步操作的接口和事件循环机制，开发者可以通过注册回调函数处理特定事件。
Linuxfcntl函数详解
Linuxfcntl函数详解功能描述：根据⽂件描述词来操作⽂件的特性。
⽂件控制函数 fcntl -- file control头⽂件：#include <unistd.h>#include <fcntl.h>函数原型：int fcntl(int fd, int cmd);int fcntl(int fd, int cmd, long arg);int fcntl(int fd, int cmd, struct flock *lock);描述：fcntl()针对(⽂件)描述符提供控制.参数fd是被参数cmd操作(如下⾯的描述)的描述符. 针对cmd的值,fcntl能够接受第三个参数（arg）fcntl函数有5种功能： 1.复制⼀个现有的描述符（cmd=F_DUPFD）. 2.获得／设置⽂件描述符标记(cmd=F_GETFD或F_SETFD).3.获得／设置⽂件状态标记(cmd=F_GETFL或F_SETFL).4.获得／设置异步I/O所有权(cmd=F_GETOWN或F_SETOWN).5.获得／设置记录锁(cmd=F_GETLK,F_SETLK或F_SETLKW).cmd选项：F_DUPFD 返回⼀个如下描述的(⽂件)描述符: （1）最⼩的⼤于或等于arg的⼀个可⽤的描述符 （2）与原始操作符⼀样的某对象的引⽤ （3）如果对象是⽂件(file)的话,返回⼀个新的描述符,这个描述符与arg共享相同的偏移量(offset) （4）相同的访问模式(读,写或读/写) （5）相同的⽂件状态标志(如:两个⽂件描述符共享相同的状态标志) （6）与新的⽂件描述符结合在⼀起的close-on-exec标志被设置成交叉式访问execve(2)的系统调⽤F_GETFD 取得与⽂件描述符fd联合close-on-exec标志,类似FD_CLOEXEC.如果返回值和FD_CLOEXEC进⾏与运算结果是0的话,⽂件保持交叉式访问exec(), 否则如果通过exec运⾏的话,⽂件将被关闭(arg被忽略)F_SETFD 设置close-on-exec旗标。
linux socket编程基础(必读)
（2） void bcopy（const void * src，void * dest，int n）：从参数 src 指定 的内存区域拷贝指定数目的字节内容到参数 dest 指定的内存区域。
在调用函数 connect 之前，客户机需要指定服务器进程的套接字地址。客户 机一般不需要指定自己的套接字地址（IP 地址和端口号），系统会自动从1024 至5000的端口号范围内为它选择一个未用的端口号，然后以这个端口号和本机 的 IP 地址填充这个套接字地址。
客户机调用函数 connect 来主动建立连接。这个函数将启动 TCP 协议的3次 握手过程。在建立连接之后或发生错误时函数返回。连接过程可能出现的错误情 况有：
（2） 如果远程 TCP 协议返回一个 RST 数据段，函数立即以错误返回，错 误类型为 ECONNREFUSED。当远程机器在 SYN 数据段指定的目的端口号处
没有服务进程在等待连接时，远程机器的 TCP 协议将发送一个 RST 数据段，向 客户机报告这个错误。客户机的 TCP 协议在接收到 RST 数据段后不再继续发送 SYN 数据段，函数立即以错误返回。
（3） int bcmp（const void * s1，const void * s2，int n）：比较参数 s1指 定的内存区域和参数 s2指定的内存区域的前 n 个字节内容，如果相同则返回0， 否则返回非0。
注：以上函数的原型定义在 strings.h 中。 以 mem 开头的函数有： （1） void * memset（void * s，int c，size_t n）：将参数 s 指定的内存区 域的前 n 个字节设置为参数 c 的内容。 （2） void * memcpy（void * dest，const void * src，size_t n）：功能同 bcopy （），区别：函数 bcopy（）能处理参数 src 和参数 dest 所指定的区域有重叠的 情况，memcpy（）则不能。 （4） int memcmp（const void * s1，const void * s2，size_t n）：比较参 数 s1和参数 s2指定区域的前 n 个字节内容，如果相同则返回0，否则返回非0。 注：以上函数的原型定义在 string.h 中。 9、 基本套接字函数 （1） socket（） #include<sys/types.h> #include<sys/socket.h>
Linux内核中系统调用详解
Linux内核中系统调用详解什么是系统调用?（Linux）内核中设置了一组用于实现各种系统功能的子程序，称为系统调用。
用户可以通过系统调用命令在自己的应用程序中调用它们。
从某种角度来看，系统调用和普通的函数调用非常相似。
区别仅仅在于，系统调用由（操作系统）核心提供，运行于核心态;而普通的函数调用由函数库或用户自己提供，运行于用户态。
随Linux核心还提供了一些（C语言）函数库，这些库对系统调用进行了一些包装和扩展，因为这些库函数与系统调用的关系非常紧密，所以习惯上把这些函数也称为系统调用。
为什么要用系统调用?实际上，很多已经被我们习以为常的C语言标准函数，在Linux 平台上的实现都是靠系统调用完成的，所以如果想对系统底层的原理作深入的了解，掌握各种系统调用是初步的要求。
进一步，若想成为一名Linux下（编程）高手，也就是我们常说的Hacker，其标志之一也是能对各种系统调用有透彻的了解。
即使除去上面的原因，在平常的编程中你也会发现，在很多情况下，系统调用是实现你的想法的简洁有效的途径，所以有可能的话应该尽量多掌握一些系统调用，这会对你的程序设计过程带来意想不到的帮助。
系统调用是怎么工作的?一般的，进程是不能访问内核的。
它不能访问内核所占内存空间也不能调用内核函数。
（CPU）（硬件）决定了这些(这就是为什么它被称作"保护模式")。
系统调用是这些规则的一个例外。
其原理是进程先用适当的值填充（寄存器），然后调用一个特殊的指令，这个指令会跳到一个事先定义的内核中的一个位置(当然，这个位置是用户进程可读但是不可写的)。
在（Intel）CPU中，这个由中断0x80实现。
硬件知道一旦你跳到这个位置，你就不是在限制模式下运行的用户，而是作为操作系统的内核--所以你就可以为所欲为。
进程可以跳转到的内核位置叫做sysem_call。
这个过程检查系统调用号，这个号码告诉内核进程请求哪种服务。
然后，它查看系统调用表(sys_call_table)找到所调用的内核函数入口地址。
Socket调用方式（同步，异步，阻塞，非阻塞）
Socket调⽤⽅式（同步，异步，阻塞，⾮阻塞）同步:我调⽤⼀个功能，该功能没有结束前，我死等结果。
异步:当⼀个异步过程调⽤发出后，调⽤者不能⽴刻得到结果。
该功能在完成后，通过状态、通知和回调来通知调⽤者。
同步和⾮同步关注的是调⽤者是否等待等待调⽤结果。
举个通俗的例⼦：你打电话问书店⽼板有没有《分布式系统》这本书，如果是同步通信机制，书店⽼板会说，你稍等，”我查⼀下"，然后开始查啊查，等查好了（可能是5秒，也可能是⼀天）告诉你结果（返回结果）。
⽽异步通信机制，书店⽼板直接告诉你我查⼀下啊，查好了打电话给你，然后直接挂电话了（不返回结果）。
然后查好了，他会主动打电话给你。
在这⾥⽼板通过“回电”这种⽅式来回调。
阻塞：调⽤我（函数），我（函数）没有接收完数据或者没有得到结果之前，我不会返回。
⾮阻塞：调⽤我（函数），我（函数）⽴即返回通知调⽤者以最常⽤的send和recv两个函数为例⽐如你调⽤send函数发送⼀定的Byte,在系统内部send做的⼯作其实只是把数据传输(Copy)到TCP/IP协议栈的输出缓冲区,它执⾏成功并不代表数据已经成功的发送出去了,如果TCP/IP协议栈没有⾜够的可⽤缓冲区来保存你Copy过来的数据的话...这时候就体现出阻塞和⾮阻塞的不同之处了:对于阻塞模式的socket send函数将不返回直到系统缓冲区有⾜够的空间把你要发送的数据Copy过去以后才返回,⽽对于⾮阻塞的socket来说send会⽴即返回WSAEWOULDDBLOCK告诉调⽤者说:"发送操作被阻塞了!!!你想办法处理吧..."对于recv函数,同样道理,对于阻塞模式的socket来说如果TCP/IP协议栈的接收缓冲区没有通知⼀个结果给它它就⼀直不返回:耗费着系统资源....对于⾮阻塞模式的socket该函数会马上返回,然后告诉你:WSAEWOULDDBLOCK---"现在没有数据,回头再来看看"阻塞I/O模型：⾮阻塞I/O模型：阻塞和⾮阻塞关注的是调⽤者在等待调⽤结果时的状态。
非阻塞connect写法
非阻塞connect写法
非阻塞connect是指在网络编程中，客户端发起连接请求时不
会被阻塞，而是立即返回，可以在后续的代码中通过轮询或者回调
的方式来获取连接是否建立成功。
在实际编程中，可以通过设置套
接字为非阻塞模式来实现非阻塞connect。
在C/C++语言中，可以使用以下步骤来实现非阻塞connect的
写法：
1. 创建套接字，使用socket函数创建套接字。
2. 设置为非阻塞模式，使用fcntl函数或者ioctl函数将套接
字设置为非阻塞模式。
3. 发起连接请求，使用connect函数向服务器发起连接请求。
4. 检测连接状态，在非阻塞模式下，connect函数会立即返回，并不保证连接一定会成功建立。
可以使用select函数、poll函数
或者epoll函数等进行轮询，或者使用回调函数来检测连接状态。
5. 处理连接结果，根据轮询或者回调的结果，可以判断连接是
否成功建立，如果连接成功，则可以进行后续的数据传输操作；如
果连接失败，则可以进行相应的处理，比如重新发起连接请求或者
进行错误处理。
在Python语言中，可以使用socket模块提供的
setblocking(False)方法将套接字设置为非阻塞模式，然后使用connect方法发起连接请求，最后通过select模块进行状态检测。
总之，非阻塞connect的写法需要将套接字设置为非阻塞模式，并通过轮询或者回调来检测连接状态，以实现在发起连接请求时不
被阻塞的效果。
fcntl函数介绍
fcntl函数介绍 1、fcntl：manipulate file descriptor 1）简介：fcntl（file control）函数可执⾏各种描述符控制操作。
#include <unistd.h>#include <fcntl.h>int fcntl(int fd, int cmd, ... /* arg */ ); 2）正确的使⽤⽅法（以设置“⾮阻塞”标记为例）：int flags;// 先获取当前的flagsif ((flags = fcntl(sockfd, F_GETFL, 0)) < 0)// 错误处理...flags |= O_NONBLOCK; // 加上“⾮阻塞”flagif (fcntl(sockfd, F_SETFL, flags) < 0) // 设置新的flags// 错误处理... 3）常⽤⽤法： （1）把⼀个套接字设置为⾮阻塞型：cmd为F_SETFL，flags“包含”O_NONBLOCK。
（2）把⼀个套接字设置成⼀旦其状态发⽣变化，内核就产⽣⼀个SIGIO：cmd为F_SETFL，flags“包含”O_ASYNC。
（3）关于套接字的当前属主。
cmd为F_SETOWN：指定⽤于接收SIGIO或SIGURG信号的套接字属主（进程ID或进程组ID）。
SIGIO是套接字被设置为信号驱动式I/O 型后产⽣的，⽽SIGURG是在新的带外数据到达套接字时产⽣的。
SIGIO与SIGURG与其他信号的不同之处在于，这两个信号仅在已使⽤F_SETOWN命令给相关套接字指派了属主后才会产⽣。
F_SETOWN命令对应的arg参数是正整数时，指出接收信号的进程ID；为负整数时，其绝对值指出接收信号的进程组ID（此时整个进程组中的所有进程接收信号）。
cmd为F_GETOWN：返回套接字的当前属主。
（4）记录上锁。
记录上锁的Posix接⼝是fcntl函数。
linux、glibc中socket系统调用实现
/* %eax is < 0 if there was an error. */ cmpl $-125, %eax jae SYSCALL_ERROR_LABEL
/* Successful; return the syscall's value. */ L(pseudo_end):
ret ……
代码# define __socket socket 将__socket 定义为 socket，因此 ENTRY (__socket)即为 ENTRY (socket) 在这段汇编代码中，我们在 eax 保存当前系统调用号（这里是 socketcall），查看 SYS_ify 的定义，在 glibc/sysdeps/unix/sysv/linux/i386/sysdep.h 中：
#ifndef _SYS_SOCKETCALL_H #define _SYS_SOCKETCALL_H 1
/* Define unique numbers for the operations permitted on socket. Linux uses a single system call for all these functions. The relevant code file is /usr/include/linux/net.h. We cannot use a enum here because the values are used in assembler code. */
movl $SYS_ify(socketcall), %eax /* System call number in %eax. */
/* Use ## so `socket' is a separate token that might be #define'd. */
Linux下C语言的socket函数解析
Linux下C语言的socket函数解析socketsocket()我们使用系统调用socket()来获得文件描述符：#include#includeint socket(int domain,int type,int protocol);第一个参数domain设置为“AF_INET”。
第二个参数是套接口的类型：SOCK_STREAM或SOCK_DGRAM。
第三个参数设置为0。
系统调用socket()只返回一个套接口描述符，如果出错，则返回-1。
bind()一旦你有了一个套接口以后，下一步就是把套接口绑定到本地计算机的某一个端口上。
但如果你只想使用connect()则无此必要。
下面是系统调用bind()的使用方法：#include#includeintbind(int sockfd,struct sockaddr*my_addr,int addrlen);第一个参数sockfd是由socket()调用返回的套接口文件描述符。
第二个参数my_addr是指向数据结构sockaddr的指针。
数据结构sockaddr中包括了关于你的地址、端口和IP地址的信息。
第三个参数addrlen可以设置成sizeof(structsockaddr)。
下面是一个例子：#include#include#include#define MYPORT 3490main(){int sockfd;struct sockaddr_inmy_addr;sockfd=socket(AF_INET,SOCK_STREAM,0);/*do someerror checking!*/my_addr.sin_family=AF_INET;/*hostbyteorder*/my_addr.sin_port=htons(MYPORT);/*short,network byte order*/my_addr.sin_addr.s_addr=inet_addr("132.241.5.10");bzero(&(my_addr.sin_zero),8);/*zero the rest of the struct*//*don't forget your error checking for bind():*/bind(sockfd,(struct sockaddr*)&my_addr,sizeof(struct sockaddr));...如果出错，bind()也返回-1。
Linux下connect超时处理（总结）
Linux下connect超时处理（总结）1、前⾔最近在写⼀个测试⼯具，要求快速的⾼效率的扫描出各个服务器开放了哪些端⼝。
当时想了⼀下，ping只能检测ip，判断服务器的⽹络是连通的，⽽不能判断是否开放了端⼝。
我们知道端⼝属于⽹络的传输层，因此需要⽤ip和端⼝来探测，这个时候就可以⽤connect来探测⼀下，针对TCP协议，connect函数要进⾏TCP三次握⼿，如果connect成功，则说明服务器开放了某个端⼝，如果connect失败，则说明服务器没有开放某个端⼝。
⽽connect失败是通过超时来控制的，在规定的时间内，connect 会发起多次连接，⼀直执⾏到超时，才返回错误。
默认情况下，connect是阻塞的，⽽且默认的超时时间为75s，正常情况下，检测⽹络的连通性都是毫秒级，如果要判断10万台服务器的，⽤阻塞的默认的connect去做，效率⾮常低下。
因此采⽤⾮阻塞的connect，⽽且需要⾃定义超时间（我⾃定义超时时间为5s）。
2、⾮阻塞connect对于阻塞式套接字，调⽤connect函数将激发TCP的三次握⼿过程，⽽且仅在连接建⽴成功或者出错时才返回；对于⾮阻塞式套接字，如果调⽤connect函数会之间返回-1（表⽰出错），且错误为EINPROGRESS，表⽰连接建⽴，建⽴启动但是尚未完成；如果返回0，则表⽰连接已经建⽴，这通常是在服务器和客户在同⼀台主机上时发⽣。
select是⼀种IO多路复⽤机制，它允许进程指⽰内核等待多个事件的任何⼀个发⽣，并且在有⼀个或者多个事件发⽣或者经历⼀段指定的时间后才唤醒它。
connect本⾝并不具有设置超时功能，如果想对套接字的IO操作设置超时，可使⽤select函数。
对于select和⾮阻塞connect，注意两点：[1] 当连接成功建⽴时，描述符变成可写； [2] 当连接建⽴遇到错误时，描述符变为即可读，也可写，遇到这种情况，可调⽤getsockopt函数。
linux下recvsend阻塞非阻塞区别和用法
linux下recv、send阻塞、非阻塞区别和用法非阻塞IO 和阻塞IO：在网络编程中对于一个网络句柄会遇到阻塞IO 和非阻塞IO 的概念, 这里对于这两种socket 先做一下说明：基本概念：阻塞IO::socket 的阻塞模式意味着必须要做完IO 操作（包括错误）才会返回。
非阻塞IO::非阻塞模式下无论操作是否完成都会立刻返回，需要通过其他方式来判断具体操作是否成功。
(对于connect，accpet操作，通过select判断，对于recv，recvfrom，send，sendto 通过返回值+错误码来判断)IO模式设置：SOCKET对于一个socket 是阻塞模式还是非阻塞模式的处理方法::方法：：用fcntl 设置;用F_GETFL获取flags,用F_SETFL设置flags|O_NONBLOCK;同时，recv,send 时使用非阻塞的方式读取和发送消息，即flags设置为MSG_DONTWAIT实现fcntl 函数可以将一个socket 句柄设置成非阻塞模式:flags = fcntl(sockfd, F_GETFL, 0);//获取文件的flags值。
fcntl(sockfd, F_SETFL, flags | O_NONBLOCK); //设置成非阻塞模式；flags = fcntl(sockfd,F_GETFL,0);fcntl(sockfd,F_SETFL,flags&~O_NONBLOCK); //设置成阻塞模式；并在接收和发送数据时:将recv, send 函数的最后有一个flag 参数设置成MSG_DONTWAITrecv(sockfd, buff, buff_size,MSG_DONTWAIT); //非阻塞模式的消息发送send(scokfd, buff, buff_size, MSG_DONTWAIT); //非阻塞模式的消息接受普通文件对于文件的阻塞模式还是非阻塞模式::方法1、open时，使用O_NONBLOCK；方法2、fcntl设置，使用F_SETFL，flags|O_NONBLOCK；消息队列对于消息队列消息的发送与接受:://非阻塞msgsnd(sockfd,msgbuf,msgsize(不包含类型大小),IPC_NOWAIT)//阻塞msgrcv(scokfd,msgbuf,msgsize(**),msgtype,IPC_NOWAIT);读阻塞与非阻塞读的区别: //阻塞和非阻塞的区别在于没有数据到达的时候是否立刻返回．读(read/recv/msgrcv):读的本质来说其实不能是读,在实际中, 具体的接收数据不是由这些调用来进行,是由于系统底层自动完成的。
linux accept4用法
linux accept4用法# Linux accept4用法详解Linux系统提供了一种叫做`accept4()`的系统调用，它用于在监听套接字上接受新的连接请求。
本文将详细介绍`accept4()`函数的使用方法和注意事项。
## 1. `accept4()`函数原型```c#include <sys/socket.h>int accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags);```- 参数说明：- sockfd：已监听的套接字描述符。
- addr：用于返回远程地址信息的缓冲区。
- addrlen：指向addr缓冲区长度的指针。
- flags：设置文件描述符标志，可以是以下几种组合：- SOCK_CLOEXEC：关闭exec时自动关闭此文件描述符。
- SOCK_NONBLOCK：使新套接字处于非阻塞模式。
## 2. `accept4()`函数返回值成功执行时，`accept4()`返回一个新的套接字描述符，该描述符与客户端建立了一个连接。
错误发生时，返回-1，并将错误代码存储在`errno`中。
## 3. `accept4()`函数示例下面是一个简单的`accept4()`函数使用示例：```c#include <stdio.h>#include <stdlib.h>#include <string.h>#include <unistd.h>#include <sys/socket.h>#include <netinet/in.h>#include <arpa/inet.h>#define PORT 8080int main(void) {int server_sockfd, client_sockfd;struct sockaddr_in server_addr, client_addr;socklen_t client_len;// 创建一个TCP socketif ((server_sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) { perror("socket");exit(1);}// 设置服务器端口和IP地址memset(&server_addr, 0, sizeof(server_addr));server_addr.sin_family = AF_INET;server_addr.sin_port = htons(PORT);server_addr.sin_addr.s_addr = htonl(INADDR_ANY);// 绑定到本地地址if (bind(server_sockfd, (struct sockaddr*)&server_addr,sizeof(server_addr)) == -1) {perror("bind");exit(1);}// 开始监听连接请求if (listen(server_sockfd, 5) == -1) {perror("listen");exit(1);}printf("Server listening on port %d...\n", PORT);while (1) {// 接受新的连接请求if ((client_sockfd = accept4(server_sockfd, (structsockaddr*)&client_addr, &client_len, SOCK_CLOEXEC|SOCK_NONBLOCK)) == -1) {perror("accept4");continue;}printf("Accepted connection from %s:%d\n",inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));// 这里处理客户端连接...}return 0;}```在这个例子中，我们创建了一个TCP服务器，监听8080端口。
socket阻塞和非阻塞的用法
在Python中，socket默认是阻塞的。
对于阻塞的socket，当调用recv()函数时，如果数据没有准备好，那么系统就会等待数据。
如果数据准备好后，系统会将数据从系统内核缓冲区复制到用户空间，然后该函数返回。
对于非阻塞的socket，当调用recv()函数时，即使数据没有准备好，也不会阻塞，而是直接返回。
以下是socket阻塞和非阻塞的用法示例：1. socket阻塞模式：```pythonimport socket# 创建一个socket对象s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)# 连接服务器s.connect()# 接收数据，如果数据没有准备好，就会一直等待data = s.recv(1024)2. socket非阻塞模式：```pythonimport socketimport select# 创建一个socket对象s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)# 设置socket为非阻塞模式s.setblocking(False)# 连接服务器s.connect()# 创建select对象，将socket对象添加进去r, w, e = select.select([s], [], [])# 接收数据，如果数据没有准备好，就会直接返回None data = s.recv(1024) if r else None注意：在非阻塞模式下，如果没有数据可读，recv()函数会立即返回None。
因此，在使用非阻塞模式时，需要不断循环检查是否有数据可读，直到接收到所有需要的数据。
linux下串口的阻塞和非阻塞操作
linux下串口的阻塞和非阻塞操作linux下串口的阻塞和非阻塞操作[cpp]有两个可以进行控制串口阻塞性（同时控制read和write）：一个是在打开串口的时候，open函数是否带O_NDELAY；第二个是可以在打开串口之后通过fcntl()函数进行控制。
阻塞的定义：对于read，block指当串口输入缓冲区没有数据的时候，read函数将会阻塞在这里，移植到串口输入缓冲区中有数据可读取，read读到了需要的字节数之后，返回值为读到的字节数；对于write，block指当串口输出缓冲区满，或剩下的空间小于将要写入的字节数，则write将阻塞，一直到串口输出缓冲区中剩下的空间大于等于将要写入的字节数，执行写入操作，返回写入的字节数。
非阻塞的定义：对于read，no block指当串口输入缓冲区没有数据的时候，read函数立即返回，返回值为0。
对于write，no block指当串口输出缓冲区满，或剩下的空间小于将要写入的字节数，则write将进行写操作，写入当前串口输出缓冲区剩下空间允许的字节数，然后返回写入的字节数。
[cpp]static int set_opt(int fd, int nSpeed, int nBits, char nEvent, int nStop) { struct termios newtio;struct termios oldtio;if(tcgetattr(fd,&oldtio) != 0){ perror("SetupSerial 1"); return -1; }bzero(&newtio,sizeof(newtio)); newtio.c_cflag |= CLOCAL |CREAD; newtio.c_cflag &=~CSIZE; /***********数据位选择****************/ switch(nBits){ case 7: newtio.c_cflag |= CS7; break; case 8: newtio.c_cflag |= CS8; break; }/***********校验位选择****************/switch(nEvent) { case 'O':newtio.c_cflag |= PARENB; newtio.c_cflag |= PARODD; newtio.c_iflag |= (INPCK | ISTRIP); break; case 'E': newtio.c_iflag |= (INPCK |ISTRIP); newtio.c_cflag |= PARENB; newtio.c_cflag &= ~PARODD; break;case 'N': newtio.c_cflag &= ~PARENB; break; } /***********波特率选择****************/ switch(nSpeed){ case 2400:cfsetispeed(&newtio,B2400);cfsetospeed(&newtio,B2400); break; case 4800: cfsetispeed(&newtio,B4800); cfsetospeed(&newtio,B4800); break; case 9600: cfsetispeed(&newtio,B9600); cfsetospeed(&newtio,B9600); break; case 57600: cfsetispeed(&newtio,B57600); cfsetospeed(&newtio,B57600); break; case 115200:cfsetispeed(&newtio,B115200);cfsetospeed(&newtio,B115200); break; case 460800:cfsetispeed(&newtio,B460800);cfsetospeed(&newtio,B460800); break; default: cfsetispeed(&newtio,B9600); cfsetospeed(&newtio,B9600);break; } /***********停止位选择****************/ if(nStop ==1){ newtio.c_cflag &=~CSTOPB; } else if(nStop==2){ newtio.c_cflag |= CSTOPB; } newtio.c_cc[VTIME] = 1; newtio.c_cc[VMIN] = FRAME_MAXSIZE; //阻塞条件下有效tcflush(fd,TCIFLUSH);if((tcsetattr(fd,TCSANOW,&newtio)) != 0){ perror("com set error"); return -1; } printf("set done!\n"); return 0; }[cpp] view plaincopy?static int open_port(int fd,int comport) { /***********打开串口1****************/if(comport == 1) { fd =open("/dev/ttyAT1",O_RDWR|O_NOCTTY|O_NDELAY);if(fd == -1){ perror("Can't Open Serial Port"); return -1; } } /***********打开串口2****************/ else if(comport == 2) { fd =open("/dev/ttyAT2",O_RDWR|O_NOCTTY|O_NDELAY);if(fd == -1){ perror("Can't Open Serial Port"); return-1; } } /***********打开串口3****************/ else if(comport == 3){ fd =open("/dev/ttyAT3",O_RDWR|O_NOCTTY|O_NDELAY);if(fd == -1){ perror("Can't Open Serial Port"); return-1; } } if(comport == 1) { if(fcntl(fd,F_SETFL,FNDELAY) < 0)//非阻塞，覆盖前面open的属性{ printf("fcntl failed\n"); } else{ printf("fcntl=%d\n",fcntl(fd,F_SETFL,FN DELAY)); } } else{ if(fcntl(fd,F_SETFL,0) < 0){ //阻塞，即使前面在open串口设备时设置的是非阻塞的，这里设为阻塞后，以此为准printf("fcntl failed\n"); } else{ printf("fcntl=%d\n",fcntl(fd,F_SETFL,0));} } if(isatty(STDIN_FILENO) == 0){ printf("standard input is not a terminal device\n"); }else{ printf("isattysucess!\n"); } printf("fd-open=%d\n",fd); return fd; }所以，linux的串口的阻塞性通过fcntl()函数进行设置即可。
五种IO 模式
五种IO 模式五种I/O 模式——阻塞(默认IO模式)，非阻塞(常用语管道)，I/O多路复用(IO多路复用的应用场景)，信号I/O，异步I/O 五种I/O 模式：【1】阻塞I/O (Linux下的I/O操作默认是阻塞I/O，即open和socket创建的I/O都是阻塞I/O) 【2】非阻塞I/O (可以通过fcntl或者open 时使用O_NONBLOCK参数，将fd设置为非阻塞的I/O) 【3】I/O 多路复用(I/O多路复用，通常需要非阻塞I/O配合使用)【4】信号驱动I/O (SIGIO)【5】异步I/O 一般来说，程序进行输入操作有两步：1．等待有数据可以读2．将数据从系统内核中拷贝到程序的数据区。
对于sock编程来说: 第一步: 一般来说是等待数据从网络上传到本地。
当数据包到达的时候，数据将会从网络层拷贝到内核的缓存中；第二步: 是从内核中把数据拷贝到程序的数据区中。
阻塞I/O模式//进程处于阻塞模式时，让出CPU，进入休眠状态阻塞I/O 模式是最普遍使用的I/O 模式。
是Linux系统下缺省的IO模式。
大部分程序使用的都是阻塞模式的I/O 。
一个套接字建立后所处于的模式就是（因为Linux系统默认的IO模式是阻塞模式）阻塞I/O 模式。
对于一个UDP 套接字来说，数据就绪的标志比较简单：（1）已经收到了一整个数据报（2）没有收到。
而TCP 这个概念就比较复杂，需要附加一些其他的变量。
一个进程调用recvfrom ，然后系统调用并不返回知道有数据报到达本地系统，然后系统将数据拷贝到进程的缓存中。
（如果系统调用收到一个中断信号，则它的调用会被中断）我们称这个进程在调用recvfrom一直到从recvfrom返回这段时间是阻塞的。
当recvfrom正常返回时，我们的进程继续它的操作。
非阻塞模式I/O//非阻塞模式的使用并不普遍，因为非阻塞模式会浪费大量的CPU资源。
当我们将一个套接字设置为非阻塞模式，我们相当于告诉了系统内核：“当我请求的I/O 操作不能够马上完成，你想让我的进程进行休眠等待的时候，不要这么做，请马上返回一个错误给我。
linux socket状态 函数 -回复
linux socket状态函数-回复Linux socket状态函数是指用于获取和设置socket连接状态信息的特定函数集合。
这些函数非常重要，因为它们允许开发人员监视和控制网络连接的各个方面，从而确保网络应用程序的可靠性和稳定性。
本文将详细介绍Linux socket状态函数的使用和原理，并提供一些常见的实例和应用场景。
一、什么是socket状态函数Socket状态函数是一组用于获取和设置socket连接状态的API函数。
它们允许开发人员查询和修改socket连接的各个方面，包括连接的状态、缓冲区状态、传输层协议状态等。
通过使用这些函数，开发人员能够更好地监控和管理其网络应用程序，以确保其可靠性和稳定性。
在Linux系统中，socket状态函数主要包括以下几个关键函数：1. getsockopt：用于获取socket选项的值，如缓冲区大小、超时值等。
2. setsockopt：用于设置socket选项的值，如缓冲区大小、超时值等。
3. ioctl：用于控制socket的属性和状态，如非阻塞I/O、接收和发送缓冲区大小等。
4. poll/epoll：用于监视和等待多个socket文件描述符的状态变化，以便及时处理网络事件。
二、getsockopt函数详解getsockopt函数用于获取socket选项的值。
它的原型如下：cint getsockopt(int sockfd, int level, int optname, void *optval, socklen_t *optlen);其中，sockfd是socket文件描述符，level表示选项所属的协议层，如SOL_SOCKET表示socket级选项，optname表示具体的选项名称，optval是用于存放选项值的缓冲区，optlen表示缓冲区的长度。
3.1）常见使用场景getsockopt函数广泛应用于网络编程中，主要用于获取和查询socket的各个状态和属性。
Window和Linux下Socket的区别
Window和Linux下Socket的区别1)头文件windows下winsock.h或winsock2.hlinux下netinet/in.h（大部分都在这儿），unistd.h（close函数在这儿），sys/socket.h（在in.h里已经包含了，可以省了），错误处理：errno.h2)初始化windows下需要用WSAStartup启动Ws2_32.lib，并且要用#pragma comment(lib,"Ws2_32")来告知编译器链接该lib。
linux下不需要WSADATA wsaData;err = WSAStartup(0x202,&wsaData);if ( err != 0 ){return 0;}else if ( LOBYTE( wsaData.wVersion ) != 2 || HIBYTE( wsaData.wVersion ) != 2 ) //检测是否支持这个版本{WSACleanup( );return 0;对应的退出清理用WSACleanup( );3)关闭socketwindows下closesocket(...)linux下close(...)4)类型windows下SOCKETlinux下int（我喜欢用long，这样保证是4byte，因为-1我总喜欢写成0xFFFF）5)获取错误码windows下getlasterror()/WSAGetLastError(),linux下，未能成功执行的socket操作会返回-1；如果包含了errno.h，就会设置errno变量extern int errno;int geterror(){return errno;}6)设置非阻塞windows下ioctlsocket() linux下fcntl()，需要头文件fcntl.hwindows下ioctlsocket(server_socket,FIONBIO,&ul); int ul = 1linux下fcntl(server_socket,F_SETFL, O_NONBLOCK); 包含头文件<fcntl.h>7)send函数最后一个参数windows下一般设置为0linux下最好设置为MSG_NOSIGNAL，如果不设置，在发送出错后有可能会导致程序退出linux下必须是后几个参数用到的socket中，值最大的数（整型）加1（另一种说法是设置为MSG_NOSIGNAL）8)毫秒级时间获取windows下GetTickCount()linux下gettimeofday()9)编译连接windows下ws2_32.liblinux下连接是使用参数：-lstdc运行时需要libstdc++.so.5，可在/usr/lib目录中创建一个链接。
linux下文件描述符状态详细解释 -回复
linux下文件描述符状态详细解释-回复Linux下文件描述符（File Descriptor）是一种抽象概念，用于表示打开的文件、套接字和其他I/O设备。
在Linux系统中，每个进程都有一个文件描述符表，该表记录了进程所打开的文件和设备的信息。
文件描述符是非负整数，其范围一般是0到最大文件描述符的数值。
文件描述符状态是指文件描述符在不同的情况下所处的状态，包括可读写状态、阻塞状态、非阻塞状态等。
不同的状态会影响对文件的读写操作。
下面将详细解释Linux下文件描述符状态的各个方面。
1. 可读写状态（RDWR）可读写状态是文件描述符最常见的状态，表示该文件描述符既可以读取也可以写入数据。
当文件描述符处于可读写状态时，进程可以通过相应的系统调用函数（如read()和write()）来读取和写入文件。
例如，一个打开的文件可以被读取和写入新的数据。
2. 只读状态（RDONLY）只读状态是文件描述符的一种特殊状态，表示该文件描述符只能读取数据，不能对文件进行写入操作。
如果一个文件被打开为只读状态，那么进程可以通过read()函数来读取文件中的数据，但不允许使用write()函数对文件进行写入操作。
这种状态在保护文件的完整性和只读文件的访问权限时非常有用。
3. 只写状态（WRONLY）只写状态与只读状态相反，表示该文件描述符只能对文件进行写入操作，不能读取文件中的数据。
如果一个文件被打开为只写状态，那么进程可以通过write()函数将数据写入文件，但不允许使用read()函数读取文件的内容。
这种状态在某些场景下很有用，比如创建一个新文件，或者将数据追加到已有文件的末尾。
4. 阻塞状态（BLOCK）阻塞状态是指当对文件描述符进行读写操作时，进程会被阻塞，直到操作完成或者发生错误。
在阻塞状态下，系统调用函数会一直等待，直到读取或写入操作完成或者出错。
阻塞状态是默认状态，即文件描述符默认情况下是以阻塞方式进行读写操作的。
linux socket 面试题
linux socket 面试题Linux Socket面试题在进行Linux Socket面试时，以下是一些可能会出现的问题及其答案，请参考：1. 什么是Socket？Socket是一种网络通信协议，它允许不同的计算机在网络上进行通信。
通过Socket，可以建立客户端和服务器之间的连接，实现数据的发送和接收。
2. 什么是TCP和UDP？TCP和UDP是两种常见的传输层协议。
TCP（Transmission Control Protocol）提供可靠的、面向连接的通信，确保数据的可靠传输。
UDP （User Datagram Protocol）是一种无连接的通信协议，它更加轻量级，但不保证数据的可靠性。
3. Socket通信的基本流程是什么？Socket通信的基本流程包括以下几个步骤：- 创建Socket：使用socket()函数创建一个新的socket对象。
- 绑定地址：使用bind()函数将socket与IP地址和端口号进行绑定。
- 监听连接请求：使用listen()函数监听客户端的连接请求。
- 接受连接：使用accept()函数接受客户端的连接请求，建立与客户端的连接。
- 数据收发：使用send()和recv()函数进行数据的发送和接收。
- 关闭连接：使用close()函数关闭连接。
4. Socket通信中的IP地址和端口号有什么作用？IP地址用于标识计算机在网络上的唯一位置，而端口号则用于标识计算机中的进程或服务。
在Socket通信中，客户端需要指定服务器的IP地址和端口号才能建立连接，而服务器则需要绑定一个固定的端口号来监听连接请求。
5. 如何实现多个客户端与服务器的通信？可以使用多线程或多进程来实现多个客户端与服务器的通信。
每个客户端连接到服务器后，服务器可以为每个客户端创建一个新的线程或进程来处理与该客户端的通信。
6. 如何处理并发连接？在处理并发连接时，可以使用多路复用技术。
Linux提供了select()、poll()和epoll()等函数，可以同时监听多个Socket，当其中任何一个Socket有数据到达时，通过对应的文件描述符判断是哪个Socket有数据到达，并进行处理。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Linux下socket设置为非阻塞方式和fcntl系统调用
[日期：2011-04-16]来源：Linux社区作者：Linux
用以下方法将socket设置为非阻塞方式
int flags = fcntl(socket, F_GETFL, 0);
fcntl(socket, F_SETFL, flags | O_NONBLOCK);
用以下方法将socket设置为非阻塞方式
int flags = fcntl(socket, F_GETFL, 0);
fcntl(socket, F_SETFL, flags | O_NONBLOCK);
将非阻塞的设置回阻塞可以用
int flags = fcntl(socket, F_GETFL, 0);
fcntl(socket, F_SETFL, flags & ~O_NONBLOCK);
功能描述：根据文件描述词来操作文件的特性。
用法：
int fcntl(int fd, int cmd);
int fcntl(int fd, int cmd, long arg);
int fcntl(int fd, int cmd, struct flock *lock);
参数：
fd：文件描述词。
cmd：操作命令。
arg：供命令使用的参数。
lock：同上。
有以下操作命令可供使用
一. F_DUPFD ：复制文件描述词。
二. FD_CLOEXEC ：设置close-on-exec标志。
如果FD_CLOEXEC位是0，执行execve的过程中，文件保持打开。
反之则关闭。
三. F_GETFD ：读取文件描述词标志。
四. F_SETFD ：设置文件描述词标志。
五. F_GETFL ：读取文件状态标志。
六. F_SETFL ：设置文件状态标志。
其中O_RDONLY， O_WRONLY， O_RDWR， O_CREAT， O_EXCL， O_NOCTTY 和 O_TRUNC不受影响，
可以更改的标志有 O_APPEND，O_ASYNC， O_DIRECT， O_NOATIME 和 O_NONBLOCK。
七. F_GETLK, F_SETLK 和 F_SETLKW ：获取，释放或测试记录锁，使用到的参数是以下结构体指针：
F_SETLK：在指定的字节范围获取锁（F_RDLCK, F_WRLCK）或者释放锁（F_UNLCK）。
如果与另一个进程的锁操作发生冲突，返回 -1并将errno设置为EACCES或EAGAIN。
F_SETLKW：行为如同F_SETLK，除了不能获取锁时会睡眠等待外。
如果在等待的过程中接收到信号，会立即返回并将errno置为EINTR。
F_GETLK：获取文件锁信息。
F_UNLCK：释放文件锁。
为了设置读锁，文件必须以读的方式打开。
为了设置写锁，文件必须以写的方式打开。
为了设置读写锁，文件必须以读写的方式打开。
八. 信号管理
F_GETOWN, F_SETOWN, F_GETSIG 和 F_SETSIG 被用于IO可获取的信号。
F_GETOWN：获取当前在文件描述词 fd上接收到SIGIO 或 SIGURG事件信号的进程或进程组标识。
F_SETOWN：设置将要在文件描述词fd上接收SIGIO 或 SIGURG事件信号的进程或进程组标识。
F_GETSIG：获取标识输入输出可进行的信号。
F_SETSIG：设置标识输入输出可进行的信号。
使用以上命令，大部分时间程序无须使用select()或poll()即可实现完整的异步I/O。
九. 租约（ Leases）
F_SETLEASE 和 F_GETLEASE 被用于当前进程在文件上的租约。
文件租约提供当一个进程试图打开或折断文件内容时，拥有文件租约的进程将会被通告的机制。
F_SETLEASE：根据以下符号值设置或者删除文件租约
1.F_RDLCK设置读租约，当文件由另一个进程以写的方式打开或折断内容时，拥有租约的当前进程会被通告。
2.F_WRLCK设置写租约，当文件由另一个进程以读或以写的方式打开或折断内容时，拥有租约的当前进程会被通告。
3.F_UNLCK删除文件租约。
F_GETLEASE：获取租约类型。
十.文件或目录改变通告
（linux 2.4以上）当fd索引的目录或目录中所包含的某一文件发生变化时，将会向进程发出通告。
arg参数指定的通告事件有以下，两个或多个值可以通过或运算组合。
1.DN_ACCESS 文件被访问 (read, pread, readv)
2.DN_MODIFY 文件被修改(write, pwrite,writev, truncate, ftruncate)
3.DN_CREATE 文件被建立(open, creat, mknod, mkdir, link, symlink, rename)
4.DN_DELETE 文件被删除(unlink, rmdir)
5.DN_RENAME 文件被重命名(rename)
6.DN_ATTRIB 文件属性被改变(chown, chmod, utime[s])
返回说明：
成功执行时，对于不同的操作，有不同的返回值
F_DUPFD：新文件描述词
F_GETFD：标志值
F_GETFL：标志值
F_GETOWN：文件描述词属主
F_GETSIG：读写变得可行时将要发送的通告信号，或者0对于传统的SIGIO行为
对于其它命令返回0。
失败返回-1，errno被设为以下的某个值
EACCES/EAGAIN: 操作不被允许，尚未可行
EBADF: 文件描述词无效
EDEADLK: 探测到可能会发生死锁
EFAULT: 锁操作发生在可访问的地址空间外
EINTR: 操作被信号中断
EINVAL：参数无效
EMFILE: 进程已超出文件的最大可使用范围
ENOLCK: 锁已被用尽
EPERM:权能不允许
struct flock {
short l_type; /* 锁类型： F_RDLCK, F_WRLCK, F_UNLCK */
short l_whence; /* l_start字段参照点： SEEK_SET(文件头), SEEK_CUR(文件当前位置), SEEK_END(文件尾) */ off_t l_start; /* 相对于l_whence字段的偏移量 */
off_t l_len; /* 需要锁定的长度 */
pid_t l_pid; /* 当前获得文件锁的进程标识（F_GETLK） */
};
如有侵权请联系告知删除，感谢你们的配合！。