linux系统编程
linux系统编程
文章目录
- linux系统编程
-
- linux
-
- 概述
- 环境搭建
- VIM编辑器常用指令
- GDB调试工具
- 文件
-
- 打开与关闭文件
- 读写字节
- 文件描述符
- 动态与静态文件
- main函数的参数
- 读写结构体
- 用标准c库读写文件
- linux进程
-
- 程序与进程
- 进程标识符
- 父子进程
- 内存分配
- 创建进程
- 结束进程
- 进程退出状态
- EXEC族函数
- system函数
- popen函数
- linux线程
-
- 概述
- 相关API
- 线程
- 互斥锁
- 线程死锁
- 条件
- 进程通信
-
- 无名管道通信（PIPE）
-
- 特点
- 创建与关闭
- 使用方法
- 有名管道通信（FIFO）
-
- 特点
- 创建与关闭
- 使用方法
- 消息队列（msg）
-
- 特点
- 创建
- 使用方法
- 键值生成
- 共享内存（shm）
-
- 特点
- 创建
- 使用方法
- 信号（signal）
-
- 概述
- 信号处理函数的注册
- 信号发送函数
- 带消息的信号
- 信号量(semaphore)
-
- 概述
- 创建与控制信号量
- 获取和释放锁
- 使用方法
- 网络编程
-
- 通信协议
- 字节序
- API
- Socket服务器
- Socket客户端
- makefile
- Tools
-
-
- Typora
-
linux
概述
1.免费使用和自由传播的类Unix操作系统
2.版本
发行版： ubuntu <–嵌入式开发
cent os <–web服务器
红旗linux
Linux内核：发行版基于Linux内核进行二次开发
IOS
Android
环境搭建
虚拟机：为一个设备同一时间运行多个操作系统提供可能 vmware
真机：公司的研发服务器
VIM编辑器常用指令
h、j、k、l 移动光标
x 删除一个字符
dd 删除一行
u 撤销
Ctrl + r REDO
p 粘贴
y 复制（需选中）
yy 复制一行
/XXX 查找XXX n下一个 N上一个
：n 跳转到n行
：wq 保存并退出
：q！ 强制退出（不保存）
GDB调试工具
要使用GDB来调试程序，编译时要加入 -g 选项
gdb a.out 进入GDB调试
set args 1 2 3 向可执行文件输入参数1 2 3
list n 从第n行开始列出源代码
b n 在第n行设置断点
delete n 删除断点
run 运行程序，遇到断点会停止，命令后可加传入参数
display 显示变量值
set x=6 将x设置为6
continue 继续运行
next 下一行
step 进入函数
finish 退出函数
print 打印变量，表达式，函数 如：print var print 2+3 print sum(3)
q 退出GDB
文件
打开与关闭文件
#include读写字节
#include文件描述符
linux默认有文件描述符：0(标准输入) 1(标准输出) 2(标准错误)
每个进程至少有上述3个打开的文件描述符，除非显示关闭
c库中它们被宏定义 STDIN_FILENO STDOUT_FILENO STDERR_FILENO
文件描述符不仅用于普通文件访问，也用于访问设备文件，管道，FIFO，套接字等
一切皆文件，读写的东西均可用文件描述符来访问
read (0,buffer,5);//从终端即键盘读入5个字节放入buffer
write (1,buffer,5);//从buffer输出5个字节到shell即标准输出
文件描述符只在当前的进程使用，用于识别哪一个文件，非本进程的文件标识符是没有意义的
打开文件后要关闭文件，防止文件的丢失
动态与静态文件
文件存在磁盘，此时的文件成为静态文件
而文件被进程打开后，Linux内核将file读入内存，并由结构体来记录文件信息，此时文件为动态文件，对文件的操作为动态文件，close后，磁盘文件被更新
硬盘以块存储，内存中以字节存储
main函数的参数
int main (int arge, char **argv) {
/*
argv表示从终端读入的字符串个数
argv是指向指向char*即字符串的指针，用来存储各个字符串
argv[0] argv[1] argv[2] 可依次获取字符串
如：在命令行输入如 ./a.out char1 char2
*/
return 0;
}
读写结构体
Data* temp = (Data*)malloc(sizeof(Data));
Data data = {
10,"hello"};
int fd = open("data",O_RDWR|O_CREAT|O_TRUNC,0600);
write(fd,&data,sizeof(Data));
lseek(fd,0,SEEK_SET);
read(fd,temp,sizeof(Data));
printf("%d\t%s\n",temp->num,temp->s);
close(fd);
用标准c库读写文件
open：是unix系统调用函数（包括linux），返回文件描述符，它是在文件描述符表里的索引
fopen：是ANSIC标准中的C语言函数，不同系统中会调用不同的API，返回指向文件结构的指针
fopen因此具有良好的执行性，更接近系统内核，open只能UNIX系统下使用,比如在WINDOWS下无法使用
#includelinux进程
程序与进程
程序是静态的概念，磁盘中的可执行文件为程序，而进程为程序运行时的动态概念
命令行下
ps -aux ：查看当前设备所有进程
ps -aux|grep name ：查看带name的进程来过滤
top ：展示任务管理器
进程标识符
与文件标识符类似，每一个进程都有一个非负整数表示唯一的ID，叫做pid（linux下通常是C语言的int类型）
pid=0：交换进程：进程调度
pid=1：init进程：系统初始化
#include 父子进程
即A进程创建了进程B
每一个进程都是由其他进程创建的（除了init进程），因此每一个子进程都有一个父进程
内存分配
低地址------------------------------------------------->高地址
正文 初始化的数据 未初始化的数据 堆 栈 命令行和环境变量
如：[代码段] [初始化过的变量] [函数外未初始化的数据] [用户申请的空间] [函数调用时, 产生的内存] [argc.argv]
创建进程
/*
创建一个和当前进程印像一样的进程
返回2次值，一次返回到父进程，一次返回子进程
父进程中的pid为子进程的ID号
子进程中的pid为0
-1表示内部错误，并设置errno
*/
#include 子进程会共享代码即内存并在修改内存时选择性复制内存的存储（写时复制）来执行，较早的 linux 会直接全部复制
进程变量的修改是独立的，不会相互影响，创建进程后父子进程将一起同时运行
/*
vfork也可创建进程
区别有2：vfork产生的子进程会与父进程共享内存，父进程会被挂起进入等待，等待子进程运行结束或运行了一个新的可执行文件映像（如调用exit(0)时），父进程才继续运行
*/
结束进程
正常退出
#include 非正常退出
#include 进程终止时，内核会执行一段代码，用于释放内存，关闭文件等
进程退出状态
不对子进程退出状态进行收集，该子进程会成为僵死进程，它们只保留最小的概要信息
只要父进程获取了子进程的信息，子进程就会消失，否则将保持僵死状态
收集子进程退出状态：
/*
父进程在调用下面函数后会进入阻塞等待子进程结束并收集其状态
返回已经终止的子进程pid或者返回-1表示出错
子进程如果终止，它将立即返回子进程的pid
*/
#include /*
当有多个进程时，我们只需要等待一个特定的进程终止后返回状态
参数pid是要等待进程的pid（fork函数调用的返回值为子进程的pid），当传入-1时表示任意子进程
参数status和wait()用法是一致的
options: WCONTINUED WNOHANG(主进程不阻塞) WUNTRACED 按位运算或0
如果执行成功则返回子进程的pid ,错误返回-1，并修改errno
*/
#include 父进程不等待子进程而推出后，子进程便成为孤儿进程
linux为避免父进程不等待和提前结束而造成的僵死进程，init进程（pid=1）将作为这些进程的父进程，因为每一个进程的结束，都会引发内核来遍历它的子进程
EXEC族函数
/*
在调用的进程内执行一个可执行文件（二进制文件或任何可执行的脚本）
执行成功后原程序将不再执行，而是执行所调用的程序，这是因为函数会调用path中的映像载入内存来替换当前进程
path&file：路径 arg&argv[]：依次为所带参数，第一个必须为执行文件名字，然后为参数，必须以NULL结尾
执行失败返回-1，然后从原程序进行往下执行，并修该errno的值 TIPS:perror(const char* string);可打印失败原因
*/
#include 一般与fork（）配合使用
system函数
用于执行shell命令，实质是封装后的exec，与之不同是是它执行时，原进程会等待它结束，完毕后会继续执行原进程
/*
调用/bin/sh失败返回127，其他原因失败返回-1
*/
#includepopen函数
/*
可以通过文件流获取运行的输出结果，而非直接输出到shell
command:指向一个以NULL结束的shell命令字符串指针
mode:r或w 返回的文件指针链接到command的标准输入或输出
返回的文件流可用fread来读取 只能用pclose()结束进程
*/
FILE* popen (const char* command, const char* mode);
linux线程
概述
典型的UNIX/LInux进程可以看成只有一个控制线程，一个进程在同一时刻只做一件事，而有了多个控制线程，一个进程在同一时间就可做不止一件事
进程是线程的容器，是分配系统资源的基本单位，其中有多个线程，并共享一块内存（有自己的栈）,任意线程调用exit（）后进程将会结束，同时，所有线程均结束运行
多个进程独立，互不影响，但资源耗费大，效率略低，对并发操作多线程更合适，通信也跟方便，而多个线程当一个线程出现问题，整个进程将会崩溃
相关API
/*
linux平台有成熟的pthread库支持，它是第三方库
*/
#include 线程
void* run (void* arg) {
static const int flag = 10;
printf("flag from main is %d\n",*((int*)arg));
int i;
for(i = 0; i<3; i++) {
printf("this is t print,%ld\n",(unsigned long)pthread_self());
sleep(1);
}
pthread_exit ((void*)&flag);
}
int main (int argc, char const *argv[])
{
pthread_t t;
int* p;
int arg = 10;
pthread_create (&t, NULL, run, (void*)&arg);
pthread_join (t, (void**)&p);
printf("msg from t is %d\n",*p);
int i;
for(i = 0; i<3; i++) {
printf("this is main print,%ld\n",(unsigned long)pthread_self());
sleep(1);
}
return 0;
}
互斥锁
#define count 3
int flag;
pthread_mutex_t mutex;
void* run1 (void* arg) {
pthread_mutex_lock (&mutex);
int i;
for (i = 0; i < count; ++i)
{
printf("flag from run1 is %d\n",flag++);
}
pthread_mutex_unlock (&mutex);
}
void* run2 (void* arg) {
pthread_mutex_lock (&mutex);
int i;
for (i = 0; i < count; ++i)
{
printf("flag from run2 is %d\n",flag++);
}
pthread_mutex_unlock (&mutex);
}
int main (int argc, char const *argv[])
{
pthread_mutex_init (&mutex, NULL);
pthread_t t1;
pthread_create (&t1, NULL, run1, NULL);
pthread_t t2;
pthread_create (&t2, NULL, run2, NULL);
sleep(5);
pthread_mutex_destroy (&mutex);
return 0;
}
线程死锁
2个及以上的锁的时候才会造成线程死锁，即互相想获得对方已经拥有的锁
条件
int a;
pthread_cond_t cond;
pthread_mutex_t mutex;
void* run1 (void* arg) {
pthread_mutex_lock (&mutex);
pthread_cond_wait (&cond, &mutex);
printf("this is run1 print, run1 is end\n");
pthread_mutex_unlock (&mutex);
}
void* run2 (void* arg) {
int i;
for ( i= 0; i < 5; i++) {
pthread_mutex_lock (&mutex);
printf("this is run2 print, a = %d\n",a++);
if(a == 3){
pthread_cond_signal (&cond);
}
pthread_mutex_unlock (&mutex);
sleep(1);
}
}
int main(int argc, char const *argv[])
{
pthread_mutex_init (&mutex, NULL);
pthread_cond_init (&cond, NULL);
pthread_t t1;
pthread_create (&t1, NULL, run1, NULL);
pthread_t t2;
pthread_create (&t2, NULL, run2, NULL);
pthread_join (t1, NULL);
pthread_join (t2, NULL);
pthread_mutex_destroy (&mutex);
pthread_cond_destroy (&cond);
return 0;
}
/*生产者与消费者 from CSDN*/
#include 进程通信
进程间通信(IPC，InterProcess Communication)：在不同进程之间传播或交换信息
IPC的方式：管道（无名管道和命名管道）、消息队列、信号量、共享存储、Socket、Stream等（后两个支持不同主机上的两个进程IPC）
无名管道通信（PIPE）
特点
1.数据单方向，比如同一时间只能一个进程写一个进程读，不能同时读取,也称半双工管道
2.有“亲缘关系”的进程间，如父子进程
3.数据写入后，读取后便消失（不存储数据），只存在于内存中，由内核来管理
创建与关闭
#include使用方法
int main (int arge, char* argv[]) {
int fd[2];
pipe(fd);
int pid = fork();
if(pid >0 ) {
wait(NULL);
close(fd[1]); //要把不关心的管道端关掉
char buf[128];
read(fd[0],buf,128); //用read和write来读写
puts(buf);
}else if (pid == 0) {
close(fd[0]);
write(fd[1],"hello",5);
}else {
puts("ERROR");
}
return 0;
}
有名管道通信（FIFO）
特点
它和无名管道一样，也是单向的通信
不同的是它可以和无关的进程间交换数据，并且它有路径名与之关联，它以一种特殊的设备文件形式存在与系统文件即磁盘内
创建与关闭
#include /*
用open来打开这个文件，即链接到管道
当没有指定O_NONBLOCK（默认）时，只读open会进入阻塞直到某个其他进程为写而打开此FIFO，只写open会进入阻塞直到某个其他进程为读而打开此FIFO
用close来关闭这个文件
*/
close (fd)；
使用方法
int flag = mkfifo("./fifo", 0600);
if(flag < 0 && errno != EEXIST) {
//当仅文件创建按失败时执行if语句内的内容
perror(""); //加入与运算时因为如果文件存在flag的值将为-1
}
int fd = open("./fifo",O_RDONLY); //链接到管道并进入阻塞，直到另一个进程为读而打开它
printf("open sucessfully");
while(1) {
char* buf = (char*)malloc(128);
read(fd,buf,128);
//sleep(3);
puts(buf);
free(buf);
}
//----------------
int main (int arge, char* argv[]) {
int fd = open("./fifo",O_WRONLY); //链接到管道并进入阻塞，直到另一个进程为写而打开它
while(1) {
char buf[128];
gets(buf);
write(fd, buf,sizeof(buf));
puts(buf);
}
}
消息队列（msg）
特点
消息队列，就是消息的链接表，存放在内核中，一个消息队列由一个标识符（队列ID）来标识
消息具有特定的格式和特定的优先级
数据被读取，进程被结束，消息列表内容不会被删除
可以随即查询，不一定要先进先出，可按消息类型读取
创建
#include #include ）
当flag是权限信息，当IPC_CREAT且没有与key对应的消息队列时，创建
成功返回ID，失败返回-1
*/
int msgget (key_t key,int flag);
/*
发送消息
为msqid队列上添加一个消息,ptr指向一个消息缓冲区，flag可设置为0表示忽略
成功返回0，失败返回-1
*/
int msgsnd (int msqid, const void *msgp, size_t size, int flag);
//msgp所指向的内存空间应该仿照以下结构
struct msgbuf {
long mtype; /* message type, must be > 0 */
char mtext[1]; /* message data */
};
/*
接收消息
从msqid的队列中，获取类型为msgtyp的消息类型，并把它放入msgp所指向的内存，消息的结构大小（不含mtype）为msgsz， flag为0时当队列中没有消息时，会等待消息的接收
成功返回消息数据长度，失败返回-1
*/
int msgrcv (int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);//type：消息类型
/*
控制消息队列
对队列进行cmd的命令
成功返回0，失败返回-1
*/
int msgctl (int msqid, int cmd, struct msqid_ds *buf);
msgctl (msgId, IPC_RMID,NULL);
//上述可移除消息队列ID为msgId的队列
使用方法
struct msgbuf {
//消息缓冲区的结构，可以根据实际情况加以修改，但mtype是一致的，且总大小不超过8192个字节
long mtype;
char mtext[128];
};
int main(int argc, char const *argv[]) {
int msgId = msgget(ftok(".",2), IPC_CREAT|0777);
struct msgbuf msgBuf = {
111,"hello"};
// while(1){
msgsnd(msgId, &msgBuf, strlen(msgBuf.mtext),0);
printf("msg is sending");
sleep(10);
// }
return 0;
}
//---------------------------------------------------------------------------------------------------
struct msgbuf {
long mtype; /* message type, must be > 0 */
char mtext[128]; /* message data */
};
int main(int argc, char const *argv[])
{
int msgId = msgget(ftok(".",2), IPC_CREAT|0777);
struct msgbuf msgBuf;
msgrcv(msgId, &msgBuf, 128, 111, 0);
printf("rcv is %s", msgBuf.mtext);
return 0;
}
键值生成
#include 共享内存（shm）
特点
进程间共享一块物理内存空间的通信方式，它是IPC最快捷的方式
创建
#include 命令行下ipcs -m可查看当前系统的共享内存ipcs -m id可删除共享内存
使用方法
int shmId = shmget(ftok(".",1),1024,IPC_CREAT|0666);
char* buf=(char*)shmat(shmId,NULL,0);
strcpy(buf,"hello world");
shmdt(buf);
getchar();
return 0;
//---------------------------------------------------------------------------------------------------
int shmId = shmget(ftok(".",1),1024,IPC_CREAT|0666);
char* buf=(char*)shmat(shmId,NULL,0);
puts(buf);
shmdt(buf);
getchar();
shmctl(shmId,IPC_RMID,NULL);
return 0;
信号（signal）
概述
信号，为linux提供了一种处理异步事件的方法
每个信号都有一个名字和编号，这些名字以SIG开头，信号定义在signal.h头文件中，信号名都定义为正整数
如SIGQUIT SIGKILL SIGINT
命令行下，kill -l 来查看信号名字和编号（从1开始编号），如kill -9 pid 可结束进程
信号处理：忽略，捕捉，默认动作(SIGKILL SIGSTOP不允许忽略)
常用的时信号捕捉：写一个信号处理函数，这个函数在内核被注册，当该信号产生时，内核将会调用它
每一个信号系统都有默认的处理动作，当然你可以自定义这些动作，也可以在程序中发出某个信号
信号处理函数的注册
#include 信号发送函数
#include 带消息的信号
#include #include 信号量(semaphore)
概述
首先它和信号没有什么关系
用途：它是一种计数器，常常被用做一个锁机制，对于某些进程的共享资源，同一时间只能一个进程进行操作临界资源，以避免数据出错混乱
原理：
设信号量值为1
当一个进程1运行时，使用资源，进行P操作，即对信号量值减1，也就是资源数少了1个。这时信号量值为0。系统中规定当信号量值为0时，必须等待，直到信号量值不为零才能继续操作。
这时如果进程2想要运行，那么也必须进行P操作，但是此时信号量为0，所以无法减1，即不能P操作，也就阻塞。这样就达到了进程1排他访问。
当进程1运行结束后，释放资源，进行V操作。资源数重新加1，这时信号量的值变为1.
这时进程2发现资源数不为0，信号量能进行P操作了，立即执行P操作。信号量值又变为0，此时进程2占有资源，排他访问资源。
信号量集：信号量的集合
p操作：拿锁
v操作：放回锁
创建与控制信号量
#include 获取和释放锁
#include 使用方法
int main(int argc, char const *argv[]) {
int semid = semget (ftok(".",2), 1, IPC_CREAT|0666); //建立一个具有一个信号量的信号量集合
union semun {
int val;
struct semid_ds *buf;
unsigned short *array;
struct seminfo *__buf;
};
union semun initsem；
initsem.val = 0;
semctl (semid, 0, SETVAL, initsem); //初始化信号量，使信号量为0
pid_t pid = fork(); //当然,默认是1
if (pid >0){
struct sembuf set1;
set1.sem_num = 0;
set1.sem_op = -1;
set1.sem_flg = SEM_UNDO;
semop (semid, &set1, 1); //在信号量上无法减去了一个值，该进程挂起，等待子进程v操作
printf("this is father print\n"); //子进程v操作后，父进程信号量可以进行减一，开始执行
struct sembuf set2;
set2.sem_num = 0;
set2.sem_op = 1;
set2.sem_flg = SEM_UNDO;
semop (semid, &set2, 1); //在信号量上增加了一个值，信号量为1
semctl (semid, 0, IPC_RMID); //移除信号量
}
else if (pid == 0){
printf("this is child print\n"); //父进程被挂起时，子进程前半部分不受影响的执行
struct sembuf set2;
set2.sem_num = 0;
set2.sem_op = 1;
set2.sem_flg = SEM_UNDO;
semop (semid, &set2, 1); //在信号量上增加了一个值，现在父进程可以执行了
}
return 0;
}
网络编程
多设备之间进程的通信，依赖于网络，需要借助地址：IP地址、端口号和协议
通信协议
Socket（套接字）通信协议：
TCP：面向链接：建立在链接基础上，然后进行通信，较为可靠的，仅支持一对一
UDP：面向报文：只管发送，而不管是否接收，尽最大努力交付，不保证可靠性，支持一对一或一对多
端口号：
IP地址的主机可以提供许多服务，基于一个IP，所以通过IP地址+端口号来实现
字节序
字节序是指多字节在计算机内存中存储或者网络传输时个字节的存储顺序
Litle endian（小端字节数）：将低序字节存储在起始位置
Big endian（大端字节数）：将低序字节存储在起始位置
网络字节序 = 大端字节序
API
#include Socket服务器
int sockfd;
sockfd = socket (AF_INET, SOCK_STREAM, 0); /*建立套接字*/
struct sockaddr_in s_addr;
memset(&s_addr, 0, sizeof(struct sockaddr_in));//清空
s_addr.sin_family = AF_INET;//设置协议
s_addr.sin_port = htons(9000);//设置端口
inet_aton ("192.168.8.108", &s_addr.sin_addr);//设置ip
bind (sockfd, (struct sockaddr*)&s_addr, sizeof(struct sockaddr_in)); /*设置服务器地址并绑定*/
listen (sockfd, 10); /*设置监听队列*/
struct sockaddr_in c_addr;
memset(&c_addr, 0, sizeof(struct sockaddr_in));
int size = sizeof(struct sockaddr_in);
int sock_fd = accept (sockfd, (struct sockaddr*)&c_addr, &size); /*接收链接*/
puts(inet_ntoa (c_addr.sin_addr));//打印客户端信息
char* msg = (char*)malloc(128);
write (sock_fd,"hello\n", 7); /*读写数据*/
read (sock_fd, msg, 128);
printf("%s\n", msg);
getchar();
close(clnt_fd); /*关闭套接字*/
return 0;
Socket客户端
int clnt_fd = socket (AF_INET, SOCK_STREAM, 0); /*建立套接字*/
struct sockaddr_in c_addr;
memset(&c_addr, 0, sizeof(struct sockaddr_in));
c_addr.sin_family = AF_INET;
c_addr.sin_port = htons(9000);
inet_aton ("192.168.8.108", &c_addr.sin_addr);//配置服务器地址
int a =connect (clnt_fd, (struct sockaddr*)&c_addr, sizeof(struct sockaddr_in)); /*链接服务器*/
if (a == -1)
{
perror("");
}
char* msg = (char*)malloc(128);
read (clnt_fd, msg, 128); /*读写数据*/
printf("%s\n", msg);
write (clnt_fd,"hi\n", 4);
getchar();
close(clnt_fd); /*关闭套接字*/
return 0;
makefile
target:dependencies
command
test:test.c
gcc test.c -o test
#当前文件夹下执行下面的命令
make
main:main.c tool.c
gcc main.c tool.o -o main
tool.o:tool.c
gcc -c tool.c
clean:
rm *.o
#清除文件
make clean
main:main.c foo.o bar.o
gcc main.c foo.o bar.o -o main
foo.o:foo.c
gcc -c foo.c
bar.o:bar.c
gcc -c bar.c
clean:
rm *.o
CC = gcc
main:main.c foo.o bar.o
$(CC) main.c foo.o bar.o -o main
foo.o:foo.c
$(CC) -c foo.c
bar.o:bar.c
$(CC) -c bar.c
clean:
rm *.o
CC = gcc
all:main_max main_min
main:main_max.c foo.o bar.o
$(CC) main_max.c foo.o bar.o -o main_max
main:main_min.c foo.o bar.o
$(CC) main_min.c foo.o bar.o -o main_min
foo.o:foo.c foo.h
$(CC) -c foo.c
bar.o:bar.c bar.h
$(CC) -c bar.c
clean:
rm *.o