标签 linux 下的文章

vmware-tool安装及设置共享目录

宿主计算机为windows系统,虚拟机为Cent OS 6.10
用VMware Workstation安装的时候会报错,这里是从VMware官网下载的包安装的

1. 下载vmtool安装包

2. 解压

unzip VMware-Tools-10.0.9-3917699.zip

3. 挂载linux iso文件

cd VMware-Tools-10.0.9-3917699/vmtools/
mkdir /tmp/vmware
mount -o loop linux.iso /tmp/vmware

4. 解压出安装包文件

cd /tmp/vmware/
cp VMwareTools-10.0.9-3917699.tar.gz /tmp/
cd /tmp/
chmod 777 VMwareTools-10.0.9-3917699.tar.gz
tar -zxvf VMwareTools-10.0.9-3917699.tar.gz

5. 安装,碰到选项一直回车就行

cd vmware-tools-distrib
# 给777权限,不然后面安装的时候会权限不足
chmod 777 -R vmware-tools-distrib
# 安装
./vmware-install.pl

6. 在 VMware 的虚拟机设置->选项中添加共享目录,我这里添加的名称为 share-dir(这个名称在第7步有用),windows路径为 E:\share-dir

7. 在linux虚拟机中把共享的目录挂载在虚拟机的目录上

mount -t vmhgfs .host:/share-dir /tmp/target-share-dir

ok了,如果需要开机就挂载的话,可以把第7步的命令放到开机脚本中

linux编程学习 05-02 网络编程

上一篇:http://jinblog.com/archives/866.html

网络高级编程

  • 前面介绍的函数如recv,send,read和write等函数都是阻塞性函数,若资源没有准备好,则调用该函数的进程将进入阻塞状态,下面介绍两种I/O复用的解决方案

    • fcntl函数实现(非阻塞)
    • select函数

I/O多路转换-select函数

int select(int maxfdp1,fd_set readfds,fd_set writefds,fd_set exceptfds,struct timeval timeout);

  • 头文件
#include <sys/types.h>
#include <sys/time.h>
#include <unistd.h>
  • 返回准备就绪的描述符数,若超时则为0,若出错则为-1
  • timval结构体
struct timeval
{
        long tv_sec;//seconds
        long tv_usec;//and microseconds
};
  • 参数

    • maxfdp1:最大fd加1(max fd plus 1),在三个描述符集中找出最高描述符编号值,然后加1,就是第一个参数的值
    • readfds,writefds,exceptfds:是指向描述符集的指针。这三个描述符集说明了我们关小的可读,可写或处于异常条件的各个描述符。每个描述符集存放在一个fd_set数据类型中
    • timeout:指定愿意等待的时间

      • NULL:永远等待,知道捕捉到信号或文件描述符已准备好为止
      • 具体值:struct timeval类型的指针,若等待为timeout时间,还没有文件描述符准备好,就立即返回
      • 0:从不等待,测试所有指定的描述符立即返回
  • 传向select的参数告诉内核

    • 我们所关心的描述符
    • 对于每个描述符我们所关心的条件(是否可读一个给定的描述符,是否可写一个指定的描述符,是否关心一个描述符的异常条件)
    • 希望等待多长时间(可以永远等待,等待一个固定量的时间,或完全不等待)
  • 从select返回时内核告诉我们

    • 已准备好的描述符的数量
    • 哪一个描述符已准备好读,写或异常条件
    • 使用这种返回值,就可调用相应的I/O函数(一般是write或read),并且确知该函数不会阻塞
  • select函数根据希望进行的文件操作对文件描述符进行分类处理,这里,对文件描述符的处理主要设计4个宏函数

    • FD_ZERO(fd_set* set) 清除一个文件描述符集
    • FD_SET(int fd,fd_set* set) 将一个文件描述符加入文件描述符集中
    • FD_CLR(int fd,fd_set* set) 将一个文件描述符从文件描述符集中清除
    • FD_ISSET(int fd,fd_set* set) 测试该集中的一个给定位是否有变化
  • 在使用select函数之前,首先使用FD_ZERO和FD_SET来初始化文件描述符集,并使用select函数时,可循环使用FD_ISSET测试描述符集,在执行完成对相关的文件描述符后,可用FD_CLR来清除描述符集

fcntl函数实现示例

#include <stdio.h>
// atoi函数
#include <stdlib.h>
// wait函数
#include <sys/wait.h>
// I/O函数
#include <unistd.h>
#include <time.h>
// socket 系列函数
#include <sys/socket.h>
// sockaddr_in 结构体
#include <netinet/in.h>
// hton 函数
#include <arpa/inet.h>
#include <signal.h>
// memset函数
#include <string.h>
// pthread库
#include <pthread.h>
// errno
#include <errno.h>
// fcntl函数
#include <fcntl.h>
// ctrl + c时关掉服务器socket
void siginit_handle(int);
// 初始化指定数目的线程处理连接
void child_thread_init(int);
// 客户端链表节点结构体
struct client_fd
{
        int fd;
        struct client_fd* pre;
        struct client_fd* next;
};
typedef struct client_fd client_fd;
// 链表
client_fd* client_fd_link = NULL;
// 链表互斥锁
pthread_mutex_t link_mutex;
// 服务器socket
int server_fd = 0;
// 添加链表元素
int add_client(int);
// 删除链表元素,通过fd删除元素
int del_client_by_fd(int);
// 通过节点地址删除元素
int del_client_by_client(client_fd*);
// 服务器连接日志
void server_log(struct sockaddr_in*);
// ctrl + c关闭服务器socket
void sigint_handle(int sig);

int main(int argc,char* argv[])
{
        if(argc < 2)
        {
                printf("incorrect parameter\n");
                return 1;
        }
        if(SIG_ERR == signal(SIGINT,sigint_handle))
        {
                perror("signal error");
                return 1;
        }
        // 初始化互斥锁
        pthread_mutex_init(&link_mutex,NULL);
        struct sockaddr_in server_attr;
        memset(&server_attr,0,sizeof(server_attr));
        /*
         * 1. 创建socket
         * socket创建在内核中,是一个结构体
         * AF_INET : IPV4
         * SOCK_STREAM : TCP协议
         */
        server_fd = socket(AF_INET,SOCK_STREAM,0);
        if(server_fd == -1)
        {
                perror("sock error");
                return 1;
        }

        /*
         * 2. 设置SO_REUSEADDR,避免重启导致bind报错
         */
        int opt = 1;
        setsockopt(server_fd,SOL_SOCKET,SO_REUSEADDR,(void*)&opt,sizeof(int));
        /*
         * 3. 调用bind函数将socket与地址(ip,port)进行绑定
         */
        server_attr.sin_family = AF_INET;
        // 转换位网络字节序
        server_attr.sin_port = htons((short)atoi(argv[1]));
        // 表示所有ip,也可以指定第一个ip,指定ip时要把主机字节序转换成网络字节序
        server_attr.sin_addr.s_addr = INADDR_ANY;
        // 绑定ip端口
        if(-1 == bind(server_fd,(struct sockaddr*)&server_attr,sizeof(server_attr)))
        {
                perror("bind error");
                return 1;
        }
        /*
         * 4. 调用listen函数启动监听,通知系统接收来自客户端的请求
         * 第二个参数代表客户端队列的长度
         * 执行成功后能用netstat查看
         */
        if(-1 == listen(server_fd,8))
        {
                perror("listen error");
                return 1;
        }

        // 忽略SIGPIPE信号处理函数,避免由于客户端断开连接,并由于read发送SIGPIPE信号导致进程结>束
        signal(SIGPIPE,SIG_IGN);
        int client_fd = 0;
        struct sockaddr_in client_attr;
        socklen_t addrlen = sizeof(client_attr);
        int client_flag = 0;
        // 开启子线程处理连接·
        child_thread_init(8);
        while(1)
        {
                /*
                * 5. 调用accept获得客户端连接,并返回一个新的socket文件描述符,新的文件描述符放>进client_fd链表中
                * 没有客户端连接,此函数会阻塞,直到获得一个客户端连接
                */
                client_fd = accept(server_fd,(struct sockaddr*)&client_attr,&addrlen);
                if(client_fd <= 0)
                {
                        continue;
                }
                server_log(&client_attr);
                // 修改socket为非阻塞读写
                client_flag = fcntl(client_fd,F_GETFL);
                client_flag |= O_NONBLOCK;
                fcntl(client_fd,F_SETFL,client_flag);
                add_client(client_fd);
                // 线程是共享的进程资源,这里不要关闭,不然线程里面的也没了
                // close(client_fd);
        }
        // close(server_fd);
        return 0;
}
void sigint_handle(int sig)
{
        close(server_fd);
        exit(0);
}
void server_log(struct sockaddr_in* client_attr)
{
        char ip[16] = {'\0'};
        // 结构体的的数据不能直接显示,需要先转换成本机字节序
        inet_ntop(AF_INET,&client_attr->sin_addr.s_addr,ip,sizeof(ip));
        printf("connected by %s:%d\n",ip,ntohs(client_attr->sin_port));
}
void* thread_handle(void* data)
{
        /*
        * 5. 遍历客户端socket_fd,对有输入的客户端进行回应
        */
        client_fd* temp;
        char res[512] = {'\0'},buf[512] = {'\0'};
        int read_len = 0,res_len = sizeof(res);
        while(1)
        {
                temp = client_fd_link;
                while(temp != NULL)
                {
                        read_len = read(temp->fd,res,res_len);
                        // 客户端关闭,则关闭客户端连接
                        if(read_len == 0)
                        {
                                perror("read");
                                del_client_by_client(temp);
                                break;
                        }
                        else if(read_len > 0)
                        {
                                // buf 与 res不能一样
                                sprintf(buf,"thread : %lu\nmessage : %s\n",pthread_self(),res);

                                sprintf(res,"%s\n",buf);

                                if(write(temp->fd,res,res_len) != res_len)
                                {
                                        // 客户端关闭,则关闭客户端连接
                                        if(errno == EPIPE)
                                        {
                                                perror("write");
                                                del_client_by_client(temp);
                                                break;
                                        }
                                }
                        }
                        temp = temp->next;
                }
        }
        return (void*)NULL;
}
void child_thread_init(int max)
{
        pthread_t tid = 0;
        // 初始化线程属性,用来创建分离的线程,使子线程结束后自动回收
        pthread_attr_t thread_attr;
        pthread_attr_init(&thread_attr);
        pthread_attr_setdetachstate(&thread_attr,PTHREAD_CREATE_DETACHED);
        // 子线程处理I/O,达到并发的效果
        while(max > 0)
        {
                pthread_create(&tid,&thread_attr,thread_handle,(void*)NULL);
                max--;
        }
}
// 添加链表元素
int add_client(int fd)
{
        pthread_mutex_lock(&link_mutex);
        if(client_fd_link == NULL)
        {
                client_fd_link = malloc(sizeof(client_fd));
                client_fd_link->pre = NULL;
                client_fd_link->next = NULL;
                client_fd_link->fd = fd;
                pthread_mutex_unlock(&link_mutex);
                return 0;
        }
        client_fd* temp = client_fd_link;
        while(temp->next != NULL)
        {
                temp = temp->next;
        }
        temp->next = malloc(sizeof(client_fd));
        temp->next->pre = temp;
        temp->next->next = NULL;
        temp->next->fd = fd;
        pthread_mutex_unlock(&link_mutex);
        return 0;
}
// 删除链表元素,通过fd删除元素
int del_client_by_fd(int fd)
{
        pthread_mutex_lock(&link_mutex);
        if(client_fd_link == NULL)
        {
                pthread_mutex_unlock(&link_mutex);
                return -1;
        }
        client_fd* temp = client_fd_link->next;
        // 链表第一个元素比较特殊,做特殊处理
        if(fd == client_fd_link->fd)
        {
                free(client_fd_link);
                client_fd_link = temp;
                if(client_fd_link != NULL)
                {
                        client_fd_link->pre = NULL;
                }
                pthread_mutex_unlock(&link_mutex);
                return 0;
        }
        while(temp != NULL)
        {
                if(temp->fd == fd)
                {
                        temp->pre->next = temp->next;
                        if(temp->next != NULL)
                        {
                                temp->next->pre = temp->pre;
                        }
                        close(temp->fd);
                        free(temp);
                        pthread_mutex_unlock(&link_mutex);
                        return 0;
                }
                temp = temp->next;
        }
        pthread_mutex_unlock(&link_mutex);
        return -1;
}
// 通过节点地址删除元素
int del_client_by_client(client_fd* client)
{
        pthread_mutex_lock(&link_mutex);
        if(client_fd_link == NULL)
        {
                pthread_mutex_unlock(&link_mutex);
                return -1;
        }
        client_fd* temp = client_fd_link->next;
        // 链表第一个元素比较特殊,做特殊处理
        if(client == client_fd_link)
        {
                free(client_fd_link);
                client_fd_link = temp;
                if(client_fd_link != NULL)
                {
                        client_fd_link->pre = NULL;
                }
                pthread_mutex_unlock(&link_mutex);
                return 0;
        }
        while(temp != NULL)
        {
                if(temp == client)
                {
                        temp->pre->next = temp->next;
                        if(temp->next != NULL)
                        {
                                temp->next->pre = temp->pre;
                        }
                        close(temp->fd);
                        free(temp);
                        pthread_mutex_unlock(&link_mutex);
                        return 0;
                }
                temp = temp->next;
        }
        pthread_mutex_unlock(&link_mutex);
        return -1;
}

select函数实现示例

