LinuxC应用开发学习笔记（十三）—高级I\O

最新推荐文章于 2023-07-10 10:03:05 发布
最新推荐文章于 2023-07-10 10:03:05 发布
阅读量487 收藏 2
点赞数 1
分类专栏： Linux操作系统 C语言 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46152793/article/details/122419380
版权

高级I\O

非阻塞IO – 阻塞 IO
补充：有限状态机编程

有限状态机
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>

#define  TTY1 "/dev/tty11"
#define  TTY2 "/dev/tty12"

#define BUFSIZE 1024 

enum
{
    STATE_R = 1,
    STATE_W,
    /*异常终止态*/
    STATE_Ex,
    STATE_T
};

struct fsm_st
{
    int state;
    int sfd;
    int dfd;
    int len;
    int pos;
    char * errstr;
    char buf[BUFSIZE];
};

static void fsm_driver(struct fsm_st*fsm)
{
    int ret;
    switch (fsm->state)
    {
    case STATE_R:
        fsm->len = read(fsm->sfd,fsm->buf,BUFSIZE);
        if (fsm->len == 0)
        fsm->state = STATE_T;
        else if (fsm->len < 0)
        {
            if (errno == EAGAIN)
                fsm->state =STATE_R;
            else
            {
                fsm->errstr = "read()";
                fsm->state =STATE_Ex;

            }    
        }
        else
        {
            fsm->pos = 0;
            fsm->state =STATE_W;     
        }  
        break;
    case STATE_W:
        ret = write(fsm->dfd,fsm->buf+fsm->pos,fsm->len);
        if(ret<0)
        {
            if (errno == EAGAIN)
                fsm->state =STATE_W;
            else 
            {
                fsm->errstr = "read()";
                fsm->state =STATE_Ex;
            }
                
        }
        else
        {
            fsm->pos += ret;

            fsm->len -= ret;
            if(fsm->len == 0)
                fsm->state = STATE_R;
            else 
                fsm->state = STATE_W;
        }
        
        break;
    case STATE_Ex:
        perror(fsm->errstr);
        fsm->state = STATE_T;
        break;
    case STATE_T:
        /*do sth*/
        break;
    default:
        /*发送异常*/
        abort();
        break;
    }

}
 
static void relay(int fd1,int fd2)
{
    int fd1_save,fd2_save;
    struct fsm_st fsm12,fsm21;
    /*保证两个文件是以非阻塞方式实现*/
    fd1_save = fcntl(fd1,F_GETFL); 
    fcntl(fd1,F_SETFL,fd1_save|O_NONBLOCK);

    fd2_save = fcntl(fd2,F_GETFL); 
    fcntl(fd2,F_SETFL,fd2_save|O_NONBLOCK);

    fsm12.state = STATE_R;
    fsm12.sfd = fd1;
    fsm12.dfd = fd2;
    
    fsm21.state = STATE_R;
    fsm21.sfd = fd2;
    fsm21.dfd = fd1;


    while (fsm12.state != STATE_T ||fsm21.state != STATE_T )
    {
        fsm_driver(&fsm12);
        fsm_driver(&fsm21);   
    }

    /*恢复之前的状态*/
    fcntl(fd1,F_SETFL,fd1_save);
    fcntl(fd2,F_SETFL,fd2_save);
     
}

int main()
{
    int fd1,fd2;
    fd1 = open(TTY1,O_RDWR);
    if (fd1<0)
    {
        perror("open()");
        exit(1);
    }

    write(fd1,"TTY1\n",5);

    fd2 = open(TTY2,O_RDWR|O_NONBLOCK);
    if (fd2<0)
    {
        perror("open()");
        exit(1);
    }

    write(fd2,"TTY2\n",5);

    relay(fd1,fd2);
    close(fd2);
    close(fd1);
    
    exit(0);
}

简单流程：自然流程是结构化的

复杂流程：自然流程不是结构化的

1、非阻塞IO

中继引擎实现实例

.h文件

#ifndef RELAYER_H__
#define RELAYER_H__
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define REL_JOBMAX 10000 

enum
{
    STATE_RUNNING=1,
    STATE_CANCELED,
    STATE_OVER

};



struct rel_stat_st
{
    int state;
    int fd1;
    int fd2;
    int64_t count12,count21;
    //struct timerval start end;
};


int rel_addjob(int fd,int fd2);
/*
*  return >=0  成功 返回当前任务ID
*          == -EINVAL 失败 参数非法
*          == -ENOSPC 失败 任务数组满
*          == -ENNMEM 失败 内存分配有误
*            
*/

int rel_canceljob(int fd);
/*
*  return  == 0  成功 制定任务成功取消
*          == -EINVAL 失败 参数非法
*          == -EBUSY  失败 任务早已被取消         
*/

