阿里云服务器win系统建站教程,wordpress 自动相册,直播视频软件,集客crm进程的基本概念
定义#xff1a;在Linux系统中#xff0c;进程是正在执行的一个程序实例#xff0c;它是资源分配和调度的基本单位。每个进程都有自己独立的地址空间、数据段、代码段、栈以及一组系统资源#xff08;如文件描述符、内存等#xff09;。进程的组成部分在Linux系统中进程是正在执行的一个程序实例它是资源分配和调度的基本单位。每个进程都有自己独立的地址空间、数据段、代码段、栈以及一组系统资源如文件描述符、内存等。进程的组成部分 代码段Text Segment包含程序的可执行代码通常是只读的多个进程可以共享相同程序的代码段。数据段Data Segment存储程序中已初始化的全局变量和静态变量。BSS段Block Started by Symbol存放程序中未初始化的全局变量和静态变量在程序加载时系统会将BSS段初始化为全零。栈Stack用于存储函数调用的局部变量、函数参数、返回地址等信息。栈的增长方向是从高地址向低地址。堆Heap用于动态分配内存程序可以在运行时通过malloc等函数在堆上申请内存堆的增长方向是从低地址向高地址。
进程的创建 - fork函数 函数原型pid_t fork(void);其中pid_t是一个整数类型用于表示进程ID。工作原理当一个进程调用fork函数时系统会创建一个新的进程这个新进程几乎是原进程的一个副本。原进程称为父进程新创建的进程称为子进程。子进程会复制父进程的代码段、数据段、堆和栈等资源。返回值 在父进程中fork函数返回新创建的子进程的进程ID。这个ID是一个大于0的值用于在父进程中区分不同的子进程。在子进程中fork函数返回0。如果fork函数调用失败会返回 - 1并设置errno来指示错误原因例如内存不足等。 示例代码
#include stdio.h
#include stdlib.h
#include sys/types.h
#include unistd.h
int main() {pid_t pid;pid fork();if (pid -1) {perror(fork失败);return 1;} else if (pid 0) {// 子进程代码printf(这是子进程进程ID为 %d父进程ID为 %d\n, getpid(), getppid());} else {// 父进程代码printf(这是父进程进程ID为 %d子进程ID为 %d\n, getpid(), pid);}return 0;
}进程的终止 正常终止方式 return语句在main函数中当main函数执行return语句时进程会正常终止。返回值可以被父进程获取如果父进程有获取子进程返回值的机制用于表示进程的执行结果。exit函数void exit(int status);其中status是进程的退出状态码用于告知父进程本进程的退出状态。exit函数会执行一些清理工作如关闭文件描述符、刷新标准I/O缓冲区等然后终止进程。 异常终止方式 abort函数会导致进程异常终止并产生一个SIGABRT信号用于在程序出现严重错误如无法恢复的错误时强行终止进程。收到信号终止进程可以接收来自操作系统或其他进程发送的信号而终止。例如当用户在终端中按下Ctrl C时当前正在运行的进程会收到SIGINT信号如果进程没有对该信号进行处理就会终止。 进程等待 - wait和waitpid函数 wait函数 函数原型pid_t wait(int *status);其中status是一个指向整数的指针用于存储子进程的退出状态信息。功能父进程调用wait函数会阻塞自己直到它的一个子进程终止。当子进程终止后wait函数会返回终止子进程的进程ID并将子进程的退出状态信息存储在status指向的变量中。 waitpid函数 函数原型pid_t waitpid(pid_t pid, int *status, int options);其中pid指定要等待的子进程的进程IDstatus和wait函数中的作用相同options用于设置等待选项如WNOHANG表示如果没有子进程终止就立即返回不阻塞父进程。功能相比wait函数更加灵活可以等待指定的子进程并且可以通过options参数控制等待行为。 示例代码使用wait函数
#include stdio.h
#include stdlib.h
#include sys/types.h
#include sys/wait.h
#include unistd.h
int main() {pid_t pid;int status;pid fork();if (pid -1) {perror(fork失败);return 1;} else if (pid 0) {// 子进程代码printf(子进程开始执行进程ID为 %d\n, getpid());// 模拟子进程执行一些任务后退出sleep(2);return 42;} else {// 父进程代码printf(父进程等待子进程...\n);pid_t terminated_pid wait(status);if (terminated_pid -1) {perror(wait失败);return 1;}if (WIFEXITED(status)) {int exit_status WEXITSTATUS(status);printf(子进程 %d 正常退出退出状态为 %d\n, terminated_pid, exit_status);}}return 0;
}进程的执行顺序和调度 进程调度器Linux系统中有进程调度器它决定哪个进程可以在CPU上运行。调度器会根据一定的算法如时间片轮转、优先级调度等来分配CPU时间。优先级和Nice值每个进程都有一个优先级优先级高的进程会优先获得CPU时间。可以通过调整进程的Nice值来间接改变进程的优先级。Nice值的范围是 - 20到19Nice值越小优先级越高。可以使用nice命令用于启动一个具有指定Nice值的进程和renice命令用于改变一个正在运行进程的Nice值来操作进程的Nice值。 管道Pipe 基本概念 管道是一种最基本的进程间通信方式它是一个单向的、先进先出FIFO的数据通道。管道用于连接一个写进程和一个读进程写进程将数据写入管道的一端读进程从管道的另一端读取数据。管道通常用于具有亲缘关系如父子进程的进程之间通信。 创建和使用方式 在Linux系统中可以使用pipe函数来创建一个管道。pipe函数的原型为int pipe(int pipefd[2]);其中pipefd是一个包含两个整数的数组pipefd[0]用于读取管道数据管道的读端pipefd[1]用于向管道写入数据管道的写端。成功时返回0失败时返回 - 1。 示例代码父子进程间通过管道通信
#include stdio.h
#include stdlib.h
#include unistd.h
#include sys/types.h
#include string.h
#define BUFFER_SIZE 1024
int main() {int pipefd[2];pid_t pid;char buffer[BUFFER_SIZE];// 创建管道if (pipe(pipefd) -1) {perror(创建管道失败);return 1;}// 创建子进程pid fork();if (pid -1) {perror(创建子进程失败);return 1;} else if (pid 0) {// 子进程关闭管道写端从管道读端读取数据close(pipefd[1]);ssize_t num_read read(pipefd[0], buffer, sizeof(buffer));if (num_read -1) {perror(子进程读取管道数据失败);return 1;} else if (num_read 0) {printf(管道已关闭没有数据可读。\n);} else {buffer[num_read] \0;printf(子进程读取到的数据%s\n, buffer);}close(pipefd[0]);} else {// 父进程关闭管道读端向管道写端写入数据close(pipefd[0]);char data[] 这是通过管道发送的数据。;ssize_t num_written write(pipefd[1], data, strlen(data));if (num_written -1) {perror(父进程向管道写入数据失败);return 1;}printf(父进程向管道写入了 %zd 个字节的数据。\n, num_written);close(pipefd[1]);}return 0;
}特点 简单易用适用于父子进程等有亲缘关系的进程之间的简单数据传输。但管道是半双工通信方式数据只能单向流动如果要实现双向通信需要创建两个管道。并且管道的容量有限如果写进程写入数据的速度超过读进程读取数据的速度管道可能会阻塞。
命名管道Named Pipe或FIFO 基本概念 命名管道是一种特殊类型的文件它也提供了一个单向或双向的通信通道。与普通管道不同的是命名管道有一个文件名可以被多个没有亲缘关系的进程访问用于实现这些进程之间的通信。 创建和使用方式 可以使用mkfifo命令在命令行中或mkfifo函数在程序中来创建一个命名管道。mkfifo函数的原型为int mkfifo(const char *pathname, mode_t mode);其中pathname是命名管道的文件名mode是文件的权限模式。成功时返回0失败时返回 - 1。一个进程以写方式打开命名管道使用open函数打开模式为O_WRONLY另一个进程以读方式打开命名管道打开模式为O_RDONLY就可以进行通信。 示例代码两个无关进程通过命名管道通信
// 写进程
#include stdio.h
#include stdlib.h
#include sys/types.h
#include sys/stat.h
#include fcntl.h
#include unistd.h
#include string.h
#define BUFFER_SIZE 1024
int main() {int fd;char data[] 这是通过命名管道发送的数据。;// 创建命名管道如果不存在if (mkfifo(myfifo, 0666) -1 errno! EEXIST) {perror(创建命名管道失败);return 1;}// 以写方式打开命名管道fd open(myfifo, O_WRONLY);if (fd -1) {perror(打开命名管道写失败);return 1;}ssize_t num_written write(fd, data, strlen(data));if (num_written -1) {perror(向命名管道写入数据失败);close(fd);return 1;}printf(向命名管道写入了 %zd 个字节的数据。\n, num_written);close(fd);return 0;
}// 读进程
#include stdio.h
#include stdlib.h
#include sys/types.h
#include sys/stat.h
#include fcntl.h
#include unistd.h
#include string.h
#define BUFFER_SIZE 1024
int main() {int fd;char buffer[BUFFER_SIZE];// 以读方式打开命名管道fd open(myfifo, O_RDONLY);if (fd -1) {perror(打开命名管道读失败);return 1;}ssize_t num_read read(fd, buffer, sizeof(buffer));if (num_read -1) {perror(从命名管道读取数据失败);close(fd);return 1;} else if (num_read 0) {printf(命名管道已关闭没有数据可读。\n);} else {buffer[num_read] \0;printf(从命名管道读取到的数据%s\n, buffer);}close(fd);return 0;
}特点 可以在没有亲缘关系的进程之间通信提供了更灵活的通信方式。但同样是半双工通信若要双向通信可能需要创建两个命名管道。命名管道在打开进行读或写操作时如果没有对应的进程进行反向操作如打开写时没有读进程可能会阻塞。
消息队列Message Queue 基本概念 消息队列是一个由内核维护的消息链表它允许不同进程通过发送和接收消息来进行通信。消息队列中的每个消息都有一个特定的类型可以根据类型来接收消息使得进程可以选择性地获取自己感兴趣的消息。 创建和使用方式 在Linux系统中使用消息队列需要包含sys/types.h、sys/ipc.h和sys/msg.h头文件。首先使用msgget函数来创建或获取一个消息队列标识符。msgget函数的原型为int msgget(key_t key, int msgflg);其中key是一个键值用于唯一标识消息队列msgflg用于指定创建或访问消息队列的标志。进程可以使用msgsnd函数向消息队列发送消息msgsnd函数的原型为int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);其中msqid是消息队列标识符msgp是指向消息结构体的指针msgsz是消息的长度msgflg是发送标志。接收消息可以使用msgrcv函数其原型为int msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);其中msgtyp是要接收的消息类型。 示例代码两个进程通过消息队列通信
// 发送消息的进程
#include stdio.h
#include stdlib.h
#include sys/types.h
#include sys/ipc.h
#include sys/msg.h
#include string.h
#define MAX_TEXT 512
struct my_msg {long int my_msg_type;char some_text[MAX_TEXT];
};
int main() {int msqid;key_t key;struct my_msg some_data;// 生成一个唯一的键值if ((key ftok(., a)) -1) {perror(生成键值失败);return 1;}// 创建或获取消息队列if ((msqid msgget(key, 0666 | IPC_CREAT)) -1) {perror(获取消息队列失败);return 1;}// 设置要发送的消息类型和内容some_data.my_msg_type 1;strcpy(some_data.some_text, 这是通过消息队列发送的消息。);// 发送消息if (msgsnd(msqid, some_data, sizeof(some_data.some_text), 0) -1) {perror(发送消息失败);return 1;}printf(消息已发送。\n);return 0;
}// 接收消息的进程
#include stdio.h
#include stdlib.h
#include sys/types.h
#include sys/ipc.h
#include sys/msg.h
#include string.h
#define MAX_TEXT 512
struct my_msg {long int my_msg_type;char some_text[MAX_TEXT];
};
int main() {int msqid;key_t key;struct my_msg some_data;// 生成一个唯一的键值if ((key ftok(., a)) -1) {perror(生成键值失败);return 1;}// 创建或获取消息队列if ((msqid msgget(key, 0666 | IPC_CREAT)) -1) {perror(获取消息队列失败);return 1;}// 接收消息类型为1的消息if (msgrcv(msqid, some_data, sizeof(some_data.some_text), 1, 0) -1) {perror(接收消息失败);return 1;}printf(接收到的消息%s\n, some_data.some_text);// 标记消息队列可以被删除当所有进程都不再使用时if (msgctl(msqid, IPC_RMID, NULL) -1) {perror(删除消息队列标记失败);return 1;}return 0;
}特点 消息队列克服了管道和命名管道无格式字节流的缺点消息有类型可以按照类型进行接收增强了通信的灵活性。消息队列可以实现多对多的通信多个进程可以向同一个消息队列发送和接收消息。但是消息队列的容量有限当消息队列满时发送进程可能会阻塞并且消息队列的实现涉及到系统调用效率相对较低。
共享内存Shared Memory 基本概念 共享内存是一种高效的进程间通信方式它允许两个或多个进程共享一段物理内存区域。进程可以像访问自己的内存一样访问共享内存区域这使得数据的传输速度非常快因为不需要进行数据的复制操作如管道和消息队列需要在用户空间和内核空间之间复制数据。 创建和使用方式 在Linux系统中使用共享内存需要包含sys/types.h、sys/ipc.h和sys/shm.h头文件。首先使用shmget函数来创建或获取一个共享内存段标识符。shmget函数的原型为int shmget(key_t key, size_t size, int shmflg);其中key是一个键值size是共享内存段的大小shmflg是创建或访问标志。然后使用shmat函数将共享内存段连接到进程的地址空间。shmat函数的原型为void *shmat(int shmid, const void *shmaddr, int shmflg);其中shmid是共享内存段标识符shmaddr是指定连接的地址通常为NULL让系统自动选择地址shmflg是连接标志。进程使用完共享内存后需要使用shmdt函数将共享内存段从进程的地址空间分离shmdt函数的原型为int shmdt(const void *shmaddr);其中shmaddr是之前shmat函数返回的地址。最后使用shmctl函数来标记共享内存段可以被删除当所有进程都不再使用时shmctl函数的原型为int shmctl(int shmid, int cmd, struct shmid_ds *buf);其中cmd为IPC_RMID时表示删除共享内存段。 示例代码两个进程通过共享内存通信
// 创建共享内存并写入数据的进程
#include stdio.h
#include stdlib.h
#include sys/types.h
#include sys/ipc.h
#include sys/shm.h
#include string.h
#define BUFFER_SIZE 1024
int main() {int shmid;key_t key;char *shared_memory;// 生成一个唯一的键值if ((key ftok(., a)) -1) {perror(生成键值失败);return 1;}// 创建共享内存段if ((shmid shmget(key, BUFFER_SIZE, 0666 | IPC_CREAT)) -1) {perror(获取共享内存段失败);return 1;}// 将共享内存段连接到进程的地址空间if ((shared_memory (char *)shmat(shmid, NULL, 0)) NULL) {perror(连接共享内存段失败);return 1;}// 写入数据到共享内存strcpy(shared_memory, 这是通过共享内存写入的数据。);// 将共享内存段从进程的地址空间分离if (shmdt(shared_memory) -1) {perror(分离共享内存段失败);return 1;}return 0;
}// 从共享内存读取数据的进程
#include stdio.h
#include stdlib.h
#include sys/types.h
#include sys/ipc.h
#include sys/shm.h
#include string.h
#define BUFFER_SIZE 1024
int main() {int shmid;key_t key;char *shared_memory;// 生成一个唯一的键值if ((key ftok(., a)) -1) {perror(生成键值失败);return 1;}// 获取共享内存段if ((shmid shmget(key, BUFFER_SIZE, 0666 | IPC_CREAT)) -1) {perror(获取共享内存段失败);return 1;}// 将共享内存段连接到进程的地址空间if ((shared_memory (char *)shmat(shmid, NULL, 0)) NULL) {perror(连接共享内存段失败);return 1;}// 读取共享内存中的数据printf(从共享内存读取到的数据%s\n, shared_memory);// 将共享内存段从进程的地址空间分离if (shmdt(shared_memory) -1) {perror(分离共享内存段失败);return 1;}// 标记共享内存段可以被删除if (shmctl(shmid, IPC_RMID, NULL) -1) {perror(删除共享内存段标记失败);return 1;}return 0;
}共享内存Shared Memory特点续 需要使用信号量或互斥锁等同步机制来保证数据的一致性。例如当一个进程正在向共享内存写入数据时另一个进程不能同时进行写入操作否则可能会出现数据混乱。并且共享内存的分配和管理相对复杂需要考虑内存的大小、地址映射等问题。 信号量Semaphore 基本概念 信号量是一个计数器用于控制多个进程对共享资源的访问。它可以实现进程间的同步和互斥。信号量的值表示可用资源的数量当信号量的值大于0时表示有可用资源当信号量的值等于0时表示没有可用资源此时请求资源的进程会被阻塞。 创建和使用方式 在Linux系统中使用信号量需要包含sys/types.h、sys/ipc.h和sys/sem.h头文件。首先使用semget函数创建或获取一个信号量集标识符。semget函数的原型为int semget(key_t key, int nsems, int semflg);其中key是一个键值nsems是信号量集中信号量的个数通常为1semflg是创建或访问标志。然后使用semctl函数对信号量进行初始化等操作。semctl函数的原型为int semctl(int semid, int semnum, int cmd,...);其中semid是信号量集标识符semnum是信号量在集合中的编号对于只有一个信号量的集合通常为0cmd是操作命令如SETVAL用于设置信号量的值。进程可以使用semop函数来操作信号量如对信号量进行P操作和V操作。semop函数的原型为int semop(int semid, struct sembuf *sops, unsigned nsops);其中sops是一个指向struct sembuf结构体数组的指针struct sembuf结构体包含信号量操作的相关信息如操作类型-1表示P操作1表示V操作、信号量编号等nsops是操作的个数。 示例代码使用信号量实现互斥访问共享资源
// 包含必要的头文件
#include stdio.h
#include stdlib.h
#include sys/types.h
#include sys/ipc.h
#include sys/sem.h
#include sys/shm.h
#include unistd.h
#include string.h#define BUFFER_SIZE 1024// 定义联合体用于semctl函数的参数传递
union semun {int val;struct semid_ds *buf;unsigned short *array;struct seminfo *__buf;
};// 信号量P操作函数
void semaphore_p(int semid) {struct sembuf sop;sop.sem_num 0;sop.sem_op -1;sop.sem_flg 0;if (semop(semid, sop, 1) -1) {perror(P操作失败);exit(1);}
}// 信号量V操作函数
void semaphore_v(int semid) {struct sembuf sop;sop.sem_num 0;sop.sem_op 1;sop.sem_flg 0;if (semop(semid, sop, 1) -1) {perror(V操作失败);exit(1);}
}// 主函数
int main() {int shmid, semid;key_t key;char *shared_memory;union semun arg;// 生成一个唯一的键值if ((key ftok(., a)) -1) {perror(生成键值失败);return 1;}// 创建共享内存段if ((shmid shmget(key, BUFFER_SIZE, 0666 | IPC_CREAT)) -1) {perror(获取共享内存段失败);return 1;}// 将共享内存段连接到进程的地址空间if ((shared_memory (char *)shmat(shmid, NULL, 0)) NULL) {perror(连接共享内存段失败);return 1;}// 创建信号量if ((semid semget(key, 1, 0666 | IPC_CREAT)) -1) {perror(获取信号量失败);return 1;}// 初始化信号量的值为1arg.val 1;if (semctl(semid, 0, SETVAL, arg) -1) {perror(初始化信号量失败);return 1;}pid_t pid fork();if (pid -1) {perror(创建子进程失败);return 1;} else if (pid 0) {// 子进程semaphore_p(semid);strcpy(shared_memory, 这是子进程写入共享内存的数据。);semaphore_v(semid);// 将共享内存段从进程的地址空间分离if (shmdt(shared_memory) -1) {perror(子进程分离共享内存段失败);return 1;}} else {// 父进程semaphore_p(semid);printf(父进程从共享内存读取到的数据%s\n, shared_memory);semaphore_v(semid);// 将共享内存段从进程的地址空间分离if (shmdt(shared_memory) -1) {perror(父进程分离共享内存段失败);return 1;}// 标记共享内存段可以被删除if (shmctl(shmid, IPC_RMID, NULL) -1) {perror(删除共享内存段标记失败);return 1;}// 标记信号量可以被删除if (semctl(semid, 0, IPC_RMID, NULL) -1) {perror(删除信号量标记失败);return 1;}}return 0;
}- **特点**- 信号量主要用于进程间的同步和互斥能够有效地控制对共享资源的访问。通过合理设置信号量的初始值和操作方式可以实现复杂的进程同步场景。但是信号量的使用比较复杂需要正确理解P操作等待资源和V操作释放资源的含义以及它们之间的关系。如果使用不当可能会导致死锁等问题。套接字Socket 基本概念 套接字是一种更为通用的进程间通信方式它不仅可以用于同一台计算机上的进程通信还可以用于不同计算机之间通过网络的进程通信。套接字提供了一种基于网络协议如TCP/IP的通信接口使得进程可以像读写文件一样进行网络通信。 - **创建和使用方式**- 在Linux系统中使用套接字需要包含sys/types.h、sys/socket.h头文件。首先使用socket函数创建一个套接字。socket函数的原型为int socket(int domain, int type, int protocol);其中domain表示套接字使用的协议族如AF_INET表示IPv4协议族type表示套接字类型如SOCK_STREAM表示面向连接的TCP套接字SOCK_DGRAM表示无连接的UDP套接字protocol表示协议通常为0表示使用默认协议。- 对于基于TCP的套接字通信服务器端需要使用bind函数将套接字绑定到一个本地地址和端口bind函数的原型为int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);其中sockfd是套接字描述符addr是指向sockaddr结构体或其变体如sockaddr_in用于IPv4地址的指针addrlen是地址结构体的长度。- 然后服务器端使用listen函数监听端口等待客户端连接。listen函数的原型为int listen(int sockfd, int backlog);其中backlog表示等待连接队列的最大长度。- 客户端使用connect函数连接到服务器。connect函数的原型为int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);其中参数含义与bind函数类似。- 服务器端接受客户端连接使用accept函数accept函数的原型为int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);它会返回一个新的套接字描述符用于与客户端进行通信。- 通信过程中使用send用于TCP套接字或sendto用于UDP套接字函数发送数据使用recv用于TCP套接字或recvfrom用于UDP套接字函数接收数据。
- **示例代码简单的TCP套接字通信示例服务器端和客户端**
- **服务器端代码**#include stdio.h
#include stdlib.h
#include sys/types.h
#include sys/socket.h
#include netinet/in.h
#include string.h
#include unistd.h#define PORT 8888
#define BUFFER_SIZE 1024int main() {int server_socket, client_socket;struct sockaddr_in server_addr, client_addr;socklen_t client_addr_len;char buffer[BUFFER_SIZE];// 创建套接字server_socket socket(AF_INET, SOCK_STREAM, 0);if (server_socket -1) {perror(创建服务器套接字失败);return 1;}// 初始化服务器地址结构体server_addr.sin_family AF_INET;server_addr.sin_port htons(PORT);server_addr.sin_addr.s_addr INADDR_ANY;// 绑定套接字到本地地址和端口if (bind(server_socket, (struct sockaddr *)server_addr, sizeof(server_addr)) -1) {perror(绑定服务器套接字失败);close(server_socket);return 1;}// 监听端口if (listen(server_socket, 5) -1) {perror(监听端口失败);close(server_socket);return 1;}printf(服务器正在等待客户端连接...\n);// 接受客户端连接client_addr_len sizeof(client_addr);client_socket accept(server_socket, (struct sockaddr *)client_addr, client_addr_len);if (client_socket -1) {perror(接受客户端连接失败);close(server_socket);return 1;}printf(客户端已连接。\n);// 接收客户端发送的数据ssize_t num_read recv(client_socket, buffer, sizeof(buffer), 0);if (num_read -1) {perror(接收客户端数据失败);close(client_socket);close(server_socket);return 1;} else if (num_read 0) {printf(客户端已断开连接。\n);} else {buffer[num_read] \0;printf(接收到客户端发送的数据%s\n, buffer);}// 发送响应数据给客户端char response[] 这是服务器的响应数据。;ssize_t num_written send(client_socket, response, strlen(response), 0);if (num_written -1) {perror(发送响应数据给客户端失败);close(client_socket);close(server_socket);return 1;}// 关闭套接字close(client_socket);close(server_socket);return 0;
}- **客户端代码**#include stdio.h
#include stdlib.h
#include sys/types.h
#include sys/socket.h
#include netinet/in.h
#include string.h
#include unistd.h#define PORT 8888
#define BUFFER_SIZE 1024int main() {int client_socket;struct sockaddr_in server_addr;char buffer[BUFFER_SIZE];// 创建套接字client_socket socket(AF_INET, SOCK_STREAM, 0);if (client_socket -1) {perror(创建客户端套接字失败);return 1;}// 初始化服务器地址结构体server_addr.sin_family AF_INET;server_addr.sin_port htons(PORT);server_addr.sin_addr.s_addr inet_addr(127.0.0.1);// 连接服务器if (connect(client_socket, (struct sockaddr *)server_addr, sizeof(server_addr)) -1) {perror(连接服务器失败);close(client_socket);return 1;}// 发送数据给服务器char data[] 这是客户端发送的数据。;ssize_t num_written send(client_socket, data, strlen(data), 0);if (num_written -1) {perror(发送数据给服务器失败);close(client_socket);return 1;}// 接收服务器响应的数据ssize_t num_read recv(client_socket, buffer, sizeof(buffer), 0);if (num_read -1) {perror(接收服务器响应数据失败);close(client_socket);return 1;} else if (num_read 0) {printf(服务器已断开连接。\n);} else {buffer[num_read] \0;printf(接收到服务器响应的数据%s\n, buffer);}// 关闭套接字close(client_socket);return 0;
}- **特点**- 套接字通信功能强大应用范围广泛可以实现本地进程间通信和网络进程间通信。但套接字编程相对复杂需要了解网络协议、IP地址、端口等知识。并且在网络通信中还需要考虑网络延迟、丢包、字节序等问题。