#include <stdio.h>
// atoi函数
#include <stdlib.h>
// wait函数
#include <sys/wait.h>
// I/O函数
#include <unistd.h>
#include <time.h>
// socket 系列函数
#include <sys/socket.h>
// sockaddr_in 结构体
#include <netinet/in.h>
// hton 函数
#include <arpa/inet.h>
#include <signal.h>
// memset函数
#include <string.h>
// pthread库
#include <pthread.h>
// errno
#include <errno.h>
// fcntl函数
#include <fcntl.h>
#include <sys/types.h>
#include <sys/time.h>
// ctrl + c时关掉服务器socket
void siginit_handle(int);
// 初始化指定数目的线程处理连接
void child_thread_init(int);
// 客户端链表节点结构体
struct client_fd
{
        int fd;
        struct client_fd* pre;
        struct client_fd* next;
};
typedef struct client_fd client_fd;
// 链表
client_fd* client_fd_link = NULL;
// 链表互斥锁
pthread_mutex_t link_mutex;
// 服务器socket
int server_fd = 0;
// 添加链表元素
int add_client(int);
// 删除链表元素,通过fd删除元素
int del_client_by_fd(int);
// 通过节点地址删除元素
int del_client_by_client(client_fd*);
// 服务器连接日志
void server_log(struct sockaddr_in*);
// ctrl + c关闭服务器socket
void sigint_handle(int sig);
// 把链表中的fd加入到set中,并返回socket描述符最大的一个
int init_set(fd_set*);
int main(int argc,char* argv[])
{
        if(argc < 2)
        {
                printf("incorrect parameter\n");
                return 1;
        }
        if(SIG_ERR == signal(SIGINT,sigint_handle))
        {
                perror("signal error");
                return 1;
        }
        // 初始化互斥锁
        pthread_mutex_init(&link_mutex,NULL);
        struct sockaddr_in server_attr;
        memset(&server_attr,0,sizeof(server_attr));
        /*
         * 1. 创建socket
         * socket创建在内核中,是一个结构体
         * AF_INET : IPV4
         * SOCK_STREAM : TCP协议
         */
        server_fd = socket(AF_INET,SOCK_STREAM,0);
        if(server_fd == -1)
        {
                perror("sock error");
                return 1;
        }

        /*
         * 2. 设置SO_REUSEADDR,避免重启导致bind报错
         */
        int opt = 1;
        setsockopt(server_fd,SOL_SOCKET,SO_REUSEADDR,(void*)&opt,sizeof(int));
        /*
         * 3. 调用bind函数将socket与地址(ip,port)进行绑定
         */
        server_attr.sin_family = AF_INET;
        // 转换位网络字节序
        server_attr.sin_port = htons((short)atoi(argv[1]));
        // 表示所有ip,也可以指定第一个ip,指定ip时要把主机字节序转换成网络字节序
        server_attr.sin_addr.s_addr = INADDR_ANY;
        // 绑定ip端口
        if(-1 == bind(server_fd,(struct sockaddr*)&server_attr,sizeof(server_attr)))
        {
                perror("bind error");
                return 1;
        }
        /*
         * 4. 调用listen函数启动监听,通知系统接收来自客户端的请求
         * 第二个参数代表客户端队列的长度
         * 执行成功后能用netstat查看
         */
        if(-1 == listen(server_fd,8))
        {
                perror("listen error");
                return 1;
        }

        // 忽略SIGPIPE信号处理函数,避免由于客户端断开连接,并由于read发送SIGPIPE信号导致进程结>束
        signal(SIGPIPE,SIG_IGN);
        int client_fd = 0;
        struct sockaddr_in client_attr;
        socklen_t addrlen = sizeof(client_attr);
        // 开启子线程处理连接·
        child_thread_init(8);
        while(1)
        {
                /*
                * 5. 调用accept获得客户端连接,并返回一个新的socket文件描述符,新的文件描述符放>进client_fd链表中
                * 没有客户端连接,此函数会阻塞,直到获得一个客户端连接
                */
                client_fd = accept(server_fd,(struct sockaddr*)&client_attr,&addrlen);
                if(client_fd <= 0)
                {
                        continue;
                }
                server_log(&client_attr);
                add_client(client_fd);
                // 线程是共享的进程资源,这里不要关闭,不然线程里面的也没了
        }
        return 0;
}
void sigint_handle(int sig)
{
        close(server_fd);
        exit(0);
}
void server_log(struct sockaddr_in* client_attr)
{
        char ip[16] = {'\0'};
        // 结构体的的数据不能直接显示,需要先转换成本机字节序
        inet_ntop(AF_INET,&client_attr->sin_addr.s_addr,ip,sizeof(ip));
        printf("connected by %s:%d\n",ip,ntohs(client_attr->sin_port));
}
void response(client_fd* temp)
{
        char res[512] = {'\0'},buf[512] = {'\0'};
        int read_len = 0,res_len = sizeof(res);
        read_len = read(temp->fd,res,res_len);
        // 客户端关闭,则关闭客户端连接
        if(read_len == 0)
        {
                printf("close connection\n");
                del_client_by_client(temp);
                return;
        }
        else if(read_len > 0)
        {
                // buf 与 res不能一样
                sprintf(buf,"thread : %lu\nmessage : %s\n",pthread_self(),res);

                sprintf(res,"%s\n",buf);

                if(write(temp->fd,res,res_len) != res_len)
                {
                        // 客户端关闭,则关闭客户端连接
                        if(errno == EPIPE)
                        {
                                printf("close connection\n");
                                del_client_by_client(temp);
                                return;
                        }
                }
        }
}
void* thread_handle(void* data)
{
        /*
        * 5. 遍历客户端socket_fd,对有输入的客户端进行回应
        */
        client_fd* temp;
        fd_set set;
        int max = init_set(&set);
        struct timeval time = {2,0};
        int n = 0;
        while(1)
        {
                // printf("n : %d;max : %d\n",n,max);
                // 注意:是文件描述符最大的加1,
                n = select(max + 1,&set,NULL,NULL,&time);
                temp = client_fd_link;
                while(temp != NULL && n > 0)
                {
                        if(FD_ISSET(temp->fd,&set) == 0)
                        {
                                continue;
                        }
                        response(temp);
                        temp = temp->next;
                        n--;
                }
                // 时间需要重新设置
                time.tv_sec = 2;
                time.tv_usec = 0;
                // 用最新的连接信息设置set,重设最大值
                max = init_set(&set);
        }
        return (void*)NULL;
}
void child_thread_init(int max)
{
        pthread_t tid = 0;
        // 初始化线程属性,用来创建分离的线程,使子线程结束后自动回收
        pthread_attr_t thread_attr;
        pthread_attr_init(&thread_attr);
        pthread_attr_setdetachstate(&thread_attr,PTHREAD_CREATE_DETACHED);
        // 子线程处理I/O,达到并发的效果
        while(max > 0)
        {
                pthread_create(&tid,&thread_attr,thread_handle,(void*)NULL);
                max--;
        }
}
// 添加链表元素
int add_client(int fd)
{
        pthread_mutex_lock(&link_mutex);
        if(client_fd_link == NULL)
        {
                client_fd_link = malloc(sizeof(client_fd));
                client_fd_link->pre = NULL;
                client_fd_link->next = NULL;
                client_fd_link->fd = fd;
                pthread_mutex_unlock(&link_mutex);
                return 0;
        }
        client_fd* temp = client_fd_link;
        while(temp->next != NULL)
        {
                temp = temp->next;
        }
        temp->next = malloc(sizeof(client_fd));
        temp->next->pre = temp;
        temp->next->next = NULL;
        temp->next->fd = fd;
        pthread_mutex_unlock(&link_mutex);
        return 0;
}
// 删除链表元素,通过fd删除元素
int del_client_by_fd(int fd)
{
        pthread_mutex_lock(&link_mutex);
        if(client_fd_link == NULL)
        {
                pthread_mutex_unlock(&link_mutex);
                return -1;
        }
        client_fd* temp = client_fd_link->next;
        // 链表第一个元素比较特殊,做特殊处理
        if(fd == client_fd_link->fd)
        {
                free(client_fd_link);
                client_fd_link = temp;
                if(client_fd_link != NULL)
                {
                        client_fd_link->pre = NULL;
                }
                pthread_mutex_unlock(&link_mutex);
                return 0;
        }
        while(temp != NULL)
        {
                if(temp->fd == fd)
                {
                        temp->pre->next = temp->next;
                        if(temp->next != NULL)
                        {
                                temp->next->pre = temp->pre;
                        }
                        close(temp->fd);
                        free(temp);
                        pthread_mutex_unlock(&link_mutex);
                        return 0;
                }
                temp = temp->next;
        }
        pthread_mutex_unlock(&link_mutex);
        return -1;
}
// 通过节点地址删除元素
int del_client_by_client(client_fd* client)
{
        pthread_mutex_lock(&link_mutex);
        if(client_fd_link == NULL)
        {
                pthread_mutex_unlock(&link_mutex);
                return -1;
        }
        client_fd* temp = client_fd_link->next;
        // 链表第一个元素比较特殊,做特殊处理
        if(client == client_fd_link)
        {
                free(client_fd_link);
                client_fd_link = temp;
                if(client_fd_link != NULL)
                {
                        client_fd_link->pre = NULL;
                }
                pthread_mutex_unlock(&link_mutex);
                return 0;
        }
        while(temp != NULL)
        {
                if(temp == client)
                {
                        temp->pre->next = temp->next;
                        if(temp->next != NULL)
                        {
                                temp->next->pre = temp->pre;
                        }
                        close(temp->fd);
                        free(temp);
                        pthread_mutex_unlock(&link_mutex);
                        return 0;
                }
                temp = temp->next;
        }
        pthread_mutex_unlock(&link_mutex);
        return -1;
}
int init_set(fd_set* set)
{
        client_fd* temp = client_fd_link;
        // 清空set
        FD_ZERO(set);
        int max = 0;
        while(temp != NULL)
        {
                // 获取最大的set
                if(max < temp->fd)
                {
                        max = temp->fd;
                }
                // 把client_fd加入set中
                FD_SET(temp->fd,set);
                temp = temp->next;
        }
        return max;
}

守护进程

  • 守护进程(deamon)是生存期长的一种进程。他们常常在系统装入时启动,在系统关闭时终止。
  • 所有守护进程都以超级用户(用户ID为0)的优先权运行
  • 守护进程没有控制终端
  • 守护进程的父进程都是init进程

守护进程编程步骤

  1. 使用umask将文件模式创建创建屏蔽字设置为0
  2. 调用fork,然后让父进程退出(exit)
  3. 调用setsid创建一个新会话
  4. 将当前工作目录更改为根目录
  5. 关闭不需要的文件描述符

守护进程出错处理

  • 由于守护进程完全脱离了控制终端,因此,不能像其他程序一样通过输出错误信息到控制台的方式来通知程序员
  • 通常的方式是使用syslog服务,将出错信息输入到“/var/log/syslog”系统日志文件中
  • syslog是linux中的系统日志管理服务,通过守护进程syslog来维护

syslog服务说明

  • openlog函数用于打开系统日志服务的一个连接
  • syslog函数用于向日志文件中写入消息,在这里可以规定消息的优先级,消息的输出格式等
  • closelog函数用于关闭系统日志服务的连接
openlog函数

void openlog(char* ident,int option,int facility);

  • 头文件
#include <syslog.h>
  • 参数

    • ident:要向每个消息加入的字符串,通常为程序名称
    • option

      • LOG_CONS 若日志消息不能通过发送至syslog,则将该消息写至控制台
      • LOG_NDELAY 立即打开linux域数据报套接口至syslog守护进程。通常,在记录第一条消息之前,该套接口不打开
      • LOG_PERROR 除将日志发送给syslog外,还将他写至stderr
      • LOG_PID 每条消息都包含进程id,此选择项可供对每个请求都fork一个子进程的守护进程使用
    • facility

      • LOG_AUTH 授权程序,如login,su,getty等
      • LOG_CRON cron和at
      • LOG_DAEMON 系统守护进程,如ftpd,routed等
      • LOG_KERN 内核产生的消息
      • LOG_LOCAL0~7 保留由本地使用
      • LOG_LPR 行打系统,如lpd,lpc等
      • LOG_MAIL 邮件系统
      • LOG_NEWSU senet网络新闻系统
      • LOG_SYSLOG syslog守护进程本身(用这个就ok)
      • LOG_USER 来自其他用户进程的消息
      • LOG_UUCP UUCP系统
syslog和closelog函数

void syslog(int priority,char* format,...);
void closelog(void);

  • 头文件
#include <syslog.h>
  • 参数

    • priority:消息优先级

      • LOG_EMERG 紧急(系统不可使用,最高优先级)
      • LOG_ALERT 必须立即修复的条件
      • LOG_CRIT 临界条件(例如,硬设备出错)
      • LOG_ERR 出错条件
      • LOG_WARNING 警告条件
      • LOG_NOTICE 正常,但重要的条件
      • LOG_INFO 信息性消息
      • LOG_DEBUG 调试排错消息(最低优先级)

示例

示例为select函数例子的main函数部分,注意要把头文件加上去和其他部分补齐才能运行

int main(int argc,char* argv[])
{
        if(argc < 2)
        {
                printf("incorrect parameter\n");
                return 1;
        }
        if(SIG_ERR == signal(SIGINT,sigint_handle))
        {
                perror("signal error");
                return 1;
        }
        /* 守护进程变成步骤  */
        // 1. 使用umask将文件模式创建屏蔽字设置为0
        umask(0);
        // 2. 调用fork,然后让父进程退出
        int pid = fork();
        if(pid > 0)
        {
                exit(0);
        }
        // 3. 调用setsid创建一个新会话
        setsid();
        // 4. 将当前工作目录更改为根目录
        chroot("/");
        // 5. 关闭不需要的文件描述符
        close(STDIN_FILENO);
        close(STDOUT_FILENO);
        close(STDERR_FILENO);

        /* 使用syslog */
        // 1. 打开
        openlog("jin",LOG_PID,LOG_SYSLOG);
        // 2. 记录
        syslog(LOG_INFO,"jin deamon start");
        // 3. 关闭
        closelog();

        // 初始化互斥锁
        pthread_mutex_init(&link_mutex,NULL);
        struct sockaddr_in server_attr;
        memset(&server_attr,0,sizeof(server_attr));
        /*
         * 1. 创建socket
         * socket创建在内核中,是一个结构体
         * AF_INET : IPV4
         * SOCK_STREAM : TCP协议
         */
        server_fd = socket(AF_INET,SOCK_STREAM,0);
        if(server_fd == -1)
        {
                perror("sock error");
                return 1;
        }

        /*
         * 2. 设置SO_REUSEADDR,避免重启导致bind报错
         */
        int opt = 1;
        setsockopt(server_fd,SOL_SOCKET,SO_REUSEADDR,(void*)&opt,sizeof(int));
        /*
         * 3. 调用bind函数将socket与地址(ip,port)进行绑定
         */
        server_attr.sin_family = AF_INET;
        // 转换位网络字节序
        server_attr.sin_port = htons((short)atoi(argv[1]));
        // 表示所有ip,也可以指定第一个ip,指定ip时要把主机字节序转换成网络字节序
        server_attr.sin_addr.s_addr = INADDR_ANY;
        // 绑定ip端口
        if(-1 == bind(server_fd,(struct sockaddr*)&server_attr,sizeof(server_attr)))
        {
                perror("bind error");
                return 1;
        }
        /*
         * 4. 调用listen函数启动监听,通知系统接收来自客户端的请求
         * 第二个参数代表客户端队列的长度
         * 执行成功后能用netstat查看
         */
        if(-1 == listen(server_fd,8))
        {
                perror("listen error");
                return 1;
        }

        // 忽略SIGPIPE信号处理函数,避免由于客户端断开连接,并由于read发送SIGPIPE信号导致进程结>束
        signal(SIGPIPE,SIG_IGN);
        int client_fd = 0;
        struct sockaddr_in client_attr;
        socklen_t addrlen = sizeof(client_attr);
        // 开启子线程处理连接·
        child_thread_init(8);
        while(1)
        {
                /*
                * 5. 调用accept获得客户端连接,并返回一个新的socket文件描述符,新的文件描述符放>进client_fd链表中
                * 没有客户端连接,此函数会阻塞,直到获得一个客户端连接
                */
                client_fd = accept(server_fd,(struct sockaddr*)&client_attr,&addrlen);
                if(client_fd <= 0)
                {
                        continue;
                }
                server_log(&client_attr);
                add_client(client_fd);
                // 线程是共享的进程资源,这里不要关闭,不然线程里面的也没了
        }
        return 0;
}