int rel_waitjob(int fd,struct rel_stat_st *);
/*
*  return  == 0  成功 指定任务已终止并返回状态
*          == -EINVAL 失败 参数非法
*          == -EBUSY  失败 任务早已被取消         
*/

int rel_statjob(int fd,struct rel_stat_st *);
/*
*  return  == 0  成功  指定状态已经返回
*          == -EINVAL 失败 参数非法
*          == -EBUSY  失败 任务早已被取消         
*/

#endif // !RELAYER_H__

relayer.c文件

#include "relayer.h"
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>

#define  TTY1 "/dev/tty11"
#define  TTY2 "/dev/tty12"

#define BUFSIZE 1024 

enum
{
    STATE_R = 1,
    STATE_W,
    /*异常终止态*/
    STATE_Ex,
    STATE_T
};

struct rel_fsm_st
{
    int state;
    int sfd;
    int dfd;
    int len;
    int pos;
    char * errstr;
    char buf[BUFSIZE];
    int64_t count;
};

struct rel_job_st
{
    int job_state;
    int fd1;
    int fd2;
    struct rel_fsm_st fsm12,fsm21;
    int fd1_save,fd2_save;
};

static struct rel_job_st* rel_job[REL_JOBMAX];

static pthread_mutex_t mut_rel_job = PTHREAD_MUTEX_INITIALIZER;

static pthread_once_t  init_once = PTHREAD_ONCE_INIT;

static void fsm_driver(struct rel_fsm_st*fsm)
{
    int ret;
    switch (fsm->state)
    {
    case STATE_R:
        fsm->len = read(fsm->sfd,fsm->buf,BUFSIZE);
        if (fsm->len == 0)
        fsm->state = STATE_T;
        else if (fsm->len < 0)
        {
            if (errno == EAGAIN)
                fsm->state =STATE_R;
            else
            {
                fsm->errstr = "read()";
                fsm->state =STATE_Ex;

            }    
        }
        else
        {
            fsm->pos = 0;
            fsm->state =STATE_W;     
        }  
        break;
    case STATE_W:
        ret = write(fsm->dfd,fsm->buf+fsm->pos,fsm->len);
        if(ret<0)
        {
            if (errno == EAGAIN)
                fsm->state =STATE_W;
            else 
            {
                fsm->errstr = "read()";
                fsm->state =STATE_Ex;
            }
                
        }
        else
        {
            fsm->pos += ret;

            fsm->len -= ret;
            if(fsm->len == 0)
                fsm->state = STATE_R;
            else 
                fsm->state = STATE_W;
        }
        
        break;
    case STATE_Ex:
        perror(fsm->errstr);
        fsm->state = STATE_T;
        break;
    case STATE_T:
        /*do sth*/
        break;
    default:
        /*发送异常*/
        abort();
        break;
    }

}

static void *thr_relayer(void *p)
{
    while (1)
    {
    pthread_mutex_lock(&mut_rel_job);
        for (int i = 0; i < REL_JOBMAX; i++)
        {
            if (rel_job[i]!=NULL)
            {
                if (rel_job[i]->job_state == STATE_RUNNING)
                {
                    fsm_driver(&rel_job[i]->fsm12);
                    fsm_driver(&rel_job[i]->fsm21);
                    if(rel_job[i]->fsm12.state == STATE_T&&rel_job[i]->fsm21.state == STATE_T)
                    {
                        rel_job[i]->job_state = STATE_OVER;
                    }  
                }   
            }
        }
        pthread_mutex_unlock(&mut_rel_job);
    }
}

//static module_unload(void)
static void  module_load(void)
{
    int err = 0;
    pthread_t tid_relayer;
    err = pthread_create(&tid_relayer,NULL,thr_relayer,NULL);
    if (err)
    {
        fprintf(stderr,"pthread_create():%s\n",strerror(err));
        exit(1);
    }  
}


static int get_free_pos_unlocked()
{
    int i;
    for (i = 0; i < REL_JOBMAX; i++)
    {
        if (rel_job[i]==NULL) 
            return i;
    }
    return -1;
    
}


