socket编程：地址已经被使用——Address already in use

今天在linux下，编写了一个简单的回射客户/服务器（就是客户机从控制台标准输入并发送数据，服务端接受数据，但是不对数据进行处理，然后将数据返回，交由客户机标准输出），然后遇到了一些问题，郁闷了好长时间，然后就想着将这些东西写下来，跟大家分享分享

1， 客户端和服务端到底那个是先退出的？？这个有什么区别吗？？（死循环）

2， 为什么有的时候bind：address already in use一直存在？？？不是说好的2-4分钟吗，，（ctrl + z 和 ctrl + c）

3， 当bind：address already in use不是一直存在时（存在2-4分钟时），如何避免？？？（SO_REUSEADDR可以让当前的端口立即重用）

为了能让上面的问题更形象一点，好理解一点（下面我添加上了源代码）

服务端：

[cpp]
view plain
copy

print?

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */

//#define INADDR_ANY 0

#define ERR_EXIT(m) \
do{ \
perror(m); \
exit(EXIT_FAILURE); \
}while(0)

int main(){

int listenfd; //socket返回值，类似于文件描述符，也成为套接字
if((listenfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
ERR_EXIT("SOCKET");

struct sockaddr_in servaddr; //inin IPv4
memset(&servaddr, 0 , sizeof(servaddr)); //inint memory
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(5188);
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
// servaddr.sin_addr.s_addr = inet_addr(192.0.0.1);
// inet_aton("127.0.0.1", &servaddr.sin_addr);

if((bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr))) < 0 ) //bind serve and IPv4
ERR_EXIT("bind");

if ((listen(listenfd, SOMAXCONN)) < 0) //change state (from initiative to passivity)
ERR_EXIT("LISTEN");

int conn; //accept's backvalue,is a connect socket
struct sockaddr_in peeraddr;
socklen_t peerlen = sizeof(peeraddr);
if((conn = (accept(listenfd, (struct sockaddr*)(&peeraddr), &peerlen))) < 0)
ERR_EXIT("accept");
printf("ip is %s, port is %d\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));
// printf("ip=%d\n", ntohs(peeraddr.sin_port));
char recvbuf[1024];
while(1){
memset(recvbuf, 0 , sizeof(recvbuf)); //inint string
int ret = read(conn , recvbuf, sizeof(recvbuf)); //receive a string
printf("服务端：%s", recvbuf);
int r = write(conn, recvbuf, ret);
}
close(conn);
close(listenfd);
}

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <netinet/ip.h> /* superset of previous */

//#define INADDR_ANY  0

#define ERR_EXIT(m)                    \
do{                            \
perror(m);             \
exit(EXIT_FAILURE);    \
}while(0)

int main(){

int listenfd;      //socket返回值，类似于文件描述符，也成为套接字
if((listenfd = socket(AF_INET,  SOCK_STREAM,  IPPROTO_TCP)) < 0)
ERR_EXIT("SOCKET");

struct  sockaddr_in servaddr;                                //inin IPv4
memset(&servaddr,  0 , sizeof(servaddr));                 //inint memory
servaddr.sin_family = AF_INET;
servaddr.sin_port   = htons(5188);
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
//      servaddr.sin_addr.s_addr = inet_addr(192.0.0.1);
//      inet_aton("127.0.0.1", &servaddr.sin_addr);

if((bind(listenfd,  (struct sockaddr*)&servaddr,  sizeof(servaddr))) < 0 )     //bind  serve and IPv4
ERR_EXIT("bind");

if ((listen(listenfd, SOMAXCONN)) < 0)                                 //change  state (from initiative to passivity)
ERR_EXIT("LISTEN");

int conn;                                                              //accept's  backvalue,is a connect socket
struct sockaddr_in peeraddr;
socklen_t peerlen = sizeof(peeraddr);
if((conn = (accept(listenfd, (struct sockaddr*)(&peeraddr), &peerlen))) < 0)
ERR_EXIT("accept");
printf("ip is %s,  port is %d\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));
//      printf("ip=%d\n", ntohs(peeraddr.sin_port));
char recvbuf[1024];
while(1){
memset(recvbuf, 0 , sizeof(recvbuf));  //inint  string
int ret = read(conn , recvbuf, sizeof(recvbuf)); //receive a string
printf("服务端：%s", recvbuf);
int r = write(conn,  recvbuf, ret);
}
close(conn);
close(listenfd);
}

客户端：

[cpp]
view plain
copy

print?

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <netinet/in.h>

#define ERR_EXIT(m) \
do{ \
perror(m); \
exit(EXIT_FAILURE); \
}while(0)

int main(){

int sock; //socket返回值，类似于文件描述符，也成为套接字
if((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
ERR_EXIT("SOCKET");

struct sockaddr_in servaddr; //inin IPv4
memset(&servaddr, 0 , sizeof(servaddr)); //inint memory
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(5188);
servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
// inet_aton("127.0.0.1", &servaddr.sin_addr);

if (connect(sock, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)
ERR_EXIT("CONNECT");

char sendrec[1024] = {0};
char recerec[1024] = {0};

while( fgets(sendrec , sizeof(sendrec), stdin) != NULL){
write(sock , sendrec, strlen(sendrec));
read(sock, recerec, sizeof(recerec));

printf("客户端： %s\n", recerec);

memset(sendrec , 0, sizeof(sendrec));
memset(recerec, 0, sizeof(sendrec));

}
close(sock);
}

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <netinet/in.h>

#define ERR_EXIT(m)                    \
do{                            \
perror(m);             \
exit(EXIT_FAILURE);    \
}while(0)

int main(){

int sock;      //socket返回值，类似于文件描述符，也成为套接字
if((sock = socket(AF_INET,  SOCK_STREAM,  IPPROTO_TCP)) < 0)
ERR_EXIT("SOCKET");

struct  sockaddr_in servaddr;                                //inin IPv4
memset(&servaddr,  0 , sizeof(servaddr));                 //inint memory
servaddr.sin_family = AF_INET;
servaddr.sin_port  = htons(5188);
servaddr.sin_addr.s_addr  = inet_addr("127.0.0.1");
//     inet_aton("127.0.0.1", &servaddr.sin_addr);

if (connect(sock,  (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)
ERR_EXIT("CONNECT");

char sendrec[1024] = {0};
char recerec[1024] = {0};

while( fgets(sendrec  , sizeof(sendrec),  stdin) != NULL){
write(sock , sendrec, strlen(sendrec));
read(sock,   recerec, sizeof(recerec));

printf("客户端：  %s\n", recerec);

memset(sendrec , 0,  sizeof(sendrec));
memset(recerec,  0,  sizeof(sendrec));

}
close(sock);
}

1， 关于客户端还是服务端退出的先后顺序？？

至于是服务器还是客户端是谁先启动的，这个应该比较确定，服务器首先启动，bind处于祯听状态（祯听连接的客户端的个数），accept接受来自客户端的数据请求，然后对数据进行处理，并把数据返回给客户端，倘使是客户端先启动的话，那么它发送的数据也就不能完全的保证服务端是不是打开，影响数据传输的准确性和安全性

UNIX网络编程（基本TCP套接字编程78页）给出了一个解释说的是：当我们关闭客户端后，客户端会发送一个数据（EOF，也就是-1），然后服务端通过read（）函数收到这个数据,，知道了客户端已经退出，所以服务端也就推出了程序，并且调用相应的close操作。（个人理解）

我们来验证一下：



从上面可以看出来，完美的把数据发送到了服务端并把数据发送回来啦，

但是：如果我们先结束服务端呢？？



从上图还可以看出：如果我们先结束了服务器（ctrl+c），那么客户端是不会立即退出的，可是在发一次数据便会自动退出，这是因为在正常通信中，服务器关闭了连接，那么客户端会正常接收到EOF，，如果对这个连接用epoll或者select进行监听，可以马上得知服务器关闭了连接。否则就定时向服务器发心跳探测，不然是不太可能得知服务器目前的状态的。之所以你现在不会立刻发现问题是因为服务器退出后，客户端需要靠下一次send才会触发问题，因为这时候连接已关闭，而客户端继续写，会产生SIGPIPE异常，而这个异常的默认动作是进程终止，所以你的客户端退出了。

如果：是我们的客户端先结束的呢？？



同样的，从上图可以看出，当我们的客户端先结束后（ctrl + c），我们的服务器直接进入死循环，但是是为什么呢？？

经过不断的查错：才发现是我们没有对服务端的while里面进行退出程序的处理，里面刚好有一个，printf打印的语句，所以会出现安一直循环的情况，我们把里面的语句改一下：

[cpp]
view plain
copy

print?

while(1){ memset(recvbuf, 0 , sizeof(recvbuf)); int ri = read(conn , recvbuf, sizeof(recvbuf)); //receive a stri // int ret = (sizeof(recvbuf)); if ( ri == -1){ printf("one client closed\n"); break; } printf("服务端：%s,", recvbuf); int r = write(conn, recvbuf, ri); } }

while(1){
memset(recvbuf, 0 , sizeof(recvbuf));
int ri = read(conn , recvbuf, sizeof(recvbuf)); //receive a stri
//              int ret = (sizeof(recvbuf));
if ( ri == -1){
printf("one client closed\n");
break;
}
printf("服务端：%s,", recvbuf);
int r = write(conn,  recvbuf, ri);
}
}

嗯嗯，这回应该好啦（因为客户端结束后传回的是EOF，read是服务端接收客户端的消息，所以我们就让read等于-1）

但是，但是，但是，不幸的是，这个语句还是没有起作用，就是说，当客户端结束后，服务端还是在死循环里面？？这又是为什m,啊啊啊啊啊？？？（博主快爆炸了都！！！）

后来经过经过仔细的查资料，才发现这个：当客户端结束后，服务端read（）函数返回的应该是0,而不是-1，，

所以我的程序有改了一改：

[cpp]
view plain
copy

print?

while(1){ memset(recvbuf, 0 , sizeof(recvbuf)); int ri = read(conn , recvbuf, sizeof(recvbuf)); //receive a stri // int ret = (sizeof(recvbuf)); if ( ri == 0){ break; } printf("服务端：%s,", recvbuf); int r = write(conn, recvbuf, ri); } }

while(1){
memset(recvbuf, 0 , sizeof(recvbuf));
int ri = read(conn , recvbuf, sizeof(recvbuf)); //receive a stri
//              int ret = (sizeof(recvbuf));
if ( ri == 0){
break;
}
printf("服务端：%s,", recvbuf);
int r = write(conn,  recvbuf, ri);
}
}

嗯嗯，这样就好啦，可以对其进行处理了！！！！

当然，对于多个客户端的情况就是这样了：

[cpp]
view plain
copy

print?

while(1){
if((conn = (accept(listenfd, (struct sockaddr*)(&peeraddr), &peerlen))) < 0)
ERR_EXIT("accept");
printf("ip is %s, port is %d\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));
// printf("ip=%d\n", ntohs(peeraddr.sin_port));

pid = fork();
if(pid == -1)
ERR_EXIT("fork");
else if(pid == 0){
close(listenfd);
do_service(conn);
exit(1);
}
else
close(conn);
}

while(1){
if((conn = (accept(listenfd, (struct sockaddr*)(&peeraddr), &peerlen))) < 0)
ERR_EXIT("accept");
printf("ip is %s,  port is %d\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));
//              printf("ip=%d\n", ntohs(peeraddr.sin_port));

pid = fork();
if(pid == -1)
ERR_EXIT("fork");
else if(pid == 0){
close(listenfd);
do_service(conn);
exit(1);
}
else
close(conn);
}

我们上面程序里的do_service(conn)函数，其实就是之前提到的while，对数据进行具体的收发

这里，为了完成多个客户端的访问情况，我们设置了进程（fork）



所以可以完全看到合理的结果，最左边的那个客户端退出了之后，服务端并没有退出，同样的，最右边的客户端还是可以收发数据的！！！

当然，一个客户端一个服务器的情况，同样的，对于多个客户端也是如此的，我们的某一个客户端退出并不会影响服务器的运行结果的，哈哈，对，就是这样！！！，举一个例子：我们好多人在同时访问百度服务器，但是，我们不能让某一个人退出这个页面，而导致其他的人的页面也退出啊！！！

2， bind：address already in use一直存在，它就关不掉

首先，我们先声明：bind：address already in use的存在是合理的，在服务端终止之后，会有一个TIME_WAIT的状态，再次打开会出现：bind的

但是，服务器端可以尽可能的使用REUSEADDR（在绑定之前尽可能调用setsockopt来设置REUSEADDR）套接字选项，这样就可以使得不必等待TIME_WAIT状态就可以重启服务器了,也就是说：TIME_WAIT状态还是存在的，但是不影响我们重新启动服务器

下面讨论的情况还是一样：一个客户端，一个服务器，根据上面说的情况，还是服务端先退出，然后是客户端，但是为什么：bind：address already in use 还是一直存在（即使我们等了好长时间），其实这个很简单，那只是因为我们在退出服务端或者客户端的时候，我们是用了 CTRL + Z,这个退出条件，跟CTRL+C搞混了！！！

CTRL+C：发送SIGINT信号给前台进程组中的所有进程。常用于终止正在运行的程序，强制中断程序的执行

CTRL+Z：发送SIGTSTP信号给前台进程组中的所有进程，常用于挂起一个进程，是将任务中断，但是此任务并没有结束，它仍然在进程中他只是维持挂起的状态，用户可以使用fg/bg操作继续前台或后台的任务，fg命令重新启动前台被中断的任务，bg命令把被中断的任务放在后台执行

通过我们上面所说的：可以使用这个命令查看状态

2，当我们用：CTRL+C结束时：



可以看到右下角：出现了TIME_WAIT

当我们想重新运行这两个程序时：就会出现（bind：address already in use）的情况（我们在两分钟以内运行）

但是，当我们等上个2-4分钟后，然后在运行，就又没有这种情况了，很好解释，那只是因为在一定的时间内这个端口还被占用着，没有来的及释放，但是2-4分钟后，端口释放完毕，所以可以正常的运行这个程序了

当我们用：CTRL+Z结束时：



同样的：我们可以看到右下角：出现的是ESTABLISHED，但是不一样的是，无论我们等多久，只要我们一运行这个服务端程序，必定会出现bind：address already in use，并且这个不会自动消失，除非我们杀死这个进程，或者我们进到程序里面改一下端口号

ESTABLISHED的意思是建立连接。表示两台机器正在通信。

TIME_WAIT：我方主动调用close()断开连接，收到对方确认后状态变为TIME_WAIT。TCP协议规定TIME_WAIT状态会一直持续2MSL(即两倍的分
段最大生存期)，以此来确保旧的连接状态不会对新连接产生影响。处于TIME_WAIT状态的连接占用的资源不会被内核释放，所以作为服务器，在可能的情 况下，尽量不要主动断开连接，以减少TIME_WAIT状态造成的资源浪费。目前有一种避免TIME_WAIT资源浪费的方法，就是关闭socket的LINGER选项。但这种做法是TCP协议不推荐使用的，在某些情况下这个操作可能会带来错误。

3，当我们用：setsockopt和SO_REUSEADDR时：充分的减少了等待时间，在一次的通讯完毕，可以直接再次的运行这个程序，这样就不会出现上面如：bind：address already in use

程序如下（在bind之前调用，提高端口的重用行）：



运行结果：


可以看到我们可以直接运行，无压力，但是当我们用：netstat -an|grep TIME_WAIT时，还是显示TIME_WAIT，但这个并不影响我们的结果

其他参考

参考1