linux编程学习 04 进程间通信

进程间通信概述

  • 数据传输:一个进程需要将它的数据发送给另一个进程,发送的数据量在一个字节到几兆字节之间
  • 共享数据:多个进程想要操作共享数据,一个进程对共享数据的修改,别的进程应该立刻看到
  • 通知事件:一个进程需要向另一个或一组进程发送消息,通知他们发生了某种事件(如进程终止时要通知父进程)
  • 资源共享:多个进程之间共享同样的资源。为了做到这一点,需要内核提供锁和同步机制。
  • 进程控制:有些进程希望完全控制另一个进程的执行(如debug进程),此时控制进程希望能够拦截另一个进程的所有陷入和异常,并能知道他的状态和改变

进程间通信的变革

  • linux进程间通信(IPC)由以下几个部分发展而来

    • 早期unix进程间通信
    • 基于System V进程间通信
    • 基于socket进程间通信和POSIX进程间通信
  • unix进程间通信的方式包括:管道,FIFO,信号
  • System V进程间通信方式包括:System V消息队列,System V信号灯,System V共享内存
  • POSIX进程间通信包括:POSIX消息队列,POSIX信号灯,POSIX共享内存

现代的进程间通信的方式

  • 管道(pipe)和命名管道(FIFO)
  • 信号(signal)
  • 消息队列
  • 共享内存
  • 信号量
  • 套接字(socket)

管道通信

  • 管道是针对于本地计算机的两个进程之间的通信而设计的通信方法,管道建立后,实际获得两个文件描述符:一个用于读取而另一个用于写入
  • 最常见的IPC通信机制,通过pipe系统调用
  • 管道是单工的,数据只能向一个方向流动,需要双向通信时,需要建立起两个管道
  • 数据的读出和写入:一个进程向管道中写的内容被管道另一端的进程读出。写入的内容每次都添加在管道缓冲区的末尾,并且每次都是从缓冲区头部读出数据
  • 本质上是在内核中的一个缓存

管道分类

  • 匿名管道

    • 在关系进程中进行(父进程和子进程,兄弟进程之间)
    • 由pipe系统调用,管道由父进程建立
    • 管道位于内核空间,其实是一块缓存
  • 命名管道

    • 两个没有任何关系的进程之间通信可通过命名管道进行数据传输,本质是内核中的一块缓存,另在文件系统中以一个特殊的设备文件(管道文件)存在
    • 通过系统调用mkfifo创建

匿名管道创建

int pipe(int fp[2]);

  • 返回:成功返回0,出错返回-1
  • 头文件:
#include <unistd.h>
  • 两个文件描述符数组

    • fd[0]:为pipe的读端
    • fd[1]:为pipe的写端
    • fd[0]用于读取管道,fd[1]用于写入管道

管道读写

管道主要用于不同进程间通信,实际上,通常先创建一个管道,再通过fork函数创建一个子进程

示例

基本使用
int main(void)
{
        int fp[2];
        if(pipe(fp) == -1)
        {
                perror("create pipe error");
                return 1;
        }
        int pid = fork();
        int i = 0;
        if(pid == -1)
        {
                perror("fork error");
                return 1;
        }
        else if(pid > 0)
        {
                // 父进程写入,先关闭管道读端
                close(fp[0]);
                i = 8;
                if(sizeof(int) != write(fp[1],(void*)&i,sizeof(int)))
                {
                        perror("first write error");
                        return 1;
                }
                i = 88;
                if(sizeof(int) != write(fp[1],(void*)&i,sizeof(int)))
                {
                        perror("second write error");
                        return 1;
                }
                wait(NULL);
                close(fp[1]);
        }
        else if(pid == 0)
        {
                // 子进程读,先关闭管道写端
                close(fp[1]);
                int j = 0;
                if(-1 == read(fp[0],(void*)&j,sizeof(int)))
                {
                        perror("first read error");
                        return 1;
                }
                printf("first read;i = %d\n",j);
                if(-1 == read(fp[0],(void*)&j,sizeof(int)))
                {
                        perror("second read error");
                        return 1;
                }
                printf("second read;i = %d\n",j);
                close(fp[0]);
        }

        return 0;
}
达到 cat /etc/passwd | grep root 的效果
#include <stdio.h>
#include <unistd.h>
char* command1[] = {"cat","/etc/passwd",NULL};
char* command2[] = {"grep","root",NULL};
int main(void)
{
        int fp[2];
        // 备份标准输出
        int stdout_copy = dup(STDOUT_FILENO);
        if(-1 == pipe(fp))
        {
                perror("pipe error");
                return 1;
        }
        int pid = fork();
        if(pid == -1)
        {
                perror("first fork error");
                return 1;
        }
else if(pid == 0)// 读取内容进程
        {
                // 关闭读端
                close(fp[0]);
                // cat命令默认从标准输出读取数据,使用dup2命令把标准输出转换成管道的输入端
                dup2(fp[1],STDOUT_FILENO);
                close(fp[1]);
                if(execvp(command1[0],command1) == -1)
                {
                        // 显示出错信息前先把标准输出还原
                        dup2(stdout_copy,STDOUT_FILENO);
                        printf("fail to execute %s",command1[0]);
                        perror("\n");
                        return 1;
                }
        }
        else if(pid > 0)
        {
                pid = fork();
                if(pid == -1)
                {
                        perror("second fork error");
                        return 1;
                }
                else if(pid == 0)// 过滤内容进程
                {
                        // 关闭写端
                        close(fp[1]);
                        // 和上面进程一样,把标准输入转换成管道出口
                        dup2(fp[0],STDIN_FILENO);
                        close(fp[0]);
                        if(execvp(command2[0],command2) == -1)
                        {
                                dup2(stdout_copy,STDOUT_FILENO);
                                printf("fail to execute %s",command2[0]);
                                perror("\n");
                                return 1;
                        }
                }
                else// 主进程
                {
                        // 回收进程资源
                        printf("\n");
                        wait(NULL);
                        // 关闭
                        close(fp[0]);
                        close(fp[1]);
                }
        }
        return 0;
}

管道的读写特性

  • 通过打开两个管道来创建一个双向的管道
  • 管道是阻塞性的,当进程从管道中读取数据,若没有数据进程会阻塞
  • 当一个进程往管道中不断写入数据但是没有进程去读取数据,此时只要管道没有满是可以的,但若管道放满数据则会报错
  • 不完整管道

    • 当读一个写端已经被关闭的管道时,在所有数据被读取后,read返回0,以表示到达了文件末尾
    • 如果写一个读端已被关闭的管道,则产生信号SIGPIPE,如果忽略该信号或捕捉该信号并从处理程序返回,则write返回-1,同时errno设置为EPIPE
  • 示例
#include <stdio.h>
#include <unistd.h>
#include <signal.h>
void func1(void);
void func2(void);
int main(void)
{
        func2();
        return 0;
}
/* 读取写端被关闭的管道  */
void func1(void)
{
        int fp[2];
        if(-1 == pipe(fp))
        {
                return;
        }
        int pid = fork();
        if(pid == -1)
        {
                perror("fork error");
                return;
        }
        else if(pid == 0)
        {
                close(fp[0]);
                write(fp[1],"I am child precess\n",19);
                close(fp[1]);
        }
        else
        {
                sleep(3);
                close(fp[1]);
                char c = '\0';
                while(1)
                {
                        // 写端被关闭,读完管道中的数据后返回0,不会阻塞
                        if(0 == read(fp[0],&c,1))
                        {
                                break;
                        }
                        printf("%c",c);
                }
                close(fp[0]);
        }
}
void sigpipe_handle(int sig)
{
        printf("I am sigpipe_handle\n");
        return;
}
/* 往读端被关闭的管道写入数据 */
void func2(void)
{
        int fp[2];
        pipe(fp);
        close(fp[1]);
        signal(SIGPIPE,sigpipe_handle);
        if(-1 == write(fp[0],"8",1))
        {
                perror("write pipe error");
                return;
        }
        close(fp[0]);
}

标准库中的管道操作

FILE* popen(const char* cmdstring,const char* type);

  • 返回值:成功返回文件指针,出错返回NULL
    int pclose(FILE *fp);
  • 返回值:cmdstring的终止状态,出错返回-1
  • 头文件
#include <stdio.h>
  • 使用popen创建的管道必须使用pclose关闭。其实popen/pclose和标准文件输入/输出流中的fopen/fclose十分相似
  • 封装管道的常用操作
  • 示例
int main(void)
{
        // 读
        FILE *f = popen("cat /etc/passwd","r");
        char str[1024] = {'\0'};
        while(NULL != fgets(str,1024,f))
        {
                // printf("%s",str);
        }
        pclose(f);
        // 写
        f = popen("wc -l","w");
        fprintf(f,"/etc/passwd\n/etc/shadow");
        pclose(f);
        return 0;
}

命名管道FIFO创建

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

  • 返回:成功返回0,出错返回-1
  • 头文件
#include <sys/types.h>
#include <sys/stat.h>
  • 只要对FIFO有适当访问权限,FIFO可用在任何两个没有任何关系的进程之间通信。
  • 本质是内核的一块缓存,另外在文件系统中以一个特殊的设备文件(管道文件)存在
  • 在文件系统中只有一个索引块存放文件的路径,没有数据块,所有数据存放在内核中。
  • 命名管道必须读和写同时打开,否则单独读或者单独写会引发阻塞
  • 命名mkfifo创建命名管道(命令内部调用mkfifo函数)
  • 对FIFO的操作与操作普通文件一样
  • 一旦已经用mkfifo创建了一个FIFO,就可以用open打开它,一般文件I/O函数(open,close,write,read,unlink等)都可用于FIFO
  • FIFO相关出错信息

    • EACCES(无存取权限)
    • EEXIST(指定文件不存在)
    • ENAMETOOLONG(路径名太长)
    • ENOENT(包含的目录不存在)
    • ENOSPC(文件系统剩余空间不足)
    • ENOTDIR(文件路径无效)
    • EROFS(指定文件存在于只读文件系统中)
  • 示例
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
int main(int argc,char* argv[])
{
        if(argc < 2)
        {
                printf("incorret parameter\n");
                return 1;
        }
        // 创建管道文件
        char *path = "/tmp/fifo_test";
        mkfifo("/tmp/fifo_test",0777);
        int f = open(path,O_RDWR);
        char str[8] = {'\0'}; 
        // 可以启动两个,一个读取一个写入
        if(strcmp("w",argv[1]) == 0)
        {
                scanf("%s",str);
                write(f,str,8);
        }
        else if(strcmp("r",argv[1]) == 0)
        {
                read(f,str,8);
                printf("str = %s\n",str);
        }
        close(f);
        return 0;
}

System V IPC

概述

  • unix系统存在信号,管道和命名通道等基本进程间通信机制
  • System V引入了三种高级进程间通信机制

    • 消息队列,共享内存和信号量
  • IPC对象(消息队列,共享内存和信号量)存在于内核中而不是文件系统中,由用户控制释放(用户管理IPC对象的生命周期),不像管道的释放由内核控制
  • IPC对象通过其标识符来引用和访问,所有IPC对象在内核空间中有唯一性标识,在用户空间中的唯一性标识称为key
  • linux IPC继承自System V IPC

System V IPC对象访问

  • IPC对象是全局对象

    • 可用ipcs,ipcrm等命令查看或删除
  • 每个IPC对象都由get函数创建

    • msgget,shmget,semget
    • 调用get函数时必须指定关键字key

IPC对象的权限和所有者结构体

struct ipc_perm
{
        uid_t uid;// owner's effective user id
        gid_t gid;// owner's effective group id
        uid_t cuid;// creator's effective user id
        gid_t cgid;// creator's effective group id
        mode_t mode;// access mode
        ......
};

消息队列

  • 消息队列是内核中的一个链表
  • 用户进程将数据传输到内核后,内核重现添加一些如用户id,组id,读写进程的id和优先级等相关信息后并打包成一个数据包称为消息
  • 允许一个或多个进程往消息队列中写消息读消息,但一个消息只能被一个进程读取,读取完毕后就自动删除
  • 消息队列具有一定的FIFO的特性,消息可以按照顺序发送到队列中,也可以以几种不同的方式从队列中读取。每一个消息队列在内核中用一个唯一的IPC标识id表示。
  • 消息队列的实现包括创建和打开队列,发送消息,读取消息和控制消息队列四种操作
消息队列属性
struct msqid_ds{
        struct ipc_perm msg_perm;
        msgqnum_t msg_qnum;// of message on queue
        msglen_t msg_qbytes;// max of bytes on queue 最大消息字节数
        pid_t msg_lspid;// pid of last msgsnd() 最后一次发送消息的进程的pid
        pid_t msg_lrpid;// pid of last msgrcv() 最后一次接受消息的进程的pid
        time_t msg_stime;// last msgsnd time 最后发送消息的时间
        time_t msg_ctime;// last change time 最后一次改变的时间
......
};
打开或创建消息队列

int msgget(key_t key,int flag);

  • 返回:成功返回内核中消息队列的表示id,出错返回-1
  • 头文件
#include <sys/msg.h>
  • 参数

    • key:用户指定的消息队列的键值
    • flag:IPC_CREAT,IPC_EXCL等权限组合
  • 若创建消息队列,key可指定键值,也可将之设置为IPC_PRIVATE。若打开进行查询,则key不能为0必须是一个非0的值否则是查询不到的
消息队列控制

int msgctl(int msgid,int cmd,struct msqid_ds *buf)

  • 返回:成功返回0,出错返回-1
  • 头文件
#include <sys/msg.h>
  • 参数

    • msgid:消息队列的id
    • buf:消息队列属性指针
    • cmd:

      • IPC_STAT:获取消息队列属性,取此队列的msqid_ds结构,并将其存放在buf指向的结构体中
      • IPC_SET:设置属性,按由buf指向的结构体中的值,设置此队列相关的结构中的字段
      • IPC_RMID:删除队列,从系统中删除该消息队列以及仍在该队列上的所有数据
发送消息

int msgsnd(int msgqid,const void* ptr,size_t nbytes,int flag);

  • 返回:成功返回0,出错返回-1
  • ptr 结构