int rel_addjob(int fd1,int fd2)
{
    struct rel_job_st *me;
    /*动态模块的一次性初始化*/
    pthread_once(&init_once,module_load);

    int pos = 0;
    me = malloc(sizeof(*me));
    if (me == NULL)
       return -ENOMEM;
    me->fd1 = fd1;
    me->fd2 = fd2;
    me->job_state = STATE_RUNNING;



    /*保存状态,确保fd1和fd2都是非阻塞打开的*/
    me->fd1_save = fcntl(me->fd1,F_GETFL);
    fcntl(me->fd1,F_SETFL,me->fd1_save|O_NONBLOCK);
    
    me->fd2_save = fcntl(me->fd2,F_GETFL);
    fcntl(me->fd2,F_SETFL,me->fd2_save|O_NONBLOCK);
    

    me->fsm12.sfd = me->fd1;
    me->fsm12.dfd = me->fd2;
    me->fsm12.state = STATE_R;

    me->fsm21.sfd = me->fd2;
    me->fsm21.dfd = me->fd1;
    me->fsm21.state = STATE_R;

    pthread_mutex_lock(&mut_rel_job);
    get_free_pos_unlocked();
    if (pos < 0)
    {
        pthread_mutex_unlock(&mut_rel_job);
        fcntl(me->fd1,F_SETFL,me->fd1_save);
        fcntl(me->fd2,F_SETFL,me->fd2_save);
        free(me);
        return -ENOSPC;
    }

    rel_job[pos] = me;
    
    pthread_mutex_unlock(&mut_rel_job);
    
    return pos;
}
#if 0
int re_canceljob(int fd);


int re_waitjob(int fd,struct rel_stat_st *);


int re_statjob(int fd,struct rel_stat_st *);
#endif

main.c文件

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include "relayer.h"

#define  TTY1 "/dev/tty11"
#define  TTY2 "/dev/tty12"
#define  TTY3 "/dev/tty10"
#define  TTY4 "/dev/tty9"


int main()
{
    int fd1,fd2,fd3,fd4;
    int job1,job2;

    fd1 = open(TTY1,O_RDWR);
    if (fd1<0)
    {
        perror("open()");
        exit(1);
    }

    write(fd1,"TTY1\n",5);

    fd2 = open(TTY2,O_RDWR|O_NONBLOCK);
    if (fd2<0)
    {
        perror("open()");
        exit(1);
    }

    write(fd2,"TTY2\n",5);
    job1 = rel_addjob(fd1,fd2);
    if (job1 < 0)
    {
        fprintf(stderr,"rel_addjob():%s\n",strerror(-job1));
        exit(1);
    }
    
    fd3 = open(TTY3,O_RDWR);
    if (fd3<0)
    {
        perror("open()");
        exit(1);
    }
    write(fd3,"TTY3\n",5);

    fd4 = open(TTY4,O_RDWR);
    if (fd4<0)
    {
        perror("open()");
        exit(1);
    }
    write(fd3,"TTY4\n",5);

    job2 = rel_addjob(fd3,fd4);
    if (job2<0)
    {
        fprintf(stderr,"rel_addjob():%s\n",strerror(-job2));
        exit(1);
    }
    while (1)
        pause();    

    close(fd2);
    close(fd1);
    close(fd3);
    close(fd4);
    
    exit(0);
}

2、IO多路转接

select();//移植性非常好，以事件为单位组织文件描述符。

select（）示例
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/select.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>

#define  TTY1 "/dev/tty11"
#define  TTY2 "/dev/tty12"

#define BUFSIZE 1024 

enum
{
    STATE_R = 1,
    STATE_W,
    /*异常终止态*/
    STATE_AUTO,
    STATE_Ex,
    STATE_T
};

struct fsm_st
{
    int state;
    int sfd;
    int dfd;
    int len;
    int pos;
    char * errstr;
    char buf[BUFSIZE];
};

static void fsm_driver(struct fsm_st*fsm)
{
    int ret;
    switch (fsm->state)
    {
    case STATE_R:
        fsm->len = read(fsm->sfd,fsm->buf,BUFSIZE);
        if (fsm->len == 0)
        fsm->state = STATE_T;
        else if (fsm->len < 0)
        {
            if (errno == EAGAIN)
                fsm->state =STATE_R;
            else
            {
                fsm->errstr = "read()";
                fsm->state =STATE_Ex;

            }    
        }
        else
        {
            fsm->pos = 0;
            fsm->state =STATE_W;     
        }  
        break;
    case STATE_W:
        ret = write(fsm->dfd,fsm->buf+fsm->pos,fsm->len);
        if(ret<0)
        {
            if (errno == EAGAIN)
                fsm->state =STATE_W;
            else 
            {
                fsm->errstr = "read()";
                fsm->state =STATE_Ex;
            }
                
        }
        else
        {
            fsm->pos += ret;

            fsm->len -= ret;
            if(fsm->len == 0)
                fsm->state = STATE_R;
            else 
                fsm->state = STATE_W;
        }
        
        break;
    case STATE_Ex:
        perror(fsm->errstr);
        fsm->state = STATE_T;
        break;
    case STATE_T:
        /*do sth*/
        break;
    default:
        /*发送异常*/
        abort();
        break;
    }

}
 
static int max(int a,int b)
{
    if (a>b)
        return a;
    return b;
}

