多任务编程项目 （2） -- 7.9.2024和7.10.2024

学习目标：

Linux

linux应用开发(高级编程):
（1）数据存储问题：文件和数据库
（2）多任务编程：进程 和 线程
（3）网络编程：tcp udp

---

学习内容：

进程、进程通信

7.9.2024
进程：

1. 概念
2. 进程编程
3. 进程通信

进程通信：

1. 管道通信
2. 消息队列
3. 共享内存

7.10.2024
函数指针

1. 概念
2. 作用
3. 函数指针数组

共享内存

1. 概念
2. 编程

信号

1. 概念
2. 编程

---

学习时间：7.9.2024 和7.10.2024

7.9 7.10

• 7.9 上午和下午
• 7.10 上午和下午

---

学习笔记：

7.9.2024

进程：1、概念 2、编程 3、进程通信

一、概念
	1、进程是动态概念，一个程序运行多次产生多个进程


	2、三种状态：
	     运行态 就绪态 阻塞态
	
	3、产生进程：
	     父和子进程

二、进程编程
	fork()
	返回值是两个值
	     父进程空间返回是子的id号
	     子进程空间返回是0
	getpid()
	getppid（）
	
	wait()
	waitpid()
	
	阻塞式等待

	exit(-1);


所有管道都是单向的

三、进程通信：管道通信 消息队列 共享内存 信号

1、管道通信
一、概念
   1、在进程之间假设一条管道，通过管道传输字节流
   2、管道本质上是一个文件，该文件有两个文件描述符，一个读端和一个写端
   3、通过写端写入数据，如果管道写满或者读端未打开则阻塞当前进程
   4、通过读端读取数据，数据从管道中读走，如果管道为空，则阻塞当前进程
   5、管道文件分类：
	无名管道（匿名管道）：用在亲缘进程之间通信
	有名管道:用在任意进程之间通信
	
二、编程实现
   
      1、创建管道：
           创建无名管道 
            int fd[2] = {0};
            ret = pipe(fd);

            fd[0]--读端
            fd[1]--写端

           创建有名管道：
            int mkfifo(const char * pathname,mode_t mode);

     2、读写管道：用标准文件系统调用
 2、消息队列：
一、概念
    1、队列（特点：先进先出）是一种数据结构
    2、os提供队列操作一系列函数：
	创建队列 入队列 出队列 销毁队列
       （具有阻塞机制）
       
二、编程
         1、创建队列
                key_t ftok(const char *pathname, int proj_id);

                int msgget(key_t key, int msgflg);
                功能：创建或者获取队列
                返回值：队列标识符
             
         2、入队
                int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);

		struct msgbuf {
   		  long mtype;   /* 消息类型，必须 > 0 */
  		  char msg[100];/* 消息文本 */
		};

          3、出队：
              ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtype, int msgflg);
          
          4、销毁队列
              int msgctl ( int msgqid, int cmd, struct msqid_ds *buf );

7.10.2024

函数指针：

一、概念
   1、函数在内存中起始地址，即指向函数的指针
   2、函数名就是函数首地址
   3、函数指针变量定义：
	（1）定义：（返回值类型）（*指针变量名）（形参类型列表） = NULL;	
	（2）指向：指针变量名 = 函数名；
	（3）使用：通过函数指针调用函数

   	 int （*p）（int,int） == NULL;
 
   4、解决函数a作为函数b的参数引入语法
	{
		double (*p1)(double)
		p1 = sin;

		double (*p2)(double)
		p1 = cos;	
	
 		res = fun(sin,cos,1.2);
  		res = fun(cos,sin,1.2);
  		double fun(double (*p1)(double),double (*p2)(double),double arg)
  		{
        		   return (*p1)(arg)/(*p2)(arg);
 		}
	}

   5、给函数指针类型起别名
	typedef 返回值类型 （*类型名【FUN】【sighandler_t】）（形参类型列表）
	{
               typedef int(*FUN)(int,int);
               FUN p = NULL;
	}	

二、作用：
	函数作为函数参数
    实例1：
	{
             信号安装函数
                      typedef void (*sighandler_t)(int);
                      sighandler_t signal(int signum, sighandler_t handler);
	}
	
    实例2：
	{
             线程创建函数
                      int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                      void *(*start_routine) (void *), void *arg);
	}
	
    实例3：
	{
	     内核中结构体  struct file_operations
	}


三、函数指针数组
	方式一：
	int （*p）（int,int） = NULL;
	int （*p[10]）（int，int） = {NULL};

	方式二：
	typedef int（*FUN）（int，int）；
	FUN p = NULL;
	FUN P[10] = {NULL};

#include <sys/shm.h>
#include <sys/ipc.h>
共享内存 -- 效率高
一、概念
	1、“共享内存”：多个进程同时都可以访问内存区域
	2、申请共享内存 --> 映射共享内存到自己地址空间 -->访问用户地址空间相当于访问共享内存
	3、使用完之后解除映射 --> 删除共享内存
	4、访问共享内存即读写内存，没有阻塞机制，需要用户自行控制

二、编程
	1、创建或申请共享内存
		{key_t ftok(const char *pathname, int proj_id);

                 int shmget(key_t key, size_t size, int shmflg);
		}

	2、映射
		{void *shmat(int shmid, const void *shmaddr, int shmflg);}

	3、解除映射
		{int shmdt(const void *shmaddr);}	

	4、删除共享内存
		{int shmctl(int shmid, int cmd, struct shmid_ds *buf);}