struct mymesg{
        long mytype; // positive message type
        char mtext[512]; // message data of length nbytes
...
};
  • nbytes:指定消息的大小,不包括mtype的大小
  • mtype是指消息的类型,他由一个整数来代表,并且他只可能是大于0的整数
  • mtext是消息数据本身
  • 在linux中消息的最大长度是4056个字节,其中包括mtype,他占四个字节
  • 结构体mymesg用户可自定义,但第一个成员必须是mtype
  • 参数flag

    • 0:阻塞
    • IPC_NOWAIT:类似于文件I/O的非阻塞I/O标志
    • 若消息队列已满(或是队列中消息总数等于系统限制值,或队列中的字节总数等于系统限制值),则指定IPC_NOWAIT使得msgsnd立即出错返回EAGAIN。如果指定0,则进程

      • 阻塞直到有空间可以容纳要发送的消息
      • 或从系统中删除了此队列
      • 或捕捉到了一个信号,并从信号处理程序返回
接受消息

size_t msgrcv(int msgqid,void* ptr,size_t nbytes,long type,int flag);

  • 返回:成功返回消息的数据部分长度,出错返回-1
  • 头文件
#include <sys/msg.h>
  • 参数

    • msgqid:消息队列id
    • ptr:指向存放消息的缓存
    • nbytes:消息缓存的大小,不包括mtype的大小。计算方式

      • nbytes = sizeof(struct mymesg) - sizeof(long)
    • type:消息类型

      • type == 0:获取队列消息中的第一个消息
      • type > 0:获取消息队列中类型为type的第一个消息
      • type < 0:获取消息队列中类型小于或等于type绝对值的消息(有多个就取类型最小的一个)
    • flag:0或IPC_NOWAIT

消息示例

#include <sys/msg.h>
#include <stdio.h>
#include <string.h>
void send_message(int);
void receive_message(int);
/* 消息结构体,注意第一个元素必须是type */
typedef struct{
        long type; // 必须大于1,否则发送消息失败
        int id;
        char name[8];
}my_message;
int main(int argc,char* argv[])
{
        if(argc < 3)
        {
                printf("incorrect parameter\n");
                return 1;
        }
        // 可以用ftok生成key,注意argv[2]必须是一个实际存在的路径,不然函数返回-1
        // key_t k = ftok(argv[2],0);
        // 直接使用数字 
        key_t k = atoi(argv[2]);
        // 打开/创建消息队列
        int msgqid = 0;
        if((msgqid = msgget(k,IPC_CREAT | 0777)) == -1)
        {
                perror("msgget error");
                return 1;
        }
        if(strcmp("send",argv[1]) == 0)
        {
                send_message(msgqid);
        }
        else if(strcmp("receive",argv[1]) == 0)
        {
                receive_message(msgqid);
        }
        else
        {
                printf("incorrect parameter\n");
                return 1;
        }
        // 删除队列,程序结束后消息队列还是会存在,不用一定要接的删除
        if(msgctl(msgqid,IPC_RMID,NULL) == -1)
        {
                perror("remove message queue error");
                return 1;
        }
        return 0;
}
/* 发送消息方法 */
void send_message(int msgqid)
{
        my_message m = {0,0,{'\0'}};
        int type = 1;
        // 消息的大小,注意要减去type的大小
        size_t bytes = sizeof(my_message) - sizeof(long);
        struct msqid_ds ds;
        int c;
        while(1)
        {
                printf("input id name\n");
                scanf("%d %7s",&m.id,m.name);
                m.type = type;
                if(msgsnd(msgqid,(void*)&m,bytes,0) == -1)
                {
                        perror("msgsnd error");
                        break;
                }
                type++;
                if(-1 == msgctl(msgqid,IPC_STAT,&ds))
                {
                        perror("msgctl error");
                }
                else
                {
                        printf("msgqnum = %u\n",(unsigned int)ds.msg_qnum);
                }
                // 重置name字符数组
                memset(m.name,'\0',8);
                // 清空标准输入的缓冲区的内容
                while ((c=getchar()) != '\n' && c!=EOF);
        }
}
/* 接受消息方法 */
void receive_message(int msgqid)
{
        my_message m;
        // 消息的大小,注意要减去type的大小
        size_t bytes = sizeof(my_message) - sizeof(long);
        struct msqid_ds ds;
        while(1)
        {
                if(msgrcv(msgqid,(void*)&m,bytes,0,0) == -1)
                {
                        perror("msgrcv error");
                        break;
                }
                else
                {
                        printf("type = %d;id = %d;name = %s\n",(int)m.type,m.id,m.name);
                }
                if(-1 == msgctl(msgqid,IPC_STAT,&ds))
                {
                        perror("msgctl error");
                }
                else
                {
                        printf("msgqnum = %u\n",(unsigned int)ds.msg_qnum);
                }
        }
}

共享内存

  • 共享内存区域是被多个进程共享的一部分物理内存
  • 多个进程都可把该共享内存映射到自己的虚拟内存空间。所有用户空间的进程若要操作共享内存,都要将其映射到自己的虚拟内存空间中,通过映射的虚拟内存空间地址去操作共享内存,从而达到进程间的数据通信
  • 共享内存是进程间共享数据的一种最快的方法,一个进程向内存区域写入数据,共享这个区域的所有内存就可以立刻看到其中的内容
  • 本身不提供同步机制,可通过信号量进行同步
  • 提高数据处理效率,一种效率最高的IPC机制
共享内存属性
struct shmid_ds{
        struct ipc_perm shm_perm;
        size_t shm_segsz;// size of segment in bytes 共享内存区大小
        pid_t shm_lpid;// pid of last shmop 最后一次操作共享内存的进程id
        pid_t shm_cpid;// pid of creator 创建共享内存的进程的id
        shmatt_t shm_nattch;// number of current attaches 和当前共享内存成功映射的内存数量
        time_t shm_atime;// last attach time 最后成功映射的时间
        time_t shm_dtime;// last detach time 最后解除映射的时间
        time_t shm_ctime;// last change time 最后一次改变的时间
......
};
共享内存使用步骤
  • 使用shmget函数创建共享内存
  • 使用shmat函数映射共享内存,将这段创建的共享内存映射到具体的进程虚拟空间中
创建共享内存

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

  • 返回:成功返回内核中共享内存的标识id,失败返回-1
  • 头文件
#include <sys/shm.h>
  • 参数

    • key:用户指定的共享内存键值
    • size:共享内存大小
    • shmflg:IPC_CREAT,IPC_EXCL等权限组合
  • errno

    • EINVAL(无效的内存段大小)
    • EEXIST(内存段已经存在,无法创建)
    • EIDRM(内存段已经被删除)
    • ENOENT(内存段不存在)
    • EACCES(权限不够)
    • ENOMEM(没有足够的内存来创建内存段)
共享内存控制

int shmctl(int shmid,int cmd,struct shmid_ds* buf);

  • 返回:成功返回0,出错返回-1
  • 头文件
#include <sys/shm.h>
  • 参数

    • shmid:共享内存id
    • buf:共享内存属性指针
    • cmd

      • IPC_STAT 获取共享内存段属性
      • IPC_SET 设置共享内存段属性
      • IPC_RMID 删除共享内存段
      • SHM_LOCK 锁定共享内存段页面(页面映射到的物理内存不和外存(swap)进行换入换出操作)
      • SHM_UNLOCK 解除共享内存段页面的锁定
共享内存映射和接触映射

void* shmat(int shmid,char* shmaddr,int shmflg);

  • 返回:成功返回共享内存映射到虚拟内存的空间的地址,失败返回-1
    int shmdt(char* shmaddr);
  • 返回:失败返回-1
  • 参数

    • shmid:共享内存id
    • shmaddr:映射到进程虚拟内存空间的地址,建议设置0,有操作系统分配
    • shmflg:若shmaddr设置成0,则shmflg也设置成0

      • SHM_RND
      • SHMLBA 地址为2的乘方
      • SHM_RDONLY 只读方式链接
  • errno

    • EINVAL 无效的IPC ID值或无效的地址
    • ENOMEM 没有足够的内存
    • EACCES 存取权限不够
      子进程不继承父进程创建的共享内存,大家的是共享的。子进程继承父进程映射的地址
示例
#include <stdio.h>
#include <sys/shm.h>
#include <unistd.h>
// 存放pipe,用来使进程互斥
int fp[2];
int init_pipe(void);
void close_pipe(void);
void sleep_pipe(void);
void wake_pipe(void);
int main(void)
{
        // 创建虚拟内存块
        key_t k = 888;
        int shmid;
        if((shmid = shmget(k,sizeof(int),IPC_CREAT | 0777)) == -1)
        {
                perror("shmget error");
                return 1;
        }
        // 映射共享内存,可直接在fork映射也可以在fork后映射
        /*
        int* share_p = shmat(shmid,NULL,0);
        if((int)share_p == -1)
        {
                perror("shmat error");
                return 1;
        }
        */
        // 初始化pipe
        init_pipe();
        int pid = fork();
        if(pid == -1)
        {
                perror("fork error");
                return 1;
        }
        if(pid > 0)
        {
                // 映射共享内存
                int* share_p = shmat(shmid,NULL,0);
                if((int)share_p == -1)
                {
                        perror("shmat error");
                        return 1;
                }
                *share_p = 8;
                wake_pipe();
                wait(NULL);
                // 接触共享内存映射
                shmdt(share_p);
                // 删除共享内存
                shmctl(shmid,IPC_RMID,NULL);
        }
        else if(pid == 0)
        {
                // 映射共享内存
                int* share_p = shmat(shmid,NULL,0);
                if((int)share_p == -1)
                {
                        perror("shmat error");
                        return 1;
                }
                sleep_pipe();
                printf("*share_p = %d\n",*share_p);
                // 接触共享内存映射
                shmdt(share_p);
        }
        // 关闭pipe
        close_pipe();
        return 0;
}
int init_pipe(void)
{
        return pipe(fp);
}
void close_pipe(void)
{
        close(fp[0]);
        close(fp[1]);
}
void sleep_pipe(void)
{
        char c;
        read(fp[0],(void*)&c,sizeof(c));
}
void wake_pipe(void)
{
        char c = 'D';
        write(fp[1],(void*)&c,sizeof(c));
}

信号量

  • 本质上就是共享资源的数目,用来控制对共享资源的访问
  • 用于进程间的互斥和同步
  • 每种共享资源对应一个信号量,为了便于大量共享资源的操作引入了信号集,可对所有信号量一次性操作。对信号量集中多有操作可以要求全部成功也可以部分成功
  • 二元信号量(信号灯)值为0和1
  • 对信号量作PV操作
信号量集属性
#include <sys/sem.h>
struct semid_ds{
        struct ipc_perm sem_perm;
        unsigned short sem_nsems;// of semaphores in set 信号量集中灯的数量
        time_t sem_otime; // last semop time 最后一次对信号量操作的时间
        time_t sem_ctime;// last change time 最后一次改变时间
};
创建信号量集

int semget(key_t key,int nsems,int flag);

  • 返回:成功返回信号量集id,出错返回-1
  • 参数

    • key:用户指定的信号量集键值
    • nsems:信号量集中信号量个数
    • flag:IPC_CREAT,IPC_EXCL等权限组合
  • 头文件
#include <sys/sem.h>
信号量集控制

int semctl(int semid,int semnum,int cmd,.../* union semun arg */);

  • union semun结构
// 需要自己定义
union semun{
        int val;
        struct semid_ds* buf;
        unsigned short* array;
};
  • 参数

    • semid:信号量集id
    • semnum:0表示对所有信号量操作,信号量编号从0开始
    • val:放置获取或设置信号量集中某个信号量的值
    • buf:信号量集属性指针
    • array:放置获取或设置信号量集中所有信号量的值
    • 通过cmd参数设定对信号量集要执行的操作

      • IPC_STAT 获取信号量集的熟悉 ==> buf
      • IPC_SET 设置信号量集的熟悉 ==> buf
      • IPC_RMID 删除信号量集 ==> buf
      • GETVAL 返回信号量的值 ==> val
      • SETVAL 设置semnum信号量的值 ==> val
      • GETALL 获取所有信号量的值 ==> array
      • SETALL 设置所有信号量的初始值 ==> array
  • 头文件
#include <sys/sem.h>
信号量集操作

int semop(int semid,struct sembuf* sops,size_t nsops);

  • 返回:成功返回0,出错返回-1
  • struct sembuf 结构体
struct sembuf{
        unsigned short sem_num;// member in set 对哪一个信号量进行操作
        short sem_op;// operation(negative,0,positive) 做P操作还V操作
        short sem_flg;// IPC_NOWAIT,SEM_UNDO
};
  • 参数

    • semid:信号量集id
    • sops:sembuf结构体数组指针
    • nsops:第二个参数中结构体数组的长度
    • sem_num:信号量集中信号量的编号
    • sep_op:正数为V操作,复数为P操作,0可用于对共享资源是否已完成的测试
    • sem_flg:SEM_UNDO标志,表示在进程结束时,相应的操作将被取消,如果设置了该标志,那么在进程没有释放共享资源就退出时,内核将代为释放
  • 用于信号量集中信号量的加和减操作(PV操作)
  • 可用于进程间的互斥和同步