static void relay(int fd1,int fd2)
{
    int fd1_save,fd2_save;
    struct fsm_st fsm12,fsm21;
    
    fd_set rset,wset;

    /*保证两个文件是以非阻塞方式实现*/
    fd1_save = fcntl(fd1,F_GETFL); 
    fcntl(fd1,F_SETFL,fd1_save|O_NONBLOCK);

    fd2_save = fcntl(fd2,F_GETFL); 
    fcntl(fd2,F_SETFL,fd2_save|O_NONBLOCK);

    fsm12.state = STATE_R;
    fsm12.sfd = fd1;
    fsm12.dfd = fd2;
    
    fsm21.state = STATE_R;
    fsm21.sfd = fd2;
    fsm21.dfd = fd1;


    while (fsm12.state != STATE_T ||fsm21.state != STATE_T )
    {
        //布置监视任务
        //读集设置为空集
        FD_ZERO(&rset);
        FD_ZERO(&wset);
        if (fsm12.state == STATE_R)
            FD_SET(fsm12.sfd,&rset);
        if (fsm12.state == STATE_W)
            FD_SET(fsm12.sfd,&wset); 

        if (fsm21.state == STATE_R)
            FD_SET(fsm21.sfd,&rset);
        if (fsm21.state == STATE_W)
            FD_SET(fsm21.sfd,&wset);      

        //监视
        if(fsm12.state<STATE_AUTO||fsm21.state<STATE_AUTO)
        {
            if (select(max(fd1,fd2)+1,&rset,&wset,NULL,NULL)<0)
            {
                if (errno == EINTR)
                    continue;
                perror("select()");
                exit(1);
            }

        }
        

        //查看监视结果

        if(FD_ISSET(fd1,&rset)||FD_ISSET(fd2,&wset)||fsm12.state > STATE_AUTO)
            fsm_driver(&fsm12);
        if(FD_ISSET(fd2,&rset)||FD_ISSET(fd1,&wset)||fsm12.state > STATE_AUTO)
            fsm_driver(&fsm21);   
    }

    /*恢复之前的状态*/
    fcntl(fd1,F_SETFL,fd1_save);
    fcntl(fd2,F_SETFL,fd2_save);
     
}

int main()
{
    int fd1,fd2;
    fd1 = open(TTY1,O_RDWR);
    if (fd1<0)
    {
        perror("open()");
        exit(1);
    }

    write(fd1,"TTY1\n",5);

    fd2 = open(TTY2,O_RDWR|O_NONBLOCK);
    if (fd2<0)
    {
        perror("open()");
        exit(1);
    }

    write(fd2,"TTY2\n",5);

    relay(fd1,fd2);
    close(fd2);
    close(fd1);
    
    exit(0);
}

poll();//以文件描述符为单位来组织事件，也可以移植。

poll示例
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/select.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <poll.h>

#define  TTY1 "/dev/tty11"
#define  TTY2 "/dev/tty12"

#define BUFSIZE 1024 

enum
{
    STATE_R = 1,
    STATE_W,
    /*异常终止态*/
    STATE_AUTO,
    STATE_Ex,
    STATE_T
};

struct fsm_st
{
    int state;
    int sfd;
    int dfd;
    int len;
    int pos;
    char * errstr;
    char buf[BUFSIZE];
};

static void fsm_driver(struct fsm_st*fsm)
{
    int ret;
    switch (fsm->state)
    {
    case STATE_R:
        fsm->len = read(fsm->sfd,fsm->buf,BUFSIZE);
        if (fsm->len == 0)
        fsm->state = STATE_T;
        else if (fsm->len < 0)
        {
            if (errno == EAGAIN)
                fsm->state =STATE_R;
            else
            {
                fsm->errstr = "read()";
                fsm->state =STATE_Ex;

            }    
        }
        else
        {
            fsm->pos = 0;
            fsm->state =STATE_W;     
        }  
        break;
    case STATE_W:
        ret = write(fsm->dfd,fsm->buf+fsm->pos,fsm->len);
        if(ret<0)
        {
            if (errno == EAGAIN)
                fsm->state =STATE_W;
            else 
            {
                fsm->errstr = "read()";
                fsm->state =STATE_Ex;
            }
                
        }
        else
        {
            fsm->pos += ret;

            fsm->len -= ret;
            if(fsm->len == 0)
                fsm->state = STATE_R;
            else 
                fsm->state = STATE_W;
        }
        
        break;
    case STATE_Ex:
        perror(fsm->errstr);
        fsm->state = STATE_T;
        break;
    case STATE_T:
        /*do sth*/
        break;
    default:
        /*发送异常*/
        abort();
        break;
    }

}
 
static int max(int a,int b)
{
    if (a>b)
        return a;
    return b;
}

