linux 进程编程

最新推荐文章于 2024-09-12 20:58:18 发布

haohaisun

最新推荐文章于 2024-09-12 20:58:18 发布

阅读量243

点赞数 1

分类专栏： linux c 文章标签： linux 编程

本文链接：https://blog.csdn.net/haohaisun/article/details/72850639

版权

linux c 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一、进程的操作

1、进程的创建

父进程与子进程之间的关系是管理与被管理，当子进程终止时，父进程不一定终止；父进程终止时子进程一定终止。

Linux系统启动时只有一个进程：init进程，进程号为1。

可以通过getpid()获取自身运行的进程ID，通过getppid()获取父进程的ID。

这两个函数在头文件<unistd.h>当中。

printf("Process ID :%d\n",(int)getpid());

2、fork（）函数

创建经常一般有两种方法：system()和fork（）函数。

pid_t   fork();

一个进程通过fork()函数会创建一个子进程，这个子进程和父进程只有进程ID不同，其他都一样，若子进程创建失败，则fork（）函数返回-1，若创建成功则在子进程中返回0，在父进程中返回子进程的ID。

#include<stdio.h>
#include<unistd.h>
#include<sys/types.h>
int main()
{
    pid_t child_pid;
    child_pid =fork();
    switch (child_pid)
    {
    case  -1:
        printf("Create Process failed!\n");
        break;
    case 0:
    printf("child Proces with ID %d\n",(int)getpid());
        break;
        default:

        printf("Parent Process with %d,child Proces Id:%d\n",(int)getppid(),getpid());
        break;
    }
    return 0;
}

3、进程的管理与调度

Linux下管理进程的命令有：at bg fg jobs kill ps pstree top noce sleep

4、进程的终止

子进程运行完毕后，并不立即释放所占用的进程控制表项，而作为僵进程存在，直到父进程终止或者调用wait（）函数终止。

pid_t   wait(int *status)

wait()函数会让父进程阻塞自己，分析已经退出的子进程，wait（）函数会返回子进程结束状态值，如果没有找到一个这样的子进程，会一直阻塞。status 会储存子进程结束信息。

另一个函数waitpid()，可以设定参数设置让指定的子进程终止。

pid_t  waitpid(pid_t pid,int *status,int option);

WIFEXITED(status)

能够判断子进程是否正常结束，如果正常结束，则返回个非0值。

#include<stdio.h>
#include<unistd.h>
#include<sys/types.h>
#include<sys/wait.h>
int main()
{
    pid_t child_pid,pid;
    int status;

    child_pid=fork();
    switch (child_pid)
    {
        case -1:
        printf("Creadte Process failed\n");
        break;
        case 0:
        printf("child Process with ID %d\n",(int)getpid());
        break;
    default:
    printf("Parent Process with ID %d,Child Process with ID %d",(int)getpid(),(int)child_pid);
    pid=wait(&status);
    printf("Child Process finished:PID=%d\n",child_pid);
    if(WIFEXITED(status))
    printf("ChildProcess exited with code %d\n",WEXITSTATUS(status));
    else 
    printf("Child Process Terminated Abnormally\n");
        break;
    }
    return 0;
}

二、进程间的通信

1、信号

定义在头文件<signal.h>中

用kill -l 可以查看所有信号。

可以通过signal（）或者sigaction()函数设定某个信号的处理方法。

void （*signal(int signum,void(*handler)(int)))(int);

int sigaction(int signum,const struct sigaction *act,struct sigaction *oldact);

第一个参数为信号值，可以为除SIGKILL SIGSTOP外的信号；第二个参数是指向结构的一个实例指针，指定对特定信号的处理，可以为空；第三个参数指向的对象用来保存对相应信号的处理，可以设定为NULL。

信号的使用主要步骤为：安装信号，实现信号，处理函数，发送信号。信号的生命周期从信号发送开始，到相应的处理函数结束。

#include<signal.h>
#include<unistd.h>
#include<stdio.h>
#include<sys/time.h>

void SignalHandle(int signal)  //信号处理函数
{
    switch (signal)
    {
    case  SIGHUP:
        printf("Catch Signal: SIGHUP(%d)\n",signal);
        break;
    case SIGINT:
    printf("Catch Signal:SIGINT(%d)\n",signal);
    break;
    case SIGQUIT:
    printf("Catch Signal:SIGQUIT(%d)\n",signal);
    break   ;
    case SIGALRM:
    printf("Catch Signal :SIGALRM(%d)\n",signal);
    break;
    default:
    printf("UNknow Signal:%d",signal);
        break;
    }
}

