客戶端程式碼：

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

static usage(const char* proc)
{
	printf("%s [ip] [port\n]", proc);
}

int main(int argc, char** argv)
{
	if(argc != 3)
	{
		usage(argv[0]);
		exit(1);
	}

	int sock = socket(AF_INET, SOCK_STREAM, 0);
	struct sockaddr_in server;
	if(sock < 0)
	{
		perror("socket");
		return 1;
	}
	server.sin_family = AF_INET;
	server.sin_addr.s_addr = inet_addr(argv[1]);
	server.sin_port = htons(atoi(argv[2]));

	if(connect(sock ,(struct sockaddr*)&server, sizeof(server) ) < 0)
	{
		perror("connect");
		exit(4);
	}

	char buf[1024];

	while(1)
	{
		printf("please input #: ");
		fflush(stdout);
		ssize_t sread = read(0, buf, sizeof(buf)-1);
		if(sread > 0)
		{
			buf[sread-1] = 0;
			write(sock, buf, strlen(buf));
			printf("server $ %s\n", buf);
			read(sock, buf, sizeof(buf) - 1);
		}
	
	}



	close(sock);
}
 

服務端程式碼：

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

// 使用幫助
static void usage(const char* proc)
{
	printf("use help : %s [local_ip] [local_port]\n", proc);
}

// 建立並繫結一個socket
int startup(const char* _ip, int _port)
{
	// 建立一個socket
	int sock = socket(AF_INET, SOCK_STREAM, 0);
	if (sock < 0)
	{
		perror("----sock----fail\n");
		exit(-1);
	}

	// 繫結一個本地socket
	struct sockaddr_in local;
	local.sin_family = AF_INET;
	local.sin_addr.s_addr = inet_addr(_ip);
	local.sin_port = htons(_port);

	if(bind(sock, (struct sockaddr*)&local, sizeof(local)) != 0)
	{
		perror("---bind---fail\n");
		close(sock);
		exit(-2);
	}

	if(listen(sock, 5) != 0)
	{
		perror("----listen----fail\n");
		close(sock);
		exit(-1);
	}

	return sock;		
}

int main(int argc, char**argv)
{
	if(argc != 3)
	{
		usage(argv[0]);
		return -1;
	}

	// 獲取一個local socket
	int listen_sock = startup(argv[1], atoi(argv[2]));
	struct sockaddr_in client;
	socklen_t len = sizeof(client);

	char buf[1024];
	while(1)
	{
		int new_sock = accept(listen_sock,(struct sockaddr*)&client, &len);
		if(new_sock < 0)
		{
			perror("----accept----fail\n");
			close(listen_sock);
			exit(-5);
		}
		pid_t id = fork();
		if(id == 0)
		{
			// ///////////////可以再這裡fork 然後退出子程序,這樣負責監聽的程序PID就不會一直變//////////
			close(listen_sock); // 子程序已經獲得 sockfd， 不需要listen sock所以關閉
			while(1)
			{
			    ssize_t s = read(new_sock,buf, sizeof(buf)-1);
			    if(s > 0 )
			    {
			    	buf[s] = 0;
			    	printf("client say## %s \n", buf);
			    	write(new_sock, buf, strlen(buf));
			    }
				else if( s == 0)
				{
					printf("client quit. \n");
					break;
				}
				else
					break;
			}
			exit(0);

		}
		else if (id > 0)
		{
			// 父程序
			// 在父程序中fork退出的話，會導致監聽程序的pid一直在變，所以我們也可以再子程序中fork然後退出
			close(new_sock); // 此時子程序已經獲取 sockfd， 父程序只需要監聽sockfd，又因為每次fork都會賦值描述符，為了節省資源，關閉new_sock
			if(fork() > 0)
			{
				exit(0);
			}
			// 父程序退出，此時第二次fork出的子程序 成為孤兒程序，此後它產生的子程序退出時由系統來回收資源
		}
	}


	return 0;
}
 

截圖：

啟動服務端：

開啟一個終端檢視狀態可以看到已經在監聽：

然後啟動兩個客戶端模擬多個連線：

1.啟動客戶端1

2.然後檢視連線狀態，可以發現已經建立連線

然後再啟動一個程序，建立連線：

觀察狀態：

我們會發現負責Listen程序的的PID一直在變，是因為我們是在父程序中fork然後讓父程序退出，讓子程序繼續監聽，所以一直會變，我們可以使用一個小技巧，在子程序中fork一個程序，讓父程序不變。