static void relay(int fd1,int fd2)
{
    int fd1_save,fd2_save;
    struct fsm_st fsm12,fsm21;
    
    struct pollfd pfd[2];

    /*保证两个文件是以非阻塞方式实现*/
    fd1_save = fcntl(fd1,F_GETFL); 
    fcntl(fd1,F_SETFL,fd1_save|O_NONBLOCK);

    fd2_save = fcntl(fd2,F_GETFL); 
    fcntl(fd2,F_SETFL,fd2_save|O_NONBLOCK);

    fsm12.state = STATE_R;
    fsm12.sfd = fd1;
    fsm12.dfd = fd2;
    
    fsm21.state = STATE_R;
    fsm21.sfd = fd2;
    fsm21.dfd = fd1;

    pfd[0].fd = fd1;
    pfd[1].fd = fd2;
    while (fsm12.state != STATE_T ||fsm21.state != STATE_T )
    {
        //布置监视任务
        //读集设置为空集
        pfd[0].events = 0;
        if (fsm12.state == STATE_R)
            pfd[0].events |= POLLIN;
        if (fsm21.state == STATE_W)
            pfd[0].events |= POLLOUT;

        pfd[1].events = 0;
        if (fsm21.state == STATE_R)
            pfd[1].events |= POLLIN;
        if (fsm12.state == STATE_W)
            pfd[1].events |= POLLOUT;

        
        

        //监视
        if(fsm12.state<STATE_AUTO||fsm21.state<STATE_AUTO)
        {
            while(poll(pfd,2,-1)<0)
            {
                if (errno == EINTR)
                    continue;
                perror("poll()");
                exit(1);
            }

        }
        

        //查看监视结果

        if(pfd[0].revents&POLLIN|| pfd[1].revents&POLLOUT||fsm12.state > STATE_AUTO)
            fsm_driver(&fsm12);
        if(pfd[1].revents&POLLIN|| pfd[0].revents&POLLOUT||fsm12.state > STATE_AUTO)
            fsm_driver(&fsm21);   
    }

    /*恢复之前的状态*/
    fcntl(fd1,F_SETFL,fd1_save);
    fcntl(fd2,F_SETFL,fd2_save);
     
}

int main()
{
    int fd1,fd2;
    fd1 = open(TTY1,O_RDWR);
    if (fd1<0)
    {
        perror("open()");
        exit(1);
    }

    write(fd1,"TTY1\n",5);

    fd2 = open(TTY2,O_RDWR|O_NONBLOCK);
    if (fd2<0)
    {
        perror("open()");
        exit(1);
    }

    write(fd2,"TTY2\n",5);

    relay(fd1,fd2);
    close(fd2);
    close(fd1);
    
    exit(0);
}

epoll();//linux的方言，无法移植。

epoll示例
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/select.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <sys/epoll.h>

#define  TTY1 "/dev/tty11"
#define  TTY2 "/dev/tty12"

#define BUFSIZE 1024 

enum
{
    STATE_R = 1,
    STATE_W,
    /*异常终止态*/
    STATE_AUTO,
    STATE_Ex,
    STATE_T
};

struct fsm_st
{
    int state;
    int sfd;
    int dfd;
    int len;
    int pos;
    char * errstr;
    char buf[BUFSIZE];
};

static void fsm_driver(struct fsm_st*fsm)
{
    int ret;
    switch (fsm->state)
    {
    case STATE_R:
        fsm->len = read(fsm->sfd,fsm->buf,BUFSIZE);
        if (fsm->len == 0)
        fsm->state = STATE_T;
        else if (fsm->len < 0)
        {
            if (errno == EAGAIN)
                fsm->state =STATE_R;
            else
            {
                fsm->errstr = "read()";
                fsm->state =STATE_Ex;

            }    
        }
        else
        {
            fsm->pos = 0;
            fsm->state =STATE_W;     
        }  
        break;
    case STATE_W:
        ret = write(fsm->dfd,fsm->buf+fsm->pos,fsm->len);
        if(ret<0)
        {
            if (errno == EAGAIN)
                fsm->state =STATE_W;
            else 
            {
                fsm->errstr = "read()";
                fsm->state =STATE_Ex;
            }
                
        }
        else
        {
            fsm->pos += ret;

            fsm->len -= ret;
            if(fsm->len == 0)
                fsm->state = STATE_R;
            else 
                fsm->state = STATE_W;
        }
        
        break;
    case STATE_Ex:
        perror(fsm->errstr);
        fsm->state = STATE_T;
        break;
    case STATE_T:
        /*do sth*/
        break;
    default:
        /*发送异常*/
        abort();
        break;
    }

}
 
static int max(int a,int b)
{
    if (a>b)
        return a;
    return b;
}