银行取款,PV操作
#include <stdio.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <sys/types.h>
#include <unistd.h>
typedef struct
{
        int deposit;
        int semid;
}Account;
typedef union
{
        int val;
        struct semid_ds* buf;
        unsigned short* array;
}my_semun;
int I(void);
void P(int semid);
void V(int semid);
void D(int semid);
void withdraw(Account* account,int amount);
int main(void)
{
        key_t k = 888;
        int shmid = shmget(k,sizeof(Account),IPC_CREAT | 0777);
        if(shmid == -1)
        {
                perror("shmget error");
                return 1;
        }
        // 映射
        Account* account = shmat(shmid,0,0);
        account->deposit = 888888;
        account->semid = I();
        V(account->semid);
        int pid = fork();
        if(pid == -1)
        {
                perror("fork error");
                // 解除映射
                shmdt(account);
                // 删除共享内存
                shmctl(shmid,IPC_RMID,NULL);
                // 删除信号量集
                D(account->semid);
                return 1;
        }
        else if(pid > 0)
        {
                withdraw(account,888888);
                wait(NULL);
                // 删除信号量集
                D(account->semid);
                // 解除映射
                shmdt(account);
                // 删除共享内存
                shmctl(shmid,IPC_RMID,NULL);
        }
        else if(pid == 0)
        {
                withdraw(account,888888);
                // 解除映射
                shmdt(account);
        }
        return 0;
}
void withdraw(Account* account,int amount)
{
        // 进行P操作,其他进程会阻塞
        P(account->semid);
        if(amount <= account->deposit)
        {
                account->deposit -= amount;
        }
        printf("process %d withdraw\n",(int)getpid());
        sleep(3);
        // 使其他进程继续运行
        V(account->semid);
}
int I(void)
{
        // 创建信号量集
        int semid = semget(IPC_PRIVATE,1,IPC_CREAT | 0777);
        if(semid != -1)
        {

                my_semun val;
                val.val = 0;
                // 初始化信号量集
                semctl(semid,0,SETALL,&val);
        }
        return semid;
}
void P(int semid)
{
        // 使用sembuf结构体进行P操作
        struct sembuf buf[1] = {{0,-1,SEM_UNDO}};
        semop(semid,buf,1);
}
void V(int semid)
{
        // 使用sembuf结构体进行V操作
        struct sembuf buf[1] = {{0,1,SEM_UNDO}};
        semop(semid,buf,1);
}
void D(int semid)
{
        // 删除信号量集
        semctl(semid,0,IPC_RMID,NULL);
}
读者和写者问题
#include <stdio.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <sys/types.h>
#include <unistd.h>
typedef struct
{
        int c_semid,g_semid;
        int* data;
}Calculate;
typedef union
{
        int val;
        struct semid_ds* buf;
        unsigned short* array;
}my_semun;
int I(void);
void get_v(Calculate*);
void calculate_v(Calculate*);
void P(int semid);
void V(int semid);
void D(int semid);
int main(void)
{
        key_t k = 888;
        int shmid = shmget(k,sizeof(int),IPC_CREAT | 0777);
        if(shmid == -1)
        {
                perror("shmget error");
                return 1;
        }
        // 映射
        Calculate c;
        c.data = shmat(shmid,0,0);
        c.c_semid = I();
        c.g_semid = I();
        int pid = fork();
        if(pid == -1)
        {
                perror("fork error");
                // 解除映射
                shmdt(c.data);
                // 删除共享内存
                shmctl(shmid,IPC_RMID,NULL);
                // 删除信号量集
                D(c.c_semid);
                D(c.g_semid);
                return 1;
        }
        else if(pid > 0)
        {
                get_v(&c);
                wait(NULL);
                // 删除信号量集
                D(c.c_semid);
                D(c.g_semid);
                // 解除映射
                shmdt(c.data);
                // 删除共享内存
                shmctl(shmid,IPC_RMID,NULL);
        }
        else if(pid == 0)
        {
                calculate_v(&c);
                // 解除映射
                shmdt(c.data);
        }
        return 0;
}
void get_v(Calculate* c)
{
        for(int i = 0;i < 100;i++)
        {
                printf("get; i = %d\n",*c->data);
                *c->data = i;
                V(c->c_semid);
                P(c->g_semid);
                printf("print; i = %d\n--------\n\n",*c->data);
        }
}
void calculate_v(Calculate* c)
{
        for(int i = 0;i < 100;i++)
        {
                P(c->c_semid);
                *c->data += 8;
                printf("calculate; i = %d\n",*c->data);
                V(c->g_semid);
        }
}
int I(void)
{
        // 创建信号量集
        int semid = semget(IPC_PRIVATE,1,IPC_CREAT | 0777);
        if(semid != -1)
        {

                my_semun val;
                val.val = 0;
                // 初始化信号量集
                semctl(semid,0,SETALL,&val);
        }
        return semid;
}
void P(int semid)
{
        // 使用sembuf结构体进行P操作
        struct sembuf buf[1] = {{0,-1,SEM_UNDO}};
        semop(semid,buf,1);
}
void V(int semid)
{
        // 使用sembuf结构体进行V操作
        struct sembuf buf[1] = {{0,1,SEM_UNDO}};
        semop(semid,buf,1);
}
void D(int semid)
{
        // 删除信号量集
        semctl(semid,0,IPC_RMID,NULL);
}

linux编程学习 03 线程

线程

  • 进程是资源管理的最小单位,线程是程序执行的最小单位
  • 每个进程都有自己的数据段,代码段和堆栈段。线程通常叫做轻型的进程,他包含独立的栈和cpu寄存器状态,线程是进程的一条执行路径,每个线程共享其所属进程的所有资源,包括打开的文件,内存页面,信号标识及动态分配的内存
  • 因为线程和进程比起来很小,所以相对来说,线程花费更少的cpu资源
  • 在操作系统设计上,从进程演化出线程,最主要的目的就是更好的支持多处理器,并且减少进程上下文切换的开销。

进程与线程的关系

  • 线程和进程的关系是:线程是属于进程的,线程运行在进程空间内,同已进程所产生的线程共享同一用户内存空间,当进程退出时该进程所产生的线程都会被强制退出并清除。一个进程至少需要一个线程作为他的指令执行体。进程管理着资源(比如cpu,内存,文件等)。而将线程分配到某个cpu上执行。
  • 进程默认会有一个线程,称为主控线程
  • 进程进入running状态时再对进程下的线程分配运行时间,同一时间只有一个线程在运行

线程分类

  • 线程按照其调度者可分为用户级线程和内核级线程两种

    • 用户级线程:主要解决上下文切换问题,其调度过程由用户决定
    • 内核级线程:有内核调度机制实现
  • 现在大多数操作系统都采用用户级线程和内核级线程并存的方法
  • 用户线程要绑定内核级线程运行,一个进程中的内核级线程会分配到固定的时间片,用户级线程分配的时间片以内核线程为准
  • 默认情况下用户级线程和内核级线程是一对一,也可以多对一,但是这样实时性会较差。
  • 当cpu分配给线程的时间片用完后但线程没有执行完毕,此时线程会从运行状态切换到就绪状态,将cpu让给其他进程使用

linux线程实现

  • 以下线程均为用户级线程,在linux中,一般采用pthread线程库实现线程的访问与控制,由POSIX提出,具有良好的移植性
  • linux线程程序编译需要在gcc上链接库pthread

线程标识

  • 每个进程内部的不同线程都有自己的唯一标识
  • 线程标识只在它所属的进程环境中有效
  • 显示标识是pthread_t数据类型
    int pthread_equal(pthread_t,pthread_t)
  • 返回:相等返回0,否则返回非0
    pthread_t pthread_self(void);
  • 返回:调用线程的线程id
  • 头文件
    #include <pthread.h>

线程创建

int pthread_create(pthread_t *retrict tidp,const pthread_attr_t *restrict attr,void *(*start_rtn)(void*),void* restrict arg);

  • 返回:成功返回0,失败返回错误编号
  • 头文件
    #include <pthread.h>
  • 参数

    • tidp:线程标识符指针
    • attr:线程属性指针
    • start_rtn:线程运行函数的起始地址
    • arg:传递给线程运行函数的参数
  • 新线程从start_rtn函数的地址开始执行
  • 不能保证新线程和调用线程的执行顺序
  • 示例
typedef struct
{
        int start;
        int end;
}for_length;
int main(void)
{
        pthread_t thread1_id,thread2_id;
        int res = 0;
        // 传递单个参数
        if((res = pthread_create(&thread1_id,NULL,thread_func,(void*)8)) != 0)
        {   
                perror("create thread1 error");
                return 1;
        }   
        if((res = pthread_create(&thread2_id,NULL,thread_func,(void*)6)) != 0)
        {   
                perror("create thread2 error");
                return 1;
        }
        // 这里要把进程阻塞,不然进程结束,线程也会结束
        // sleep(30);
        // 主控线程调用pthread_join,自己会阻塞,直到thread1和thread2结束才会运行
        pthread_join(thread1_id,NULL);
        pthread_join(thread2_id,NULL);
        // 传递多个参数时,可以使用结构体
        for_length f1 = {1,10},f2 = {1,8};
        if((res = pthread_create(&thread1_id,NULL,thread_func2,(void*)(&f1))) != 0)
        {
                perror("create thread1 error");
                return 1;
        }
        if((res = pthread_create(&thread2_id,NULL,thread_func2,(void*)(&f2))) != 0)
        {
                perror("create thread2 error");
                return 1;
        }
        pthread_join(thread1_id,NULL);
        pthread_join(thread2_id,NULL);
        return 0;
}
/**
 * 接收单个参数
 * */
void* thread_func(void* par)
{
        // 注意因为传递时,是直接把常量的值转换成地址,一般情况下 par = 0x7fffa76962f0 指针变量>是存放的地址,但是这里的情况是 par = 0x000000000006,所以直接转换就可以了
        int times = (int)par;
        for(int i = 0;i < times;i++)
        {
                sleep(1);
                printf("I am thread %li;i = %d\n",pthread_self(),i);
        }
        return (void*)NULL;
}
/**
 * 接收多个参数
 * */
void* thread_func2(void* par)
{
        // 转换成结构体指针
        for_length* times = (for_length*)par;
        for(int i = times->start;i < times->end;i++)
        {
                sleep(1);
                printf("I am thread %li;i = %d\n",pthread_self(),i);
        }
        return (void*)NULL;
}

终止方式

  • 主动终止

    • 线程的执行函数中调用return语句
    • 调用pthread_exit
  • 被动终止

    • 线程可以被同一进程的其他进程取消,其他线程调用pthread_cancel(pthid)

int pthread_cancel(pthread_t tid);
void pthread_exit(void *retval);
int pthread_join(pthread_t th,void** thread_return);

  • 返回值:成功返回0,否则返回错误编号
  • 头文件:
#include <pthread.h>
  • pthread_cancel

    • 线程可以被同一进程的其他线程取消,tid为终止的线程标识符
  • pthread_exit

    • retval:pthread_exit调用者线程的返回值,可由其他函数和pthread_join来检测获取
    • 线程退出时使用函数pthread_exit,是线程的主动行为
    • 由于一个线程中的多个线程共享数据段,因此通常在线程退出后,退出线程所占用的资源并不会随线程结束而释放。所以需要pthread_join函数来等待线程结束,类似于wait系统调用
  • pthread_join

    • th:被等待线程的标识符
    • thread_return:用户定义指针,用来存储被等待进程的返回值
  • 示例
typedef struct
{
        int id;
        char name[10];
}user;
void* thread_func(void* data);
int main(void)
{
        pthread_t thread_id;
        int res = 0;
        user u = {1,"jin"};
        if((res = pthread_create(&thread_id,NULL,thread_func,(void*)&u)) != 0)
        {
                perror("create thread error");
        }
        // 指针变量接收要回传的数据
        void* join_res;
        // 要传递的是指针变量的地址
        pthread_join(thread_id,&join_res);
        printf("id = %d;name = %s\n",((user*)join_res)->id,((user*)join_res)->name);
        return 0;
}
void* thread_func(void* data)
{
        // 先转换指针
        user* u = (user*)data;
        printf("id = %d;name = %s\n",u->id,u->name);
        u->id = 6;
        return (void*)u;
}

线程清理和控制函数

void pthread_cleanup_push(void (*rtn)(void*),void* arg);
void pthread_cleanup_pop(int execute);

  • 返回:成功返回0,否则返回错误编号
  • 头文件
#include <pthread.h>
  • 参数

    • rtn:清理函数指针
    • arg:调用清理函数传递的参数
    • execute:值1时执行线程清理函数,值0时不执行线程清理函数
  • 触发线程调用清理函数动作

    • 调用pthread_exit
    • 响应取消请求
    • 用非零execute参数调用thread_cleanup_pop时
  • 示例
int main(void)
{
        pthread_cleanup_push(cleanup_func,(void*)6);
        // 传入非0才会执行
        pthread_cleanup_pop(-1);
        return 0;
}
void cleanup_func(void* v)
{
        printf("I am cleanup_func;i = %d;\n",(int)v);
}

进程,线程启动和终止方式的比较

进程线程
fork()pthread_create()
return/exit()/_exit()return/pthread_exit()
wait()pthread_join()
atexit()pthread_cleanup_push()/pthread_cleanup_pop()

线程属性初始化和销毁

int pthread_attr_init(pthread_attr_t* attr);
int pthread_attr_destroy(pthread_attr_t* attr);

  • 返回:成功返回0,否则返回错误编号
  • 头文件
#include <pthread.h>
  • 线程属性结构体
typedef struct
{
      int etachstate; // 线程的分离状态
      int schedpolicy; // 线程调度策略
      structsched_param schedparam; // 线程的调度参数
      int inheritsched; // 线程的继承性
      int scope; // 线程的作用域
      size_t guardsize; // 线程栈末尾的警戒缓冲区大小
      int stackaddr_set; // 线程的栈设置
      void* stackaddr; // 线程栈的位置
      size_t stacksize; // 线程栈的大小
}pthread_attr_t;

设置和获得分离属性

int pthread_attr_getdetachstat(const pthread_attr_t*restrict attr,int* detachstate);
int pthread_attr_setdetachstat(const pthread_attr_t* attr,int detachstate);

  • 返回:成功返回0,出错返回错误编号
  • detachstate取值

    • PTHREAD_CREATE_JOINABLE(默认值) 正常启动线程
    • PTHREAD_CREATE_DETACHED 以分离状态启动线程
  • 以默认方式启动的线程,在线程结束后不会自动释放占有的系统资源,要在主控线程中调用pthread_join后才会释放
  • 以分离状态启动的线程,在线程结束后会自动释放所占有的系统资源
  • 分离属性在网络通讯中使用的较多
  • 示例
int main(void)
{
        pthread_attr_t attr;
        pthread_attr_init(&attr);
        pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);
        pthread_t thread_id;
        int res = 0;
        if((res = pthread_create(&thread_id,&attr,pthread_func,(void*)6)) != 0)
        {
                perror("create thread error");
                return 1;
        }
        // 使用分离状态启动进程时,pthread_join无效,看不到输出结果,需要sleep才能看到输出结果
        pthread_join(thread_id,NULL);
        sleep(1);
        return 0;
}
void* pthread_func(void* data)
{
        printf("child thread;data = %d\n",(int)data);
        return (void*)NULL;
}

线程的同步和互斥

  • 线程同步

    • 是一个宏观的概念,在微观上线程的相互排斥和线程的先后执行的约束问题
    • 解决同步方式

      • 条件变量
      • 进程信号量
  • 线程互斥

    • 线程执行的相互排斥
    • 解决互斥方式

      • 互斥锁
      • 读写锁
      • 线程信号量

线程互斥-互斥锁

  • 互斥锁(mutex)是一种简单的加锁的方法来控制对共享资源的访问。在同一时刻只能有一个线程掌握某个互斥锁,拥有上锁状态的进程能够对共享资源进行访问。若其他线程希望上锁一个已经被上了互斥锁的资源。则该线程挂起,直到上锁的线程释放互斥锁为止
  • 互斥锁数据类型

    • pthread_mutex_t

互斥锁创建与销毁

int pthread_mutex_init(pthread_mutex_t*restrict mutex,const pthread_mutexattr_t* mutexattr);
int pthread_mutex_destroy(pthread_mutex_t* mutex);

  • 返回:成功返回0,否则返回错误编号
  • 头文件
#include <pthread.h>
  • 参数

    • mutex:互斥锁
    • mutexattr:互斥锁创建方式

      • PTHREAD_MUTEX_INITIALIZER

        • 快速创建互斥锁
      • PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP

        • 创建递归互斥锁
      • PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP

        • 创建检错互斥锁

互斥锁上锁和解锁

