首页  思维导图  详情

应用开发

2023-01-07 10:54:45   0  举报





AI智能生成

c语言线程，进程，网络通信总结

物联网

C语言

算法

作者其他创作

大纲/内容

文件管理

IO文件操作

7种文件类型

普通，目录，管道，链接，套接字，块，字符设备文件

打开文件 6种方式（r ,r+, w,w+,a,a+）

读写文件 fread fwrite

关闭文件fclose

操作对象

FILE * fp 文件流指针

IO 函数操作，不能操作内核，设备

文件描述符  大于0的正整数

函数

access

int access(const char*pathname,int mode)

① pathname -- 文件名，目录名 -- F_OK（存在与否）

② mode  --- F_OK W_OK X_OK R_OK

open

int open(const char*pathname,int flags,int mode)

mode

权限 八进制数表示  0644  0755

int open(const char*pathname,int flags)

flags 打开方式

O_RDWR 可读可写

O_RDONLY  只读

O_WRONLY  只写

O_APPEND   追加

O_CREAT     创建

read

ssize_t read(int fd,char*buf,size_t count)

① fd -- open的返回值

② buf -- 缓冲区大小

③ count -- 读取的字节数

④ 返回值：读取的个数

write

ssize_t write(int fd,char*buf,size_t count)

lseek （重新设置读写的位置）

off_t lseek(int fd,off_t offset,int whence)

① offset -- 相对于whence的偏移量（+，-，0）

② whence --- SEEK_SET 开头  SEEK_CUR 当前  SEEK_END 末尾

③ 返回值：当前位置距离开头的偏移量

stat （文件的状态信息）

int stat(const char *path,struct stat*buf)

① path -- 文件名，路径名

② buf -- 存放，结构体内容

③ 返回值 -- 0 -- success   -1 -- erro

目录操作

mkdir (创建目录)

int mkdir(const char*pathname,mode_t mode)

① mode -- 权限

② 返回值： 0  --  success   -1-- error

rmdir

rmdir(const char*pathname)

opendir （打开目录）

DIR*dir = opendir(const char*pathname)

pathname -- 目录流

dir --- 目录流指针（存放目录的信息）

readdir （读取目录中的文件信息）

struct dirent *sp = readdir(DIR*dir)

dir --- 目录流指针

sp --- 指向dir目录的结构体指针

d_name  文件名字

子主题

rename （修改名字）

rename(const char *oldname,const char*newname)

remove（删除文件，或者空的目录）

int remove(const char*pathname)

任务(进程)

头文件

<stdio.h>,<unistd.h>,<stdlib.h>,<sys/types.h>

process(进程，动态的过程)

进程的状态

新建  就绪  运行 阻塞 结束 （三个回路）

ps aux--- linux中的进程

进程的特性

动态性    ---  pid不连续，动态产生，动态消亡

并发性    ---  同时执行 -- 宏观

异步性    ---  不同时执行 -- 微观角度，时间差

独立性    --- 父子进程运行在不同的空间中

结构特性  --- 空间不同，所以具有不同的空间体系（栈，堆，数据，代码）

进程的概念

1、独立可调度的活动

2、抽象的实体，申请和释放资源

3、并行执行，多进程提供基础

4、进程是程序的一次执行过程，动态的，程序执行和资源管理的最小单元。 进程的标识符

父进程 -- 创建子进行 fork() -- 函数

pid_t pid = 0;

pid = fork();

pid = fork();  if(pid == -1)  {   perror("fork");   exit(1);  }