static void relay(int fd1,int fd2)
{
    int fd1_save,fd2_save;
    struct fsm_st fsm12,fsm21;
    struct epoll_event ev;
    int epfd;

    /*保证两个文件是以非阻塞方式实现*/
    fd1_save = fcntl(fd1,F_GETFL); 
    fcntl(fd1,F_SETFL,fd1_save|O_NONBLOCK);

    fd2_save = fcntl(fd2,F_GETFL); 
    fcntl(fd2,F_SETFL,fd2_save|O_NONBLOCK);

    fsm12.state = STATE_R;
    fsm12.sfd = fd1;
    fsm12.dfd = fd2;
    
    fsm21.state = STATE_R;
    fsm21.sfd = fd2;
    fsm21.dfd = fd1;

    epfd = epoll_create(10);
    if (epfd < 0 )
    {
        perror("epoll_create()");
        exit(1);
    }
    
    ev.events = 0;
    ev.data.fd = fd1;
    epoll_ctl(epfd,EPOLL_CTL_ADD,fd1,&ev);
    

    ev.events = 0;
    ev.data.fd = fd2;
    epoll_ctl(epfd,EPOLL_CTL_ADD,fd2,&ev);
    

    while (fsm12.state != STATE_T ||fsm21.state != STATE_T )
    {
        //布置监视任务
        //读集设置为空集
        ev.data.fd =fd1;
        ev.events = 0;


        //epoll_ctl(epfd,EPOLL_CTL_MOD);

        if (fsm12.state == STATE_R)
            ev.events |= EPOLLIN;
          
        if (fsm21.state == STATE_W)
            ev.events |= EPOLLOUT;

        epoll_ctl(epfd,EPOLL_CTL_MOD,fd1,&ev);
           

        ev.data.fd =fd2;
        ev.events = 0;
        if (fsm21.state == STATE_R)
           ev.events |= EPOLLOUT;
        if (fsm12.state == STATE_W)
           ev.events |= EPOLLIN;
           

        //监视
        if(fsm12.state<STATE_AUTO||fsm21.state<STATE_AUTO)
        {
            while(epoll_wait(epfd,&ev,1,-1)<0)
            {
                if (errno == EINTR)
                    continue;
                perror("epoll_wait()");
                exit(1);
            }

        }
        

        //查看监视结果

        if(ev.data.fd == fd1 &&ev.events &EPOLLIN\
        ||ev.data.fd == fd2&&ev.events&EPOLLOUT\
        ||fsm12.state > STATE_AUTO)
            fsm_driver(&fsm12);
        if(ev.data.fd == fd2 &&ev.events &EPOLLIN\
        ||ev.data.fd == fd2&&ev.events&EPOLLOUT\
        ||fsm12.state > STATE_AUTO)
            fsm_driver(&fsm21);   
    }

    /*恢复之前的状态*/
    fcntl(fd1,F_SETFL,fd1_save);
    fcntl(fd2,F_SETFL,fd2_save);

    close(epfd);
     
}

int main()
{
    int fd1,fd2;
    fd1 = open(TTY1,O_RDWR);
    if (fd1<0)
    {
        perror("open()");
        exit(1);
    }

    write(fd1,"TTY1\n",5);

    fd2 = open(TTY2,O_RDWR|O_NONBLOCK);
    if (fd2<0)
    {
        perror("open()");
        exit(1);
    }

    write(fd2,"TTY2\n",5);

    relay(fd1,fd2);
    close(fd2);
    close(fd1);
    
    exit(0);
}

3、其他读写函数

readv();//读写可以碎片化
writev();

readn();//unix的独家函数
writen();

4、存储映射IO

mmap() &&munmap()示例
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <sys/mman.h>

int main(int argc,char **argv)
{

    int fd,count=0;
    /*获取文件字节长度的结构体*/
    struct stat statres;

    char* str;

    if(argc<2)
    {
        fprintf(stderr,"Usage...\n");
        exit(1);
    }

    fd = open(argv[1],O_RDONLY);
    if (fd<0)
    {
        perror("open()");
        exit(1);
    }
    
    if (fstat(fd,&statres)<0)
    {
        perror("fstat()");
        exit(1);
    }

    str = mmap(NULL,statres.st_size,PROT_READ,MAP_SHARED,fd,0);
    if (str == MAP_FAILED)
    {
        perror("mmap()");
        exit(1);
    }
    close(fd);

    for (int  i = 0; i < statres.st_size; i++)
    {
        if (str[i] == 'a')
        count++;
    }
    printf("%d\n",count);
    
    munmap(str,statres.st_size);

    exit(1);
}
共享内存的实现
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <sys/mman.h>
#include <string.h>


#define MEMSIZE 1024 