int pthread_mutex_lock(pthread_mutex_t* mutex);

  • 功能:上锁,拿不到锁阻塞
    int pthread_mutex_trylock(pthread_mutex_t* mutex);
  • 功能:上锁,拿不到锁阻塞
    int pthread_mutex_unlock(pthread_mutex_t* mutex);
  • 功能:释放锁
  • 返回:成功返回0,出错返回出错码
  • 参数

    • mutex:互斥锁
  • 示例
typedef struct
{
        int deposit;
        pthread_mutex_t lock;// 把锁与变量联系在一起
}Account;
typedef struct
{
        char name[8];
        int amount;
        Account* account;
}User;
void* withdraw(void*);
void* withdraw(void*);
int main(void)
{
        Account account = {88888};
        pthread_mutex_init(&account.lock,NULL);
        User user1 = {"jin1",88888,&account};
        User user2 = {"jin2",88888,&account};
        pthread_t thread1_id,thread2_id;
        int res = 0;
        if((res = pthread_create(&thread1_id,NULL,withdraw,(void*)&user1)) != 0)
        {
                perror("create thread error");
        }
        if((res = pthread_create(&thread2_id,NULL,withdraw,(void*)&user2)) != 0)
        {
                perror("create thread error");
        }
        pthread_join(thread1_id,NULL);
        pthread_join(thread2_id,NULL);
        printf("account's deposit %d\n",account.deposit);
        return 0;
}
void* withdraw(void* user)
{
        User* u = (User*)user;
        // 加锁,其他线程到这里加锁时会阻塞住,等解锁后才会继续运行
        pthread_mutex_lock(&u->account->lock);
        sleep(1);
        if(u->amount > u->account->deposit)
        {
                printf("sorry %s;your balance is not enough\n",u->name);
                return (void*)NULL;
        }
        printf("%s => %d\n",u->name,u->amount);
        u->account->deposit -= u->amount;
        // 解锁,解锁后其他线程才会继续运行
        pthread_mutex_unlock(&u->account->lock);
        return (void*)NULL;
}

互斥锁进程共属性操作

int pthread_mutexattr_getpshared(const pthread_mutextattr_t*restrict attr,int*restrict pshared);
int pthread_mutexattr_setpshared(pthread_mutexattr_t* attr,int pshared);

  • 返回:成功返回0,出错返回错误编号
  • 参数

    • attr:互斥锁熟悉
    • pshared

      • PTHREAD_PROCESS_PRIVATE(默认情况)

        • 锁只能用于一个进程内部的两个线程进行互斥
      • PTHREAD_PROCESS_SHARED

        • 锁能用于两个不同进程中的线程进行互斥

互斥锁类型操作

int pthread_mutexattr_gettype(const pthread_mutexattr_t*restrict attr,int*restrict type);
int pthread_mutexattr_settype(const pthread_mutexattr_t*restrict attr,int type);

  • 返回:成功返回0,出错返回错误编号
  • 参数

    • attr:互斥锁属性
    • type:互斥锁类型

      • 标准互斥锁:PTHREAD_MUTEX_NORMAL

        • 第一次上锁成功,第二次上锁会阻塞
      • 递归互斥锁:PTHREAD_MUTEX_RECURSIVE

        • 第一次上锁成功,第二次以后上锁还是成功,内部计数
      • 检查互斥锁:PTHREAD_MUTEX_ERRORCHECK

        • 第一次上锁成功,第二次上锁会出错
      • 默认互斥锁:PTHREAD_MUTEX_DEFAULT(同标准互斥锁)
  • 示例
int main(int argc,char* argv[])
{
        if(argc < 2)
        {
                printf("incorrect parameter\n");
                return 1;
        }
        // 初始化属性变量
        pthread_mutexattr_t attr;
        // 设置属性
        if(strcmp(argv[1],"normal") == 0)
        {
                pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_NORMAL);
        }
        else if(strcmp(argv[1],"recursive") == 0)
        {
                pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_RECURSIVE);
        }
        else if(strcmp(argv[1],"errorcheck") == 0)
        {
                pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_ERRORCHECK);
        }
        else
        {
                pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_DEFAULT);
        }
        pthread_mutex_t lock;
        // 使用设置的属性初始化锁
        pthread_mutex_init(&lock,&attr);
        if(pthread_mutex_lock(&lock) != 0)
        {
                printf("first lock error\n");
        }
        else
        {
                printf("first lock\n");
        }
        if(pthread_mutex_lock(&lock) != 0)
        {
                printf("secound lock error\n");
        }
        else
        {
                printf("second lock\n");
        }
        // 销毁锁
        pthread_mutex_destroy(&lock);
        pthread_mutexattr_destroy(&attr);
        return 0;
}

线程互斥-读写锁

  • 线程使用互斥锁缺乏都并发性
  • 当读操作较多,写操作较少时,可使用读写锁提高线程读并发性
  • 读写数据锁类型

    • pthread_rwlock_t

读写锁创建和销毁

int pthread_rwlock_init(pthread_rwlock_t*restrict rwlock,const pthread_rwlockattr_t*restrict attr);
int pthread_rwlock_destroy(pthread_rwlock_t* rwlock);

  • 头文件
#include <pthread.h>
  • 参数

    • rwlock:读写锁
    • attr:读写锁属性

读写锁加锁和解锁

int pthread_rwlock_rdlock(pthread_rwlock_t* rwlock);

  • 功能:加读锁
    int pthread_rwlock_wrlock(pthread_rwlock_t* rwlock);
  • 功能:加写锁
    int pthread_rwlock_unlock(pthread_rwlock_t* rwlock);
  • 功能:释放锁
  • 返回:成功返回0,出错返回错误编号
  • 参数

    • rwlock:读写锁
  • 读写锁特性

    • 读和读:不互斥,两个都会成功
    • 读和写:互斥,第二个会阻塞
    • 写和写:不排斥,第二会失败
    • 写和读:不互斥,第二个会失败
  • 示例
int main(int argc,char *argv[])
{
        if(argc < 3)
        {
                printf("incorrect parameter\n");
                return 1;
        }
        pthread_rwlock_t rwlock;
        pthread_rwlock_init(&rwlock,NULL);
        if(strcmp(argv[1],"r") == 0)
        {
                if(pthread_rwlock_rdlock(&rwlock) != 0)
                {
                        printf("first read lock fail\n");
                }
                else
                {
                        printf("first read lock success\n");
                }
        }
        else
        {
                if(pthread_rwlock_wrlock(&rwlock) != 0)
                {
                        printf("first write lock fail\n");
                }
                else
                {
                        printf("first write lock success\n");
                }
        }
        if(strcmp(argv[2],"r") == 0)
        {
                if(pthread_rwlock_rdlock(&rwlock) != 0)
                {
                        printf("second read lock fail\n");
                }
                else
                {
                        printf("second read lock success\n");
                }
        }
        else
        {
                if(pthread_rwlock_wrlock(&rwlock) != 0)
                {
                        printf("second write lock fail\n");
                }
                else
                {
                        printf("second write lock success\n");
                }
        }
        // 注意上面锁了两次,所以这里要解锁两次
        pthread_rwlock_unlock(&rwlock);
        pthread_rwlock_unlock(&rwlock);
        pthread_rwlock_destroy(&rwlock);
        return 0;
}

线程同步-条件变量

  • 互斥锁的缺点是它只有两种状态:锁定和非锁定
  • 条件变量通过允许线程阻塞和等待另一个线程发送信号的方法弥补了互斥锁的不足
  • 条件变量内部是一个等待队列,放置等待的线程,线程在条件变量上等待和通知,互斥锁来保护等待队列(对等待队列上锁),条件变量通常和互斥锁一起使用。
  • 条件变量运行线程等待特定条件发生,当条件不满足时,线程通常先进入阻塞状态,等待条件发生变化。一旦它的某个线程改变了条件,可唤醒一个或多个阻塞的线程
  • 具体判断条件还需用户给出
  • 条件变量数据类型

    • pthread_cond_t

条件变量的创建和销毁

int pthread_cond_wait(pthread_cond_t*restrict cond,pthread_mutex_t*restrict mutex);
int pthread_cond_timewait(pthread_cond_t*restrict cond,pthread_mutex_t*restrict mutex,const struct timespec*restrict timeout);

  • 返回:成功返回0,出错返回错误变化
  • 头文件
#include <pthread.h>
  • timespec结构体
struct timespec
{
        time_t tv_sec; // seconds
        long tv_nsec;  // nanoseconds
}
  • 参数

    • cond:条件变量
    • mutex:互斥锁
  • 互斥锁mutex是对条件变量cond的保护
  • 线程由于调用wait函数阻塞,否则释放互斥锁

条件变量通知操作

int pthread_cond_signal(pthread_cond_t* cond);
int pthread_cond_broadcast(pthread_cond_t* cond);

  • 返回:成功返回0,出错返回错误编号
  • 参数

    • cond:条件变量
  • 当条件满足,线程需要通知等待的线程
  • pthread_cond_signal函数通知单个线程
  • pthread_cond_broadcast函数通知所有线程
  • pthread_cond_wait函数内部流程

    1. unlock(&mutex); // 释放锁
    2. lock(&mutex);
    3. 将线程自己插入到条件变量的等待队列中
    4. unlock(&mutex);
    5. 当前等待的线程阻塞(等待阻塞) <== 等其他线程通知唤醒
    6. 在唤醒后,lock(&mutex)
    7. 在等待队列中删除自己
  • 示例
typedef struct
{
        pthread_mutex_t mutex;
        pthread_cond_t cond;
        int res;
        int is_wait;
}Data;
void* get_v(void*);
void* compare_v(void*);
int main(void)
{
        pthread_cond_t cond;
        pthread_mutex_t mutex;
        pthread_cond_init(&cond,NULL);
        pthread_mutex_init(&mutex,NULL);
        Data data = {mutex,cond,0,0};
        pthread_t thread1_id,thread2_id;
        if(pthread_create(&thread1_id,NULL,compare_v,(void*)&data) != 0)
        {
                printf("create thread1 error\n");
                return 1;
        }
        if(pthread_create(&thread2_id,NULL,get_v,(void*)&data) != 0)
        {
                printf("create thread2 error\n");
                return 1;
        }
        pthread_join(thread1_id,NULL);
        pthread_join(thread2_id,NULL);
        pthread_cond_destroy(&cond);
        pthread_mutex_destroy(&mutex);
        return 0;
}
// 获得输入和输出结果的线程函数
void* get_v(void* data)
{
        Data* d = (Data*)data;
        // 锁定数据,避免多个线程同时操作
        pthread_mutex_lock(&d->mutex);
        // 读取输入
        scanf("%d",&d->res);
        // 设置判断条件变量,使计算线程知道已经读取数据完毕
        d->is_wait = 1;
        // 等待计算线程计算完成
        pthread_cond_wait(&d->cond,&d->mutex);
        // pthread_cond_wait函数最后会将mutex再次锁住,所以这里要解锁
        pthread_mutex_unlock(&d->mutex);
        printf("res = %d",d->res);
        return (void*)NULL;
}
// 负责计算的线程函数
void* compare_v(void*data)
{
        Data* d = (Data*)data;
        // 先锁住,避免数据同时有多个线程操作
        pthread_mutex_lock(&d->mutex);
        // 判断输入线程是否已经正确读取输入
        while(d->is_wait == 0)
        {
                // 先解除锁定,给读取输入的线程机会去读取输入
                pthread_mutex_unlock(&d->mutex);
                usleep(0.1);
                // 再次锁定
                pthread_mutex_lock(&d->mutex);
        }
        // 读取数据线程成功读取,等待计算结果,下面进行计算
        int res = 0;
        for(int i = 0;i <= d->res;i++)
        {
                res += i;
        }
        d->res = res;
        // 先解除上面的锁定
        pthread_mutex_unlock(&d->mutex);
        // 通知输出线程输出数据
        pthread_cond_broadcast(&d->cond);
        return (void*)NULL;
}
  • 读者和写者
typedef struct
{
        int data;
        int write;/* 0表示不能写数据,1表示可以写数据 */
        int read;/* 0表示不能读数据,1表示可以读数据 */
        int length;
        pthread_cond_t write_cond;
        pthread_cond_t read_cond;
        pthread_mutex_t write_mutex;
        pthread_mutex_t read_mutex;
}Data;
int main(void)
{
        Data data = {0,0,1,3};
        pthread_cond_init(&data.write_cond,NULL);
        pthread_cond_init(&data.read_cond,NULL);
        pthread_mutex_init(&data.write_mutex,NULL);
        pthread_mutex_init(&data.read_mutex,NULL);
        pthread_t thread1_id,thread2_id;
        pthread_create(&thread1_id,NULL,writer,(void*)&data);
        pthread_create(&thread2_id,NULL,reader,(void*)&data);
        pthread_join(thread1_id,NULL);
        pthread_join(thread2_id,NULL);
        return 0;
}
/* 得到reader方法通知写数据,再通知writer方法写数据,并阻塞等待reader方法读数据  */
void* writer(void* data)
{
        Data* d = (Data*)data;
        for(int i = 0;i < d->length;i++)
        {
                pthread_mutex_lock(&d->write_mutex);
                while(d->write == 0)
                {
                        pthread_mutex_unlock(&d->write_mutex);
                        usleep(0.1);
                        pthread_mutex_lock(&d->write_mutex);
                }
                printf("write %d\n",d->data);
                d->write = 0;
                d->read = 1;
                pthread_mutex_unlock(&d->write_mutex);
                pthread_cond_broadcast(&d->read_cond);
                if(i < ( d->length - 1) )
                {
                        pthread_cond_wait(&d->write_cond,&d->write_mutex);
                        pthread_mutex_unlock(&d->write_mutex);
                }
        }
        return (void*)NULL;
}
/* 读数据方法,先读数据,再通知writer方法写一个数据,并阻塞等write方法通知 */
void* reader(void* data)
{
        Data* d = (Data*)data;
        for(int i = 0;i < d->length;i++)
        {
                pthread_mutex_lock(&d->write_mutex);
                d->data = i;
                d->write = 1;
                printf("read %d\n",d->data);
                pthread_cond_broadcast(&d->write_cond);
                while(d->read == 0)
                {
                        pthread_mutex_unlock(&d->write_mutex);
                        usleep(0.1);
                        pthread_mutex_lock(&d->write_mutex);
                }
                d->read = 0;
                pthread_mutex_unlock(&d->write_mutex);
                if(i < ( d->length - 1) )
                {
                        pthread_cond_wait(&d->read_cond,&d->read_mutex);
                        pthread_mutex_unlock(&d->read_mutex);
                }
        }
        return (void*)NULL;
}

线程的同步和互斥-线程信号量

  • 信号量从本质上是一个非负整数计数器,是共享资源的数目,通常被用来控制对共享资源的访问。
  • 信号量可以实现线程的同步和互斥
  • 通过sem_post()和sem_wait()函数对信号量进行加减操作从而解决线程的同步与互斥
  • 信号量数据类型

    • sem_t