else if(pid == 0)  {   //子进程   printf("the child process![%d-%d]\n",getpid(),getppid());   while(1);  }

else  {   //父进程   printf("the parent process![%d-%d]\n",pid,getpid());   while(1);  }

getpid() --- 返回当前进程的pid

getppid() -- 子进程中返回父进程的编号

进程间通信

头文件

<stdio.h> <sys/ipc.h> <sys/shm.h> <stdlib.h>  <sys/types.h>

pipe --- 创建无名管道

int pipe(int pfd[2]);

pfd[2] -- 接收管道的描述符

返回值：0 -- success  -1 --- error

mkfifo() --- 创建有名管道

int mkfifo(const char*pathname,mode_t mode);

pathname -- 文件名，路径名

mode  -- 权限

返回值：0--- success    -1 --- error

创建共享内存

查看共享内存：ipcs -m

编程步骤：

1、创建共享内存

2、映射共享内存

3、宋体;mso-ascii-font-family:Calibri;mso-ascii-theme-font:minor-latin;mso-fareast-theme-font: minor-fareast;mso-hansi-font-family:Calibri;mso-hansi-theme-font:minor-latin">使用共享内存<o:p></o:p>

4、断开共享内存

5、回收共享内存

int shmid = shmget(key_t key,size_t size,int shmflg);

key -->ftok() -- 返回值获得

key_t key = ftok(const char*pathname,int pro_id);

pathname -- 存在

返回值：键值

size --->共享内存大小

 shmflg --> IPC_CREAT|权限

返回值：shmid --- >共享内存的标识符

线程

概念

线程

(1) 什么是线程

① 线程是进程的一个实体，轻量级进程

② 程序执行流的最小单元

③ 被系统独立调度和分派基本单元

(2) 线程和进程关系

① 进程和线程的概念

② 如果只有一个进程，那么这个进程既是进程也叫做线程

(3) 线程A --创建--- 线程B （线程B只拥有自己需要一点儿栈段空间，其他的共享资源）

(4) 运行图

线程的创建

头文件

#include <stdio.h> #include <pthread.h> #include <stdlib.h> #include <unistd.h> #include <string.h>

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,                           void *(*start_routine) (void *), void *arg);

1、pthread_t*thread --- 新线程的编号

2、attr -- 线程的属性 NULL（默认属性）

3、void *(*start_routine) (void *) --》start_routine 指向返回值和参数都是void*的函数，---》新的线程

4、void*arg -- 作为新的线程的参数

5、返回值：success -- 0  error --- 错误编码 strerror打印

pthread_self() -- 返回线程的编号

pthread_join(pthread_t pid,void**arg) -- 等待新的线程的退出

pthread_exit(void*arg) -- 线程的结束函数（进程结束exit()）

互斥锁：锁的机制，上锁和解锁。

互斥问题 -- 只允许一个线程访问

同步问题 -- 在互斥保护下对于线程的有序访问

共享资源的访问 --- 全局变量（两个进程都可以访问到）

通过加锁和解锁的方式实现线程的通信，解决了线程的互斥的问题

1、申请互斥锁

(1) 静态初始化 pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; 快速互斥锁

(2) 动态初始化 pthread_mutex_init(&mutex,NULL); NULL -- 默认快速互斥锁

2、上锁

pthread_mutex_lock(&mutex);

3、解锁

pthread_mutex_unlock(&mutex);

4、回收资源

pthread_mutex_destroy(&mutex);

条件变量：条件，变量的改变 -- 线程的执行

在互斥锁的保护下 读文件 -- 线程             写文件 -- 线程 执行       条件为真阻塞 -- 不执行了-- 释放锁 改变条件-阻塞线程发送唤醒信号    接受到对方信号--不阻塞执行 执行完成，改变条件让自己继续阻塞

总结：读线程先执行 -- 写的线程在执行（重复上一次过程）

条件变量的操作流程

1、初始化

(1) 静态初始化 -- pthread_cond_t cond =  PTHREAD_COND_INITIALIZER;

(2) 动态初始化 -- pthread_cond_init(&cond,NULL);

2、阻塞线程（条件为真）

pthread_cond_wait(&cond,&mutex); 等待被唤醒，阻塞一个线程

3、唤醒一个阻塞的线程

pthread_cond_signal(&cond); -- 唤醒线程执行

4、回收资源

pthread_cond_destroy(&cond) -- 回收条件变量

前提，2个线程必须在互斥锁的保护下进行

网络（网络应用）

UDP编程

客户端

创建socket通信

int sockfd = socket(AF_INET,SOCK_DGRAM,0)

AF_INET IPV4的协议族

SOCK_DGRAM（数据报套接字）

protocol：指定应用程序使用的通讯协议，一般取值为0，让系统决定使用协议

 成功：返回新建的套接字描述符。失败返回-1，并将错误代码放入erron

设置ip和port

struct sockaddr_in seraddr = {0} 

清空：bzero(&seraddr,sizeof(seraddr));

seraddr.sin_family = AF_INET;(协议)

seraddr.sin_port = htons(atoi(端口号))；

seraddr.sin_addr.s_addr = inet_addr(IP地址);

socklen_t len = sizeof(seraddr);

发送消息

sendto(sockfd,str,sizeof(str),0,(struct sockaddr*)&seraddr,&len);

str:发送的字符串

seraddr:服务器地址

len：seraddr长度

接收消息

ssize_t rv=recvfrom(sockfd,buf,sizeof(buf),0,(struct sockaddr*)&seraddr,&len);

rv:接收消息的长度

关闭套接字

close(sockfd);

服务器

创建socket通信

int sockfd=socket(AF_INET,SOCK_DGRAM,0)

绑定IP和port

struct sockaddr_in seraddr={0};

接收消息

struct sockaddr_in cliaddr;

ssize_t rv=recvfrom(sockfd,buf,sizeof(buf),0,(struct sockaddr*)&cliaddr,&len);

关闭套接字

close(sockfd);

TCP编程

客户端

创建socket通信

int sockfd=socket(AF_INET,SOCK_STREAM,0);

AF_INET ipv4的协议族

流式套接字(SOCK_STREAM)

protocol：指定应用程序使用的通讯协议，一般取值为0,让系统决定使用的协议。

成功：返回新建的套接字描述符；失败：返回-1。并将错误码放入 errno

设置ip和port

struct sockaddr_in seraddr = {0} 

清空：bzero(&seraddr,sizeof(seraddr));

seraddr.sin_family = AF_INET;(协议)

seraddr.sin_port = htons(atoi(端口号))；

seraddr.sin_addr.s_addr = inet_addr(IP地址);

socklen_t len = sizeof(seraddr);

连接服务器

int flag=connect(sockfd,(struct sockaddr*)&seraddr,len)

返回值：0--success 1--error

发送消息

sd=send(sockfd,buf,sizeof(buf),0);

-1失败

也可以用write发送消息格式同read

接收消息

rd=read(sockfd,buf,sizeof(buf));

-1失败

recv接收消息，格式同send

关闭套接字

服务器

创建socket通信

int sockfd=socket(AF_INET,SOCK_STREAM,0);

AF_INET ipv4的协议族

流式套接字(SOCK_STREAM)

protocol：指定应用程序使用的通讯协议，一般取值为0,让系统决定使用的协议。

成功：返回新建的套接字描述符；失败：返回-1。并将错误码放入 errno

设置ip和port

struct sockaddr_in seraddr = {0} 

清空：bzero(&seraddr,sizeof(seraddr));

seraddr.sin_family = AF_INET;(协议)

seraddr.sin_port = htons(atoi(端口号))；

seraddr.sin_addr.s_addr = inet_addr(IP地址);

socklen_t len = sizeof(seraddr);

监听

flag=listen(sockfd,20);

sockfd:监听客户端连接请求

20：l连接队列中的最大个数，自定

接收请求

struct sockaddr_in cliaddr;

socklen_t len=sizeof(cliaddr);

accfd=accept(sockfd,(struct sockaddr*)&cliaddr,&len)

接收消息

rd=read(accfd,buf,sizeof(buf))

-1失败

发送消息

sd=send(accfd,buf,sizeof(buf),0);

-1失败

关闭套接字

通信协议设计

客户端

创建socket通信

int sockfd=socket(AF_INET,SOCK_STREAM,0);

AF_INET ipv4的协议族

流式套接字(SOCK_STREAM)

protocol：指定应用程序使用的通讯协议，一般取值为0,让系统决定使用的协议。

成功：返回新建的套接字描述符；失败：返回-1。并将错误码放入 errno

设置ip和port

struct sockaddr_in seraddr = {0} 

清空：bzero(&seraddr,sizeof(seraddr));

seraddr.sin_family = AF_INET;(协议)

seraddr.sin_port = htons(atoi(端口号))；

seraddr.sin_addr.s_addr = inet_addr(IP地址);

socklen_t len = sizeof(seraddr);

连接服务器

int flag=connect(sockfd,(struct sockaddr*)&seraddr,len)

返回值：0--success 1--error

申请空间

char *comm = (char*)malloc(sizeof(struct head)+sizeof(struct body));

head结构体

int type

int id

body结构体

组报

memcpy(comm,&head,sizeof(head));

head存入

②memcpy(comm+sizeof(HEAD),&body,sizeof(body));

body存入

发送消息

sd = send(sockfd,comm,sizeof(HEAD)+sizeof(BODY),0);

-1失败

接收消息

rd=read(sockfd,buf,sizeof(buf));

-1失败

释放空间

free

关闭套接字

服务端

创建socket通信

int sockfd=socket(AF_INET,SOCK_STREAM,0);

AF_INET ipv4的协议族

流式套接字(SOCK_STREAM)

protocol：指定应用程序使用的通讯协议，一般取值为0,让系统决定使用的协议。

成功：返回新建的套接字描述符；失败：返回-1。并将错误码放入 errno

设置ip和port

struct sockaddr_in seraddr = {0} 

清空：bzero(&seraddr,sizeof(seraddr));

seraddr.sin_family = AF_INET;(协议)

seraddr.sin_port = htons(atoi(端口号))；

seraddr.sin_addr.s_addr = inet_addr(IP地址);

socklen_t len = sizeof(seraddr);

监听

flag=listen(sockfd,20);

sockfd:监听客户端连接请求

20：l连接队列中的最大个数，自定

接收请求

struct sockaddr_in cliaddr;

socklen_t len=sizeof(cliaddr);

accfd=accept(sockfd,(struct sockaddr*)&cliaddr,&len)

申请空间

char *comm = (char*)malloc(sizeof(struct head)+sizeof(struct body));

head结构体

int type

int id

body结构体

接收消息

rd = read(accfd,comm,sizeof(HEAD)+sizeof(BODY));

-1失败

解析消息内容

HEAD*head = NULL;head = (HEAD*)comm;

BODY*body = NULL;body = (BODY*)(comm+sizeof(HEAD)

发送消息

sd=send(accfd,buf,sizeof(buf),0);

释放空间

free

关闭套接字

select函数（非阻塞链接）

申请文件描述符集合

fd_set readfd;

分支主清空文件描述符的集合题

FD_ZERO(&readfd);

文件描述符顺次添加到文件描述符的集合中

int fd = 0;FD_SET(fd,&readfd);

fd最大5

设置等待时间

struct timeval tm; int retval = 0;

内核监控（select）readfd中文件描述符的变化

select(maxfd+1（6）,&readfd,NULL,NULL,&tm);

返回值

-1：error

0:无输入

阻塞的方式等待tm时长

maxfd最大值

判断FD_ISSET()判断readfd中文件描述符状态是否可读，如果可 读--通信，如果对方断开，把文件描述符从文件描述符集合中清 除（FD_CLR()）

FD_ISSET(fd,&readfd)>0可读，通信

否则循环判断fd变化

优缺点

最大连接个数的限制 1024

效率问题低，主要对于集合操作，线性扫面（所有集合中数据查看）

内存拷贝问题，select机制，把所有的文件描述符的集合方法内核中。

函数少，编码简单，能够实现IO的多路复用。

epoll函数（非阻塞链接）

创建socket通信

int sockfd=socket(AF_INET,SOCK_STREAM,0);

AF_INET ipv4的协议族

流式套接字(SOCK_STREAM)

protocol：指定应用程序使用的通讯协议，一般取值为0,让系统决定使用的协议。

成功：返回新建的套接字描述符；失败：返回-1。并将错误码放入 errno

设置ip和port

struct sockaddr_in seraddr = {0} 

清空：bzero(&seraddr,sizeof(seraddr));

seraddr.sin_family = AF_INET;(协议)

seraddr.sin_port = htons(atoi(端口号))；

seraddr.sin_addr.s_addr = inet_addr(IP地址);

socklen_t len = sizeof(seraddr);

监听

flag=listen(sockfd,20);

sockfd:监听客户端连接请求

20：l连接队列中的最大个数，自定

创建epoll节点

int epollfd = epoll_create(EPOLL_FLAG);

EPOLL_CTL_ADD 添加fd到节点上

EPOLL_CTL_MOD 修改fd在节点上

EPOLL_CTL_DEL 从节点删除fd

创建节点的结构体并赋值

struct epoll_event ev;

bzero(&ev,sizeof(ev));

ev.events = EPOLLIN;

添加可读的事件

可读EPOLLIN 可写EPOLLOUT 异常EPOLLERR

ev.data.fd = sockfd;

文件描述符

文件描述符 -- 添加到epoll的节点

int flag = epoll_ctl(epollfd,EPOLL_CTL_ADD,sockfd,&ev);

0：success

-1:error

创建监控事件的结构体数组

struct epoll_event even[EPOLL_FLAG];

EPOLL_FLAG值自定义

epoll内核监控这些节点

maxfd = epoll_wait(epollfd,even,EPOLL_FLAG,-1);

even:存储事件

EPOLL_FLAG：检测个数

时间 0 --- 立即返回 ， -1-- 阻塞等待事件到来

返回值

活跃的文件描述符的个数max_fd

-1：error

轮询查看文件描述符变化

int ifd = even[i].data.fd;

if((ifd == sockfd)&&(even[i].events == EPOLLIN))

struct sockaddr_in cliaddr;

socklen_t len=sizeof(cliaddr);

accfd=accept(sockfd,(struct sockaddr*)&cliaddr,&len);

accfd添加到epollfd

bzero(&ev,sizeof(ev)); ev.events = EPOLLIN; ev.data.fd = accfd; if(epoll_ctl(epollfd,EPOLL_CTL_ADD,accfd,&ev)==-1) { perror("epoll_ctl"); exit(1); }

else

接收请求

struct sockaddr_in cliaddr;

socklen_t len=sizeof(cliaddr);

accfd=accept(sockfd,(struct sockaddr*)&cliaddr,&len)

接收消息

rd=read(accfd,buf,sizeof(buf));

-1失败

0：断开连接

回收资源 ,fd -- epollfd中删除

epoll_ctl(epollfd,EPOLL_CTL_DEL,accfd,NULL);

成功

发送消息 sd=send(accfd,buf,sizeof(buf),0);

关闭套接字

相对于select的改进

没有最大并发量的限制，打开文件的个数（6位数）

效率问题：只管活跃的文件描述符

内存拷贝问题：epoll机制，会和内存实现“内存共享”方式，减少拷贝，提高效率

 收藏

立即使用

应用开发

 收藏

立即使用

C++思维导图

西西

职业：本

去主页





0 条评论

下一页

为你推荐

查看更多



AI大模型应用全景视图-大模型应用-AI应用开发-AI架构图

大模型应用架构图

统一账单数据层开发应用结构

AI大模型应用开发架构图