int main(int argc,char **argv)
{
    char *ptr;

    pid_t pid;

    ptr =  mmap(NULL,MEMSIZE,PROT_READ|PROT_WRITE,MAP_SHARED|MAP_ANONYMOUS,-1,0);
    if (ptr == MAP_FAILED)
    {
        perror("mmap()");
        exit(1);
    }

    pid = fork();
    if (pid < 0)
    {
        perror("fork()");
        munmap(ptr,MEMSIZE);
        exit(1);
    }

    if (pid == 0)   //child write
    {
        strcpy(ptr,"hello!");
        munmap(ptr,MEMSIZE);    
        exit(0);
    }
    else            //parent read
    {
        wait(NULL);
        puts(ptr);
        munmap(ptr,MEMSIZE);    
        exit(0);
    }

}

5、文件锁

fcntl();
lockf();
flock();

lockf();示例 多进程取代多线程
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>

#define PROCNUM 20
#define FNAME "/tmp/out"  
#define LINESIZE 1024


char linebuf[LINESIZE];

static void  func_add(void)
{
    FILE *fp;
    int fd;

    fp = fopen(FNAME,"r+");
    if (fp == NULL)
    {
        perror("fopen()");
        exit(1);
    }
    
    fd = fileno(fp);

    lockf(fd,F_LOCK,0);
    fgets(linebuf,LINESIZE,fp);
    fseek(fp,0,SEEK_SET);
    sleep(1);
    fprintf(fp,"%d\n",atoi(linebuf)+1);
    fflush(fp);
    lockf(fd,F_ULOCK,0);
    fclose(fp);
}