信号量的创建和销毁

int sem_init(sem_t* sem,int pshared,unsigned value);
int sem_destroy(sem_t* sem);

  • 返回:成功返回0,失败返回错误编号
  • 头文件
#include <semaphore.h>
  • 参数

    • sem

      • 信号量指针
    • pshared

      • 是否在进程间共享的标志,0为不共享,1为共享
    • value

      • 信号量的初始值

信号量的加和减操作

int sem_post(sem_t* sem);

  • 功能:增加信号量的值
    int sem_wait(sem_t* sem);
  • 功能:减少信号量的值
    int sem_trywait(sem_t* sem);
  • 功能:sem_wait的非阻塞版本
  • 返回:成功返回0,出错返回错误编号
  • 调用sem_post一次信号作加1操作
  • 调用sem_wait一次信号量作减一操作
  • 当线程调用sem_wait后,若信号量的值小于0则线程阻塞。只有在其他线程在调用sem_post对信号量作加操作之后并且其值大于或等于0时,阻塞的线程才能继续运行
  • 示例
int main(void)
{
        // 按照 c->b->a 的顺序执行
        sem_init(&sem1,0,0);
        sem_init(&sem2,0,0);
        pthread_t thread_a,thread_b,thread_c;
        pthread_create(&thread_a,NULL,a,(void*)NULL);
        pthread_create(&thread_b,NULL,b,(void*)NULL);
        pthread_create(&thread_c,NULL,c,(void*)NULL);
        pthread_join(thread_a,NULL);
        pthread_join(thread_b,NULL);
        pthread_join(thread_c,NULL);
        return 0;
}
void* a(void* data)
{
        sem_wait(&sem1);
        printf("func a\n");
        return (void*)NULL;
}
void* b(void* data)
{
        sem_wait(&sem2);
        sem_post(&sem1);
        printf("func b\n");
        return (void*)NULL;
}
void* c(void* data)
{
        sem_post(&sem2);
        printf("func c\n");
        return (void*)NULL;
}
  • PV操作-银行账户
ypedef struct
{
        int deposit;
        sem_t sem;
}Account;
int main(void)
{
        pthread_t thread1_id,thread2_id;
        Account account = {888};
        sem_init(&account.sem,0,1);
        pthread_create(&thread1_id,NULL,func1,(void*)&account);
        pthread_create(&thread2_id,NULL,func2,(void*)&account);
        pthread_join(thread1_id,NULL);
        pthread_join(thread2_id,NULL);
        return 0;
}
void* func1(void* data)
{
        Account* a = (Account*)data;
        // P(1)
        sem_wait(&a->sem);
        if(a->deposit >= 888)
        {
                a->deposit -= 888;
        }
        // V(1)
        sleep(2);
        printf("func1; deposit = %d\n",a->deposit);
        sem_post(&a->sem);
        return (void*)NULL;
}
void* func2(void* data)
{
        Account* a = (Account*)data;
        // P(1)
        sem_wait(&a->sem);
        if(a->deposit >= 888)
        {
                a->deposit -= 888;
        }
        // V(1)
        sleep(1);
        printf("func2; deposit = %d\n",a->deposit);
        sem_post(&a->sem);
        return (void*)NULL;
}
  • 计算
typedef struct
{
        int data;
        sem_t get_sem,c_sem;
}Data;
int main(void)
{
        Data data = {1};
        sem_init(&data.get_sem,0,0);
        sem_init(&data.c_sem,0,0);
        pthread_t thread1_id,thread2_id;
        // get_v线程先读取输入,calculate_v线程计算,再由get_v线程输出
        pthread_create(&thread1_id,NULL,calculate_v,(void*)&data);
        pthread_create(&thread2_id,NULL,get_v,(void*)&data);
        pthread_join(thread1_id,NULL);
        pthread_join(thread2_id,NULL);
        return 0;
}
void* get_v(void* data)
{       
        Data* d = (Data*)data;
        scanf("%d",&d->data);
        sem_post(&d->c_sem);
        sem_wait(&d->get_sem);
        printf("data = %d\n",d->data);
        return (void*)NULL;
}
void* calculate_v(void* data)
{
        Data* d = (Data*)data;
        sem_wait(&d->c_sem);
        d->data += 8;
        sem_post(&d->get_sem);
        return (void*)NULL;
}

死锁

  • 两个线程试图同时占用两个资源,并按不同次序锁定相应的共享资源
  • 解决方式

    • 按相同的次序锁定相应的共享资源
    • 使用函数pthread_mutex_trylock,它是函数pthread_mutex_lock的非阻塞函数

线程和信号

  • 进程中每个线程都有自己的信号屏蔽字和信号未决字
  • 信号的处理方式是进程中所有线程共享的
  • 进程中的信号是传递到单个线程的
  • 定时器是进程资源,进程中所有线程共享相同的定时器

    • 子线程调用alarm函数产生的alarm信号发送给主控线程
      int pthread_sigmask(int how,const sigset_t*restrict set,sigset_t*restrict oset);
  • 功能:线程的信号屏蔽
  • 返回:成功返回0,失败返回错误编号
  • 示例
#include <stdio.h>
#include <pthread.h>
#include <signal.h>
void* func1(void*);
void* func2(void*);
void alarm_handle(int);
int main(void)
{
        pthread_t t1_id,t2_id;
        pthread_create(&t1_id,NULL,func1,(void*)NULL);
        pthread_create(&t2_id,NULL,func2,(void*)&t1_id);
        // 虽然是睡眠10s,但是子线程会发送alarm信号(SIGALRM默认给主线程处理),这时主线程会醒来继
续运行,可以在主线程中屏蔽,如下
        // 编译时加上 std=gnu99,不然会显示sigset_t类型没有定义
        sigset_t sig_set;
        sigemptyset(&sig_set);
        sigaddset(&sig_set,SIGALRM);
        // 屏蔽,当前线程不会处理
        pthread_sigmask(SIG_SETMASK,&sig_set,NULL);
        for(int i = 0;i < 10;i++)
        {
                printf("master thread i = %d;thread_id = %d\n",i,pthread_self());
                sleep(10);
        }
        pthread_join(t1_id,NULL);
        pthread_join(t2_id,NULL);
        return 0;
}
void alarm_handle(int sig)
{
        printf("I am alarm handle;threadid = %d\n",pthread_self());
        signal(SIGALRM,alarm_handle);
        alarm(2);
}
void* func1(void* data)
{
        // 在子线程中设置信号处理函数
        signal(SIGALRM,alarm_handle);
        alarm(2);
        for(int i = 0;i < 100;i++)
        {
                printf("thread1 i = %d;thread_id = %d\n",i,pthread_self());
                sleep(1);
        }
        return (void*)NULL;
}
void* func2(void* data)
{
        for(int i = 0;i < 100;i++)
        {
                if(i == 8)
                {
                        // 终止func1进程
                        pthread_cancel(*((pthread_t*)data));
                }
                printf("thread2 i = %d;thread_id = %d\n",i,pthread_self());
                sleep(1);
        }
        return (void*)NULL;
}

linux编程学习 02 进程与信号

进程

  • 程序:是存放在磁盘文件中的可执行文件
  • 进程

    • 程序的执行示例被称为进程(process)
    • 进程独立的权限和职责,如果系统中某个进程崩溃,它不会影响其余的进程。
    • 每个进程允许在气各自的虚拟地址空间中,进程之间可以通过由内核控制的机制互相通讯
  • 进程ID

    • 每个linux进程都一定有一个唯一的数字标识符,称为进程ID(process ID),进程ID总是一个非负整数
  • 每一个启动的进程都对应一个task_struct结构体
  • task_struct可以在/usr/src/kernels/2.6.32-642.13.1.el6.x86_64/include/linux/sched.h文件中查看,注意只有安装了kernel-devel包才有这个文件

c程序启动过程

  • 内核启动特殊例程
  • 启动例程

    • 在进程的main函数执行之前内核会启动
    • 该历程放置在/lib/libc.so.*
    • 编译器在编译时会将启动例程编译进可执行文件中
  • 启动例程作用

    • 搜集命令行的参数传递给main函数中的argc和argv
    • 搜集环境信息构建环境表并传递给main函数
    • 登记进程的终止函数

进程终止

  • 正常终止

    • 从main函数返回
    • 调用exit(标准c库函数)
    • 调用_exit_Exit(系统调用)
    • 最后一个线程从其启动例程返回
    • 最后一个线程调用pthread_exit
  • 异常终止

    • 调用abort
    • 接受到一个信号并终止
    • 最后一个线程对取消请求做处理响应
  • 进程返回

    • 通常程序运行成功返回0,否则返回非0
    • 在shell中可以查看进程返回值(echo $?)

atexit函数

int atexit(void (*function)(void));

  • 返回:若成功则为0,若出错则为-1
  • 功能:像内核登记终止函数
  • 头文件:
#include <stdlib.h>
  • 每个启动的进程都默认登记了一个标准的终止函数
  • 终止函数在进程终止时释放进程所占用的一些资源
  • 登记的多个终止函数执行顺序是以栈的方式执行,先登记的后执行
  • 使用_exit或_Exit退出时,不会执行终止函数

进程终止方式的区别

对比项returnexit()_exit()/_Exit()
是否刷新标准I/O缓存
是否自动调用终止函数

在centos 6.6 中,使用 _exit和_Exit会调用终止函数

ps命令

  • 可以查看到:进程的id,进程的用户id,进程状态和进程的command
  • ps aux可以查看到更多的信息
  • ps输出信息
    |列名|解释|
USER进程的属主
PID进程的ID
PPID父进程ID
%CPU进程占用的CPU时间
%MEM占用内存的百分比
NI进程的NICE值,数值大,表示较少占用CPU时间
VSZ进程的虚拟大小
RSS驻留集的大小,可以理解为内存中页的数量
TTY终端ID
WCHAN正在等待的进程资源
START启动进程的时间
TIME进程消耗CPU的时间
COMMAND命令的名称和参数

进程状态

进程常见状态

  • 运行状态

    • 系统当前进程
    • 就绪状态进程
    • ps命令的STAT列为R
  • 等待状态

    • 等待事件发生
    • 等待系统资源
    • 等待状态可分为可中断等待和不可中断等待
    • 可中断等待时ps命令的STAT列为S
    • 不可中断等待时ps命令的STAT列为D
  • 停止状态

    • ps命令的STAT列为T
  • 僵尸状态

    • 进程终止或结束
    • 在进程表项中仍有记录
    • ps命令的STAT列为Z

进程调度

  • 第一步:处理内核中的工作
  • 第二步:处理当前进程
  • 第三步:选择进程

    • 实时进程
    • 普通进程
  • 第四步:进程交换
  • task_struct中的调度信息

    • 策略

      • 轮流策略
      • 先进先出策略
    • 优先权

      • Jiffies变量
    • 实时优先权

      • 实时进程之间
    • 计数器

进程标识

pid_t getpid(void); 获得当前进程ID
pid_t getuid(void); 获得当前进程的实际用户ID
pid_t geteuid(void); 获得当前进程的有效用户ID,启动程序时使用的用户id,参照nginx
pid_t getgid(void); 获得当前进程的用户组ID
pid_t getppid(void); 获得当前进程的父进程ID
pid_t getpgrp(void); 获得当前进程所在进程组ID
pid_t getpgid(pid_t pid); 获得进程ID为pid的进程所在的进程组ID

  • 头文件
#include <unistd.h>
#include <sys/types.h>

进程创建

pid_t fork(void);
pid_t vfork(void);

  • 返回:子进程中为0,父进程中为子进程ID,出错为-1
  • fork创建的新进程被称为子进程,该函数被调用一次,但返回两次。两次返回的区别是:在子进程中的返回值是0,而在父进程中的返回值则是进进程的进程ID
  • 创建子进程,父子进程哪个先运行根据系统调度且复制父进程的内存空间
  • vfork创建子进程,但子进程先运行且不复制父进程的内存空间

子进程的继承

  • 子进程的继承属性

    • 用户的信息和权限,目录信息,信号信息,环境,共享存储段,资源限制,堆,栈和数据段,就是把父进程的信息复制一遍。但是共享代码段(复制虚拟地址,但是虚拟地址映射到同一个物理地址)。
  • 子进程特有属性

    • 进程ID,锁信息,运行时间,未决信号
  • 操作文件时的内核结构变化

    • 子进程只继承父进程的文件描述表,不继承但共享文件表项和i-node。
    • 父进程创建一个子进程后,文件表项的引用计数器加1变2,当父进程作close操作后,计数器减1,子进程还是可以使用文件表项,只有当计数器为0时才会释放文件表项
  • 实例
/**
 * 如何创建子进程
 * */
void fork_example1(void)
{
        int pid = fork();
        if(pid == -1) 
        {   
                printf("fork error\n");
        }   
        // 根据fork的返回值判断是父进程还是子进程
        if(pid > 0)
        {   
                // 父进程睡眠下,如果父进程在子进程结束之前结束,子进程ppid就为1
                sleep(1);
                printf("I am parent process,my pid is %d,my ppid is %d\n",getpid(),getppid());
        }
        else
        {   
                printf("I am child process,my pid is %d,my ppid is %d\n",getpid(),getppid());
        }           
}
/**
 * 父子进程哪个先运行由系统调度
 **/
void fork_example2(void)
{
        int pid = fork(),l = 10;
        if(pid == 0)
        {
                for(int i = 0;i < l;i++)
                {
                        sleep(1);
                        printf("parent pid => %d,ppid => %d;count => %d\n",getpid(),getppid(),i);
                }
        }
        else
        {
                for(int i = 0;i < l;i++)
                {
                        sleep(1);
                        printf("child pid => %d,ppid => %d;count => %d\n",getpid(),getppid(),i);
                }
        }
}
int a = 1;
/**
 * 子进程和父进程的虚拟地址是一样的,下面的打印可以看出,但是物理地址是不一样的
 * */
void fork_example3(void)
{
        int b = 2;
        int pid = fork();
        if(pid > 0)
        {
                printf("&a = %p;&b = %p",&a,&b);
        }
        else if(pid == 0)
        {
                printf("&a = %p;&b = %p",&a,&b);
        }
}
/**
 * io
 * */
void fork_example4(void)
{
        FILE* f1 = fopen("f1.txt","w+");
        int f2 = open("f2.txt",O_CREAT | O_WRONLY);
        // c标准函数写,这里的start在文件里面会写入两次,因为子进程会把标准的id的缓存也复制一边>,最后结束时,就会写入两次
        fprintf(f1,"start\n");
        // 系统函数写
        write(f2,"start\n",6);
        int pid = fork();
        if(pid > 0)
        {
                // c标准函数写
                fprintf(f1,"parent end\n");
                // 系统函数写
                write(f2,"parent end\n",11);
        }
        else if(pid == 0)
        {
                // c标准函数写
                fprintf(f1,"child end\n");
                // 系统函数写
                write(f2,"child end\n",10);
        }
        fclose(f1);
        close(f2);
}
void fork_example5(void)
{
        int f = open("a.txt",O_WRONLY | O_CREAT);
        int pid = fork();
        if(pid > 0)
        {
                // 主进程调整位置,子进程写入
                lseek(f,0,SEEK_END);
        }
        else
        {
                sleep(3);
                // f是主进程f的复制,所以主进程使用lseek对子进程也是有效的
                write(f,"write",5);
        }
        close(f);
}