int main()
{
    int sec_delay=5;
    printf("Current Process Id:%d\n",(int)getpid());
    signal(SIGQUIT,SignalHandle);
    signal(SIGALRM,SignalHandle);
    alarm(sec_delay);  //5s后输出
    while(1)
    pause();
    return 0;
}

2、命名管道命令

管道一端顺序写入数据，另一端顺序读数据，数据只能向一个方向流动，所以要双方通信要两个管道。

命名管道利用建立系统特殊文件，以FIFO的文件形式存在，一般使用mkfifo()函数创建相应的文件。

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

第一个参数是文件路径，mode是打开方式。

#include<unistd.h>
#include<fcntl.h>
#include<limits.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<stdlib.h>
#include<stdio.h>
#include<string.h>

#define FIFO_HANDLE_NAME "/tmp/fifo_hanfle"    
#define FIFO_CLIENT_NAME "/tmp/fifo_client_%d "
struct ps_fifo_struct{
    pid_t pid;
    char str[64];
};

int main()
{
    int fifo_handle,fifo_client;
    struct ps_fifo_struct ps_fifo;
    char client_fifo_name[64];

    fifo_handle=open(FIFO_HANDLE_NAME,O_WRONLY);  
    if(fifo_handle==-1)
    {
        fprintf(stderr,"Open handle fifo failed\n");
        exit(EXIT_FAILURE);
    }
    ps_fifo.pid=getpid();
    memset(client_fifo_name,0,64);
    sprintf(client_fifo_name,FIFO_CLIENT_NAME,ps_fifo.pid);
    if(access(client_fifo_name,F_OK)==-1){
        if(mkfifo(client_fifo_name,0777)!=0){
            fprintf(stderr,"Could not create fifo %s\n",client_fifo_name);
            exit(EXIT_FAILURE);
        }
    }

    sprintf(ps_fifo.str,"hi,I'm %d",ps_fifo.pid);
    printf("%d sent:\'%s'.\n",ps_fifo.pid,ps_fifo.str);
    write(fifo_handle,&ps_fifo,sizeof(ps_fifo));
    fifo_client=open(client_fifo_name,O_RDONLY);
    if(fifo_client!=-1){
        if(read(fifo_client,&ps_fifo,sizeof(ps_fifo))>0)
        printf("received from %d:%s\n",ps_fifo.pid,ps_fifo.str);
        close(fifo_client);
    }
    close(fifo_handle);
    unlink(client_fifo_name);
    exit(EXIT_SUCCESS);
}

#include<unistd.h>
#include<fcntl.h>
#include<limits.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<stdlib.h>
#include<stdio.h>
#include<string.h>

#define FIFO_HANDLE_NAME "/tmp/fifo_hanfle"   //fifo 文件
#define FIFO_CLIENT_NAME "/tmp/fifo_client_%d " 
struct ps_fifo_struct{
    pid_t pid;      //进程的PID
    char str[64];  //对应的FIFO文件名
};

int main()
{
    int fifo_handle,fifo_client;
    char client_fifo_name[64];
    char answer_str[64];
    struct ps_fifo_struct ps_fifo;
    int read_len;
//如果文件不存在且建立文件失败
    if(access(FIFO_HANDLE_NAME,F_OK)==-1)     
    {
        if(mkfifo(FIFO_HANDLE_NAME,0777)==-1){
            fprintf(stderr,"Could not create fifo %s\n",FIFO_CLIENT_NAME);
            exit(EXIT_FAILURE);
        }
    }

     fifo_handle=open(FIFO_HANDLE_NAME,O_RDONLY);//打开处理的fifo文件
    if(fifo_handle==-1)
    {
        fprintf(stderr,"Open handle fifo failed\n");
        exit(EXIT_FAILURE);
    }
    while(read_len>0)
    {
        read_len=read(fifo_handle,&ps_fifo,sizeof(ps_fifo));  //读取文件里的内容
        memset(answer_str,0,64);
        if(read_len>0){
            sprintf(answer_str,"hi,%d,Ihavereceivedhestring:'%s'.",ps_fifo.pid,ps_fifo.str);
            printf("received from %d:%s\n",ps_fifo.pid,ps_fifo.str);
            memset(client_fifo_name,0,64);
            sprintf(client_fifo_name,FIFO_CLIENT_NAME,ps_fifo.pid);
            fifo_client=open(client_fifo_name,O_WRONLY); //打开对应的另一个进程的文件
            ps_fifo.pid=getpid();
            sprintf(ps_fifo.str,answer_str);  
            if(fifo_client!=-1){
                write(fifo_client,&ps_fifo,sizeof(ps_fifo));  //写入这个文件当中
                close(fifo_client);
            }

        }
    }
    close(fifo_handle);
    unlink(FIFO_HANDLE_NAME);
    exit(EXIT_SUCCESS);
}