int main()
{
    int err,i;
    pid_t pid;

    for ( i = 0; i < PROCNUM; i++)
    {
       fork();
       if (pid<0)
       {
           perror("fork()");
           exit(1);
       }
       if (pid == 0)
       {
           func_add();
           exit(0);
       }
   
    }

    for ( i = 0; i < PROCNUM; i++)
        wait(NULL);
    
    exit(0);
}
梅山剑客
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
linux下的C语言开发（开篇）
嵌入式-老费，一个分享专业嵌入式知识的blog
01-11 10万+
【 声明：版权所有，欢迎转载，请勿用于商业用途。  联系信箱：feixiaoxing @163.com】     在很多人的眼里，C语言和linux常常是分不开的。这其中的原因很多，其中最重要的一部分我认为是linux本身就是C语言的杰出作品。当然，linux操作系统本身对C语言的支持也是相当到位的。作为一个真正的程序员来说，如果没有在linux下面用C语言编写过完整的程序，那么只能说他对C
linux C应用开发
嵌入式分享
06-08 5256
linux应用开发
LinuxC应用开发学习笔记（三）--C语言
梅山
11-26 1087
函数 1、函数的定义 数据类型 函数名 （【数据类型 变量名 】） int i; 在main函数中，argc表示传递多少个参数，argv 表示传递的列表 ，字符指针数组的首地址 printf("hello!\n");//一个 进程的返回状态是给他的父进程看的， printf("argc = %d!",argc); for(i=0;i<=argc;i++) { puts(argv[i]); } return 0;//结束当前函数 2、函数的传参 值传递：不会改变互换的参数
LinuxC应用开发学习笔记（二）--C语言
梅山
11-23 3678
P30 数组 数组：构造类型之一，连续存放 int arr[M] = {1,2,3}; printf("%d\n",sizeof(arr)); printf("arr = %p\n",arr); //arr是个常量 不能无条件出现在等号左边。 for(int i=0;i<M;i++) { printf("%p-->%d\n",&arr[i],arr[i]); } int arr[] = {1,2,3,4,5,6}; printf("%d\n",sizeof(arr)
linux下c开发
hawkyxz的专栏
04-11 390
[size=large][b][align=center]第一章 编程语言、c语言简介[/align][/b][/size][b]程序语言的简单定义[/b] 什么是程序? 我们必须通过指令，指挥计算机执行我们想要做的动作。依照顺序执行一组指令就是程序。 程序的作用？指挥计算机干活。 程序的特征 程序是与计算机沟通的语言。 程序是由特定的语法与关键字构成。 程序是一行一行执行的。 程序...
linux编程学习笔记PDF资料下载.txt
07-17
根据提供的文件信息，我们可以推断出这是一份关于Linux编程学习笔记的PDF资料。下面将对这份资料可能涉及的关键知识点进行详细的阐述。 ### Linux编程基础知识 #### 1. Linux操作系统概述 - **定义与特点**：Linux...
Linux系统编程学习笔记
最新发布
02-07
### Linux系统编程学习笔记 #### 一、IO **1.1 标准I/O (stdio)** - **fopen/fclose**: `fopen` 用于打开或创建一个文件，并返回一个指向该文件的 `FILE *` 类型的指针。`fclose` 用于关闭由 `FILE *` 指向的文件...
GTK+ 图形化应用程序开发 学习笔记
04-02
这个“GTK+图形化应用程序开发学习笔记”包含了关于使用GTK+进行GUI编程的详细教程和实践案例。 GTK+的核心特性包括跨平台支持、丰富的组件库、强大的主题引擎以及对多种编程语言的绑定，如C、C++、Python、Vala等...
嵌入式系统开发笔记.zip
06-04
这份“嵌入式系统开发笔记”涵盖了从基础概念到高级技术的广泛内容，旨在帮助开发者深入理解并掌握这一领域。 一、嵌入式系统概述 嵌入式系统是嵌入在非计算机设备中的计算机系统，它们通常是为特定任务设计的，如...
Nodejs开发的学习笔记.rar
08-26
这份"Nodejs开发的学习笔记"涵盖了Node.js的基础到高级应用，是学习和掌握Node.js开发的重要参考资料。 一、Node.js基础 1. 安装与环境配置：介绍如何在不同的操作系统（Windows、MacOS、Linux）上安装Node.js，...
Linux下C语言开发(初学者) —— Hello world
qq_34260368的博客
10-10 2706
Linux下C语言开发 —— Hello world 环境 CentOS7 vmplay版本（因为免费） 百度 “如何在虚拟机安装lInux” 软件 gcc 目的：进行编译程序 安装： 使用 yum install gcc -y 即可 流程使用vim创建一个.C文件 vim hello.c 在里面和在windows平台一样的编辑方法 #inlcude <stdio.h> int mian ()
LinuxC应用开发学习笔记（九）——文件系统
梅山
12-28 800
主要介绍linux 文件系统相关内容，包括文件属性，文件访问权限，文件信息等，并且举例多种示例代码解释文件属性信息。
第一章-Linux下C语言开发环境
Shirleyyyyyyy的博客
07-10 236
分析和替换。
Linux系统编程（二）进程控制编程
红叶的博客
08-17 279
进程的定义：进程是一个具有一定独立功能的程序的一次运行活动，同时也是资源分配的最小单元 程序是指放到磁盘的可执行文件 进程是指程序执行的实例 （./xxx） 进程与程序的区分： 进程是动态的，程序是静态的：程序是有序代码的集合；进程是程序的执行。通常进程不可在计算机之间迁移；而程序通常对应着文件、静态和可以复制 进程是暂时的，程序使长久的：进程是一个状态变化的过程，程序可长久保存 进程与程序组成不...
Linux系统编程（三）进程间通信
红叶的博客
08-18 372
进程间通信概述 1.数据传输 一个进程需要将它的数据发送给另一个进程 2.资源共享 多个进程之间共享同样的资源 3.通知事件 一个进程需要向另一个或一组进程发送消息，通知它们发生了某种事件 4.进程控制 有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有操作，并能够及时知道它的状态改变 现在Linux使用的进程间通信方式包括： 1、管道（pipe）和...
一些函数的头文件<stdio.h><unistd.h><sys/types.h><stdlib.h><sys/wait.h>头文件的作用
u013176681的专栏
08-22 2760
不用说，大家都懂得，就是一堆输入输出
课堂笔记七之Linux进程控制编程
qq_46413242的博客
04-14 556
fprintf（格式化输出数据至文件） 表头文件：#include <stdio.h> 定义函数： int fprintf（FILE * stream，const char *format，…）； 函数说明： fprintf()会根据参数format字符串来转换并格式化数据，然后将结果输出到参数steam指定的文件中，直到出现字符串结束（‘、0’）为止。 返回值：成功则返回实际输出的字...
LinuxC应用开发学习笔记（八）—系统调用I/O
梅山
12-21 985
UNIX环境高级编程（APUE） 文件系统 四、六、七章 I/0 3-5章、14章 文件I/O 标准I/O 并发 信号10章节 多进程并发 多线程并发10-11章节 IPC：进程间通信 8章节 进程基础（涉及到多进程） 13章 守护进程 15-16章 注意事项： 1、弃用root用户 2、重构代码 3、课堂重点：项目，课堂代码，面试题，实验性题目，推荐书籍课后题 I/O：input & output，是一切实现的基础 标准io：stdio 依赖于sysio 系统调用io：sysio（文件IO） 优先
Linux的C开发环境
似水流年
08-19 1265
Linux的C开发环境 Linux的操作系统内核主要是由C编写，Linux下的很多软件也是由C编写的，比如MySQL、Apache等。初学者在编译这样的软件时，会遇到过各种错误，只要初步了解了Linux的C开发环境，就能自选解决安装过程中的一些错误。    3.1.1 Linux的C开发工具包  Linux的C开发环境与Windows的有所不同，在Linux下，一个完整的C开发环境包括以下
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值