进程链

int main(void)
{
        int pid = 0;
        for(int i = 10;i > 0;i--)
        {
                if(pid > 0)
                {
                        sleep(i);
                        printf("pid = %d;ppid = %d\n",getpid(),getppid());
                        break;
                }
                else if(pid == 0)
                {
                        pid = fork();
                }
        }
        return 0;
}

进程扇

int main(void)
{
        int pid = 0;
        for(int i = 10;i > 0;i--)
        {       
                pid = fork();
                if(pid == 0)
                {       
                        printf("pid = %d;ppid = %d\n",getpid(),getppid());
                        return 0;
                }
        }
        sleep(3);
        printf("pid = %d;ppid = %d\n",getpid(),getppid());
        return 0;
}

守护进程

  • 守护进程(deamon)是生存期长的一种进程。他们常常在系统引导装入时启动,在系统关闭时终止。
  • 所有守护进程都以超级用户(用户id为0)的优先权运行
  • 守护进程没有控制终端
  • 守护进程的父进程都是init进程

孤儿进程

  • 父进程结束,子进程就成为孤儿进程,会由1号进程(init进程)领养。

僵尸进程

  • 子进程结束但是没有完全释放内存(在内核中的task_struct没有释放),该进程就成为僵尸进程。
  • 当僵尸进程的父进程结束后就会被init进程领养。最终被回收
  • 避免僵尸进程

    • 让僵尸进程的父进程来回收,父进程每隔一段时间来查询子进程是否结束并回收,调用wait()或waitpid(),通知内存释放僵尸进程
    • 采用信号SIGCHLD通知处理,并在信号处理程序中调用wait函数
    • 让僵尸进程成为孤儿进程,有init回收
  • 实例
int main(void)
{
        int pid = fork();
        if(pid == 0)
        {
                printf("child finish\n");
                // 这里return之后子进程就成为僵尸进程了
                return 0;
        }
        while(1)
        {
                sleep(1);
        }
        return 0;
}

wait和waitpid

pid_t wait(int* status);

  • 返回:成功返回子进程id,出错返回-1
  • 功能:等待子进程推出并回收,防止僵尸进程的产生
    pid_t waitpid(pid_t pid,int* status,int options);
  • 返回:成功返回子进程id,出错返回-1
  • 功能:wait函数的非阻塞版本
  • 头文件
#include <sys/types.h>
#include <sys/wait.h>
  • wait与waitpid函数区别

    • 在一个子进程终止前,wait使其调用者阻塞
    • waitpid有一选择项,可使调用者不阻塞
    • waitpid等待一个指定的子进程,而wait则等待所有的子进程,返回任一终止子进程的状态
  • status参数

    • 为空时,代表任意状态结束的子进程,若不为空,则代表指定状态结束的子进程
  • 检查wait和waitpi函数返回终止状态的宏

    • WIFEXITED/WEXITSTATUS(status)

      • 若为正常终止子进程返回的状态,则为真
    • WIFSIGNALED/WTERMSIG(status)

      • 若为异常终止子进程返回的状态则为真(接到一个不能捕捉的信号)
    • WIFSTOPPED/WSTOPSIG(status)

      • 若为当前暂停子进程的返回的状态,则为真
  • options参数

    • WNOHANG

      • 若由pid指定的进程没有退出则立即返回,则waaitpid不阻塞,此时其返回值为0
    • WUNTRACED

      • 若某实现支持作业控制,则由pid指定的任一子进程状态已暂停,且其状态自暂停以来还未报告过,则返回其状态
  • waitpid函数的pid参数

    • pid == -1

      • 等待任一子进程,功能与wait等效
    • pid > 0

      • 等待进程id与pid相等的子进程
    • pid == 0

      • 等待其组id等于调用进程的组id的任一子进程
    • pid < -1

      • 等待其组id等于pid的绝对值得任一进程
  • 示例
void out_put(int status)
{       
        int i = 0;
        if(WIFEXITED(status))
        {       
                printf("normal exit;");
                i = WEXITSTATUS(status);
        }
        else if(WIFSIGNALED(status))
        {       
                printf("abnormal exit;");
                i = WTERMSIG(status);
        }
        else if(WIFSTOPPED(status))
        {       
                printf("stopped sig;");
                i = WSTOPSIG(status);
        }
        printf("status = %d\n",i);
}
int main(void)
{
        int pid = fork();
        int status;
        if(pid == 0)
        {
                printf("pid = %d;ppid = %d\n",getpid(),getppid());
                sleep(3);
                // 暂停
                pause();
                exit(1);
                return 11;
        }
        // 会阻塞
        // wait(&status);
        // sleep(3);
        // waitpid(pid,&status,WNOHANG);
        // 不会阻塞,
        while(0 == waitpid(pid,&status,WUNTRACED | WNOHANG))
        {

        }
        out_put(status);
        return 0;
}

exec函数

  • 在用fork函数创建子进程后,子进程往往要调用一种exec函数以执行另一个程序
  • 当进程调用一冲exec函数时,该程序完全由新程序代换,替换原有进程的正文,而新程序则从其main函数开始执行。因为调用exec并不创建新进程,所以前后的进程id并不改变。exec只是用另一个新程序替换了当前进程的正文,数据,堆和栈。
int execl(const char* pathname,const char* arg0,.../* (char*)0 */);
int execv(const char* pathname,char* const argv[]);
int execle(const char* pathname,const char* arg0,.../* (char*)0,char* const envp[] */);
int execve(const char* pathname,char* const argv[],char* const envp[]);
int execlp(const char* pathname,const char* arg0,.../* (char*)0 */);
int execvp(const char* pathname,char* const argv[]);
  • 返回:出错返回-1,成功则不返回
  • exec系列函数注意点

    • execve函数为系统调用,其余为库函数。执行execve函数后面的代码不执行
    • execlp和execvp函数中的pathname,相对路径和绝对路径均可使用,其他四个函数中的pathname只能使用绝对路径。相对路径一定要在进程环境表对应的PATH中
    • argv参数为新程序执行main函数中传递argv参数,最后一个元素为NULL
    • envp为进程的环境表
  • 六个函数都是以“exec”四个字母开头,后面的字幕代表了其用法上的区别:

    • 带有字母的“l”函数,表明后面的参数列表是要传递给程序的参数列表,参数列表的第一个参数必须是执行程序,最后一个参数必须是NULL
    • 带有字母“p”的函数,第一参数可以是相对路径或程序名,如果无法立即找到要执行的程序,那么就在环境变量PATH指定的路径中搜索。其他函数的第一个参数则必须是绝对路径名。
    • 带有字母“v”的函数,表明程序的参数列表通过一个字符串数组来传递。这个数组和最后传递给程序的main函数的字符串数组argv完全一样。第一个参数必须是程序名。最后一个参数也必须是NULL
    • 带有字母“e”的函数,用户可以自己设置程序接收一个设置环境变量的数组
  • 示例
int main(void)
{
        char command1[] = "cat",command2[] = "/bin/cat";
        char *parameters[20] = {command1,"/etc/passwd",NULL};
        int pid = fork();
        if(pid == 0)
        {       
                // 注意传递参数时,命令也要传递进去
                if(execl(command2,parameters[0],parameters[1],parameters[2]))
                // if(execvp(command1,parameters))
                {
                        perror("error\n");
                        return 1;
                }
                else
                {       
                        // 下面这个不会输出,因为子进程成功不会返回
                        printf("success\n");
                        return 0;
                }
        }
        wait(NULL);
        return 0;
}

system函数

int systemp(const char* command);

  • 返回:成功返回命令执行的状态,出错返回-1
  • 功能:简化exec函数的使用
  • 头文件
    #include <stdlib.h>
  • system函数内部构建一个子进程,由子进程调用exec函数
  • 等同于/bin/bash -c "command"或者exec("bash","-c","cmd")
  • 示例
int main(void)
{
        char* command = "date";
        // system(command);
        my_system(command);
        return 0;
}
void my_system(char* command)
{
        int pid = fork();
        if(pid == 0)
        {
                execl("/bin/bash","bash","-c",command,NULL);
                perror("error:");
        }
        wait(NULL);
}

进程状态的切换

new ---fork---> runnable <-os scheduler/timeout-> running -return/exit/_exit-> dead
         ↑                        |
         |                   read/write/sleep/pause
         |                        ↓
         ---------------------block suspend

信号

  • 信号signal机制是linux系统中最古老的进程之间的通信机制,解决进程在正常运行中被中断的问题,导致进程的处理流程会发生变化
  • 信号是软件中断
  • 信号是异步事件

    • 不可预见
    • 信号有自己的名称和编号
    • 信号和异常处理机制
  • 信号发生的来源

    • 硬件来源:比如我们按下了键盘或其他硬件故障,信号是由硬件驱动程序产生
    • 软件来源:最常用发送信号的系统函数是kill(),raise(),alarm()和setitimer()等函数,软件来源还包括一些非法运算登操作,软件设置条件(如:gdb调试),信号是由内核产生。

信号无优先级

1~31:非实时信号,发送的信号可能会丢失,不支持信号排队
31~64:实时信号,支持信号排队发送的多个实时信号都会被接收
可在/usr/include/bits/signum.h

信号的处理

进程可以通过三种方式来响应和处理一个信号

  • 忽略信号

    • SIGKILL和SIGSTOP永远不能忽略
    • 忽略硬件异常
    • 进程启动时SIGUSR1和SIGUSR2两个信号被忽略
  • 执行默认操作

    • 每个信号有默认动作大部分信号默认动作是终止进程
  • 捕获信号

    • 告诉内核出现信号时调用自己的处理函数
    • SIGKILL和SIGSTOP不能被捕获

信号变革

  • 信号出现在最早的unix系统中
  • 早期信号模型是不可靠
  • BSD和System V分别对早期信号进行扩展,但是相互不兼容
  • POSIX统一了上述两种模型,提供了可靠信号模型

SIGNAL函数

void (*signal(int signo,void (*func)(int)))(int);

  • 返回:若成功则返回先前的信号处理函数指针,出错则返回SIG_ERR
  • 功能:向内核登记信号处理函数
  • 参数

    • signo

      • 要登记的信号值,一般使用参数的宏,方便辨识
    • func

      • 信号处理函数指针
      • SIG_IGN:忽略信号
      • SIG_DFL:采用系统默认方式处理信号,执行默认操作
  • 示例
int main(void)
{
        // kill -20 pid即可看到函数被执行了
        // signal(SIGTSTP,my_signal_handle);
        // 忽略
        if(signal(SIGTSTP,SIG_IGN) == SIG_ERR)
        {
                perror("error");
        }
        for(int i = 0;i < 6;i++)
        {
                sleep(6);
                printf("for => i = %d\n",i);
        }
        return 0;
}
void my_signal_handle(int sig)
{
        printf("I am my signal handle\n;my pid is %d\nsignal number is %d\n",getpid(),sig);
}

SIGCHLD信号

  • 子进程状态发生变化(子进程结束)产生该信号,父进程需要使用wait调用来等待子进程结束并回收它
  • 避免僵尸进程
  • 示例
void my_sigchld_handle(int sig)
{
        // 当接受到信号时要调用wait函数,否则子进程会是僵尸进程
        wait(NULL);
        printf("excute wait;pid = %d\n",getpid());
}
int main(void)
{
        // 子进程结束时会执行
        signal(SIGCHLD,my_sigchld_handle);
        int pid = fork();
        if(pid > 0)
        {
                for(int i = 0;i < 66;i++)
                {
                        sleep(1);
                        printf("I am parent;pid = %d;count = %d\n",getpid(),i);
                }

        }
        else if( pid == 0 )
        {
                
                for(int i = 0;i < 6;i++)
                {
                        sleep(1);
                        printf("I am child;pid = %d;count = %d\n",getpid(),i);
                }
        }
        else
        {
                perror("fork error");
        }
        return 0;
}

信号发送

  • 除了内核和超级用户,并不是每个进程都可以向其他的进程发送信号。
  • 一般的进程只能向具有相同uid和gid的进程发送信号,或向相同进程组中的其他进程发送信号
  • 常用的发送信号的函数有kill(向其他进程发送),raise(向自己发送),alarm(定时器),settimer(定时器),abort(异常终止信号)

kill和raise函数

`int kill(pid_t pid,int signo);

  • 返回:成功返回0,出错返回-1
  • 功能:向指定的进程发送某一个信号
    `int raise(int signo);
  • 返回:成功返回0,出错返回-1
  • 功能:向进程本身发送某一个信号
  • 头文件
#include <signal.c>
  • 参数:

    • pid:接受信号进程的pid

      • pid>0:将信号发送给进程id为pid的进程
      • pid==0:将信号发送给与发送进程同一进程组的所有进程
      • pid<0:将信号发送给进程组id为pid的绝对值的所有进程
      • pid==-1:将该信号发送给发送进程有权限像他们发送信号的系统上的所有进程
    • signo:要发送的信号值
  • kill函数将信号发送给函数或进程组

    • 0为空信号,常用来检测特定进程是否存在
  • 示例
int main(void)
{
        signal(SIGUSR1,my_signal_handle);
        for(int i = 0;i < 66;i++)
        {
                // 程序直接结束
                // raise(SIGUSR1);
                kill(getpid(),SIGSTOP);
        }
        return 0;
}
void my_signal_handle(int signo)
{
        printf("I am signal handle\n");
}

定时器

unsigned int alarm(unsigned int seconds);

  • 返回:0或以前设置的定时器时间余留秒数
  • 头文件
#include <unistd.h>
  • alarm函数可设置定时器,当定时器超时,产生SIGALRM
  • 信号由内核产生,在指定的seconds秒之后,给进程本身发送一个SIGALRM信号
  • 参数为0,取消以前设置的定时器。
  • 一次性的
  • ualarm函数精确性更高
  • 示例
int main(void)
{
        signal(SIGALRM,my_sigalarm_handle);
        // 六秒后发送SIGALRM信号到本进程
        alarm(6);
        for(int i = 0;i < 66;i++)
        {
                printf("i = %d\n",i);
                sleep(1);
        }
}
void my_sigalarm_handle(int signo)
{
        printf("sigalrm signo = %d\n",signo);
        // 每隔五秒发送一次信号
        alarm(6);
        // 信号注册函数也需要重新执行下
        signal(SIGALRM,my_sigalarm_handle);
}