3、信号量

主要用来控制多个进程对临界资源的互斥访问，信号量是一种进程的同步机制。

key_t ftok(char *pathname,char proj);
int semget(key_t key,int nsems,int semflg);
int semop(int semid,struct sembuf *spos,int nspos);
int semctl(int semid,int semnum,int cmd,union semun arg);

ftok()函数创建一个关键字，成功时返回一个键值，失败时返回-1.

semget()函数创建一个新的信号量或者取得一个现有的信号量。

nsems表明创建信号量的个数。

semflg设置信号量的访问权限标志，调用成功返回信号量的ID，失败返回-1.

semop用于改变信号量键值，semid是信号标志，spos是表明进行什么操作的结构指针，nspos表示数组元素的个数。

semctl()对信号量进行一系列的控制，SETVAL 设置信号量的值，IPC_RMID删除信号量。

#include<unistd.h>
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/sem.h>

#define SEM_PATHNAME "/tmp/my_sem"
union semun{
    int val;
    struct semid_ds *buf;
    unsigned short *array;
    struct semfifo *__buf;
    void *__pad;
};

int main(int argc,char *argv[])
{
    int sem_id,sem_key;
    union semun arg_ctl;
    struct sembuf sem_bufinfo;
    int option_get=IPC_CREAT|IPC_EXCL|0666;
    sem_key=ftok(SEM_PATHNAME,'X');
    sem_id=semget(sem_key,1,option_get);
    printf("semaphore id=%d.\n",sem_id);
    arg_ctl.val=1;
    if(-1==semctl(sem_id,0,SETVAL,arg_ctl))
    perror("semctl error");
    printf("value of semaphore at index 0 is %d.\n",semctl(sem_id,0,GETVAL,arg_ctl));
    sem_bufinfo.sem_num=0;
    sem_bufinfo.sem_op=-1;
    sem_bufinfo.sem_flg=IPC_NOWAIT;
    semop(sem_id,&sem_bufinfo,1);
    printf("value of semaphore at index 0 is %d \n",semctl(sem_id,0,GETVAL,arg_ctl));
    return 0;
}

4、信号队列

消息队列是将消息按队列的方式组成链表。

int msgget(key_t key,int msgflg);
int msgsnd(int msqid,const void *msgptr,int msgsz,int msgflg);
int msgrcv(int msqit,void *msgptr,int msgsz,long msgtyp,int msgflg);
int msgctl(int msqid,int cmd,struct msqid_ds *buf);

#include<sys/types.h>
#include<sys/msg.h>
#include<unistd.h>
#include<stdlib.h>
#include<stdio.h>

int main()
{
    int msg_id,msg_flags;
    int reval;
    char send_msg[64];
    msg_flags=IPC_CREAT|0666;
    msg_id=msgget((key_t)456,msg_flags);  //建立消息队列
    sprintf(send_msg,"Hi,I am%d.",getpid());
    reval=msgsnd(msg_id,send_msg,sizeof(send_msg),0);  //将消息发送到队列中
    return 0;
}#include<sys/types.h>
#include<sys/msg.h>
#include<unistd.h>
#include<stdlib.h>
#include<stdio.h>

int main()
{
    int msg_id,msg_flags;
    int reval;
    char send_msg[64];
    msg_flags=IPC_CREAT|0666;
    msg_id=msgget((key_t)456,msg_flags);  //建立消息队列
    reval=msgrcv(msg_id,send_msg,64,0,0);
    printf("Received msg:%s\n",send_msg);
    reval=msgctl(msg_id,IPC_RMID,0);
    return 0;
}



5、共享内存
在linux中只要吧共享内存段连接到进程的地址空间中，这个进程就可以访问共享内存中的地址。
1、int shmget(key_t key,int shmsz,int shmflg);
该函数分配一块共享内存，shmsz指明共享内存的大小，shmflg的设置和其他函数中的类似。
如果调用成功则返回共享内存的ID，否则-1；
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);
实现对共享内存区域的操作控制。