C语言：高级IO

于 2024-08-10 14:30:17 发布
阅读量430 收藏 19
点赞数 22
文章标签： c语言 java 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58233509/article/details/140244640
版权

非阻塞IO和阻塞IO

man手册7章是在将机制。

------- EINTR：（error interrupt）是阻塞的系统调用，动作非常的慢，这个过程被信号打断了，但并不是操作失败，故是个假错。

----------EAGAIN.(error again) 是非堵塞的调用，表示，尝试去做了，但是现在没有数据，并不是真的出错了（并不是当前系统调用函数的问题）。

有限状态机编程

简单流程：一个程序的自然流程是结构化的就叫简单流程。
复杂流程：一个程序的自然流程是非结构化的就叫简单流程。

relay.c

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

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

#define BUFSIZE 1024

enum
{
    STATE_R = 1, //读态
    STATE_W = 2, // 写态
    STATE_Ex, // 异常态
    STATE_T  //结束态
};
struct fsm_st
{
    int state;
    int sfd;
    int dfd;
    char buf[BUFSIZE];
    int len;
    int pos;
    char *errstr;
};

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 = "write()";
                    fsm->state = STATE_Ex;
                }
            }
            else
            {
                fsm->len -= ret;
                fsm->pos += 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;
    }
}
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); //以非堵塞形式打开

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

    close(fd1);
    close(fd2);

    return 0;
}

在虚拟机中使用Ctrl+Alt+ F11  切换11终端设备。12同理。

 可以使用dia工具进行绘图，类似于windows下的Visio。

非阻塞IO

man.c

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

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

#define TTY3 "/dev/tty10"
#define TTY4 "/dev/tty9"

#define BUFSIZE 1024


int main()
{
    int fd1,fd2;
    int job1;

    fd1 = open(TTY1,O_RDWR);
    if(fd1< 0)
    {
        perror("open()");
        exit(1);
    }
    write(fd1,"TTY1\n",5);
    fd2 = open(TTY2,O_RDWR|O_NONBLOCK); //以非堵塞形式打开

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

    int fd3,fd4;
    int job2;
    fd3 = open(TTY3,O_RDWR);
    write(fd3,"TTY3\n",5);
    fd4 = open(TTY3,O_RDWR);
    write(fd4,"TTY4\n",5);
    job2 =rel_addjob(fd3,fd4);
    while(1);

    close(fd1);
    close(fd2);

    close(fd3);
    close(fd4);
    return 0;
}

relayer.c

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

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

#define BUFSIZE 1024

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;

enum
{
    STATE_R = 1, //读态
    STATE_W = 2, // 写态
    STATE_Ex, // 异常态
    STATE_T  //结束态
};
struct rel_fsm_st
{
    int state;
    int sfd;
    int dfd;
    char buf[BUFSIZE];
    int len;
    int pos;
    char *errstr;
	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;
//	struct timerval start,end;
};


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 = "write()";
                    fsm->state = STATE_Ex;
                }
            }
            else
            {
                fsm->len -= ret;
                fsm->pos += 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;
    }
}
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);
	}
	return NULL;
}
//moudle_unload

void moudle_load(void)
{
	pthread_t tid_relayer;
	int err;
	err = pthread_create(&tid_relayer,NULL,thr_relayer,NULL);
	
}
int get_free_pos_unlocked()
{
    for(int 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,moudle_load);

	me = malloc(sizeof(*me));
	if(me == NULL)
		return -ENOMEM;
	me->fd1 = fd1;
	me->fd2 = fd2;
	me->job_state = STATE_RUNNING;
	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;
	int pos;

	pthread_mutex_lock(&mut_rel_job);
	pos = 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;

}

 relayer.h

#ifndef RELAYER_H
#define RELAYER_H

#define REL_JOBMAX 10000

enum
{
	STATE_RUNNING= 1,
	STATE_CANCELED,
	STATE_OVER
};
struct rel_stat_st
{
	int status;
	int fd1;
	int fd2;
	int64_t count12,count21;

//	struct timeval start,end;

};
int rel_addjob(int fd1,int fd2);
/*
	return >=0			成功，返回当前任务的ID
		   == -EINVAL   失败，参数非法
		   == -ENOSPC	失败，任务数组满
		   == -ENOMEM	失败，内存分配有误
*/
#if 0
int rel_canceljob(int id);
/*
	return == 0			成功，指定任务取消成功
		   == -EINVAL	失败，参数非法
		   == -EBUSY	失败，任务已经被取消
*/

int rel_waitjob(int id,struct rel_stat_st*);
/*
	return == 0			成功，指定任务已经终止并返回状态
		   == -EINVAL	失败，参数非法
*/

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



#endif




#endif

makefile

CFLAGS += -pthread
LDFLAGS += -pthread

all:relayer

relayer:relayer.o main.o
	gcc $^ -o $@ $(CFLAGS)

clean:
	rm -rf *.o relayer

IO多路转接

监视文件描述符行为，要是有了改变就做后续操作。select poll epoll


       int select(int nfds, fd_set *readfds, fd_set *writefds,
                  fd_set *exceptfds, struct timeval *timeout); //古老，移植性好，数组实现。以事件为单位。
       int poll(struct pollfd *fds, nfds_t nfds, int timeout); // 链表实现。以文件为单位组织事件。
        epoll() //linux下的方言，epoll可以简化用户使用，不可以移植，底层是红黑树。

select

可以实现安全的休眠。

  void FD_CLR(int fd, fd_set *set); 从集合中删除
       int  FD_ISSET(int fd, fd_set *set);判断fd是否存在在set
       void FD_SET(int fd, fd_set *set); 将fd加入set中。
       void FD_ZERO(fd_set *set); 清空文件描述符
第一 参数ndfs是目前最大文件描述符+1，第二参数：读集合 第三参数：写集合 
第四参数：异常集合  第五个参数：超时设置。返回值：成功返回文件描述符个数。失败返回-1设置error.超时返回EINTR假错。

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

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

#define BUFSIZE 1024

enum
{
    STATE_R = 1, //读态
    STATE_W = 2, // 写态
    
    STATE_AUTO,

    STATE_Ex, // 异常态
    STATE_T  //结束态
};
struct fsm_st
{
    int state;
    int sfd;
    int dfd;
    char buf[BUFSIZE];
    int len;
    int pos;
    char *errstr;
};

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 = "write()";
                    fsm->state = STATE_Ex;
                }
            }
            else
            {
                fsm->len -= ret;
                fsm->pos += 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;
    }
}
int max(int fd1,int fd2)
{
    if(fd1>fd2)
        return fd1;
    return fd2;
}

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)
    {
        //布置监视任务，
        fd_set rset,wset;
        FD_ZERO(&rset);
        FD_ZERO(&wset);
        if(fsm12.state == STATE_R)
            FD_SET(fsm12.sfd,&rset);
        if(fsm12.state == STATE_W)
            FD_SET(fsm12.dfd,&wset);

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

        //监视
        if(fsm12.state <STATE_AUTO  || fsm21.state <STATE_AUTO )
        {
        int num;
        num = select(max(fd1,fd2)+1,&rset,&wset,NULL,NULL); //忙等
        if(num<0)
        {
            if(num == 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) || fsm21.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); //以非堵塞形式打开

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

    close(fd1);
    close(fd2);

    return 0;
}

缺点：
        1.古老，每次出错都会清空原来内容。 
        2. 监听文件描述符个数要是超出最大值会溢出。
优点：
        1.移植性好。
        2.方便上手。

poll

以文件描述符为单位组织事件。

       int poll(struct pollfd *fds, nfds_t nfds, int timeout);

第一个参数：结构体数组的起始地址。第二个参数：数组的总数量。第三个参数：超时设置（0非堵塞，-1堵塞，其他超时时间）。

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

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

#define BUFSIZE 1024

enum
{
    STATE_R = 1, //读态
    STATE_W = 2, // 写态
    
    STATE_AUTO,

    STATE_Ex, // 异常态
    STATE_T  //结束态
};
struct fsm_st
{
    int state;
    int sfd;
    int dfd;
    char buf[BUFSIZE];
    int len;
    int pos;
    char *errstr;
};

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 = "write()";
                    fsm->state = STATE_Ex;
                }
            }
            else
            {
                fsm->len -= ret;
                fsm->pos += 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;
    }
}
int max(int fd1,int fd2)
{
    if(fd1>fd2)
        return fd1;
    return fd2;
}

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;
    
    struct pollfd pfd[2];
    pfd[0].fd = fd1;
    pfd[1].fd = fd2;

    while( fsm12.state != STATE_T || fsm21.state != STATE_T)
    {
        //布置监视任务，
        pfd[0].events = 0;
        pfd[1].events = 0;

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

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

        //监视
        if(fsm12.state <STATE_AUTO  || fsm21.state <STATE_AUTO )
        {
        int num;
        num = poll(pfd,2,-1); 
        while(num<0)
        {
            if(num == EINTR)
                continue;
            perror("select()");
            exit(1);
        }
        }
        //查看监视结果
        
        //根据结果推状态机
        if(pfd[0].revents & POLLIN || pfd[1].revents & POLLOUT || fsm12.state >STATE_AUTO)
            fsm_driver(&fsm12);
        if(pfd[0].revents & POLLOUT || pfd[1].revents & POLLIN || 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); //以非堵塞形式打开

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

    close(fd1);
    close(fd2);

    return 0;
}

epoll 

不方便移植。epoll相当于系统给你管理。

        int epoll_create(int size);//返回文件描述符
       int epoll_create1(int flags);
       int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
      int epoll_wait(int epfd, struct epoll_event *events,
                      int maxevents, int timeout);
       int epoll_pwait(int epfd, struct epoll_event *events,
                      int maxevents, int timeout,
                      const sigset_t *sigmask);

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

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

#define BUFSIZE 1024

enum
{
    STATE_R = 1, //读态
    STATE_W = 2, // 写态
    
    STATE_AUTO,

    STATE_Ex, // 异常态
    STATE_T  //结束态
};
struct fsm_st
{
    int state;
    int sfd;
    int dfd;
    char buf[BUFSIZE];
    int len;
    int pos;
    char *errstr;
};

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 = "write()";
                    fsm->state = STATE_Ex;
                }
            }
            else
            {
                fsm->len -= ret;
                fsm->pos += 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;
    }
}
int max(int fd1,int fd2)
{
    if(fd1>fd2)
        return fd1;
    return fd2;
}

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;

    int epfd;
    epfd = epoll_create(10);
    if(epfd <0)
    {
        perror("epoll_create()");
        exit(1);
    }
    struct epoll_event ev;
    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;

        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(fsm12.state == STATE_R)
            ev.events |= EPOLLOUT;    
        if(fsm21.state == STATE_W)
            ev.events |= EPOLLIN;

        //监视
        if(fsm12.state <STATE_AUTO  || fsm21.state <STATE_AUTO )
        {
        int num;
        num = epoll_wait(epfd,&ev,1,-1); 
        while(num<0)
        {
            if(num == 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 == fd1 && (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); //以非堵塞形式打开

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

    close(fd1);
    close(fd2);

    return 0;
}

其他读写函数

     #include <sys/uio.h>

       ssize_t readv(int fd, const struct iovec *iov, int iovcnt);

       ssize_t writev(int fd, const struct iovec *iov, int iovcnt);

       struct iovec {
               void  *iov_base;    /* Starting address */
               size_t iov_len;     /* Number of bytes to transfer */
           };
操作对象不是完整的空间，将多个碎片空间写到同一个文件中。

        readn()
        writen()  
        Linux环境高级编程书中，自己实现的内容，unix标准没有。

存储映射IO

    #include <sys/mman.h>

       void *mmap(void *addr, size_t length, int prot, int flags,
                  int fd, off_t offset);
       int munmap(void *addr, size_t length);

mmap.c

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

int main(int argc,char*argv[])
{
    if(argc<2)
    {
        printf("Usage...\n");
        exit(1);
    }
    int fd = open(argv[1],O_RDONLY);
    struct stat statres;

    if(fstat(fd,&statres)< 0)
    {
        perror("fstat()");
        exit(1);
    }
    char*str;
    str = mmap(NULL,statres.st_size,PROT_READ,MAP_SHARED,fd,0); //内存映射
    if(str == MAP_FAILED)
    {
        perror("mmap");
        exit(1);
    }
    close(fd);
    int count = 0;
    for(int i=0;i<statres.st_size;i++)
    {
        if(str[i]=='a')
            count++;
    }
    printf("count = %d\n",count);
    
    munmap(str,statres.st_size);
    
    return 0;
}

shm.c

mmap实现父子进程通信 （共享内存）

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

int main(int argc,char*argv[])
{
    if(argc<2)
    {
        printf("Usage...\n");
        exit(1);
    }
    int fd = open(argv[1],O_RDONLY);
    struct stat statres;

    if(fstat(fd,&statres)< 0)
    {
        perror("fstat()");
        exit(1);
    }
    char*str;
    str = mmap(NULL,statres.st_size,PROT_READ,MAP_SHARED,fd,0); //内存映射
    if(str == MAP_FAILED)
    {
        perror("mmap");
        exit(1);
    }
    close(fd);
    int count = 0;
    for(int i=0;i<statres.st_size;i++)
    {
        if(str[i]=='a')
            count++;
    }
    printf("count = %d\n",count);
    
    munmap(str,statres.st_size);
    
    return 0;
}

文件锁

fcntl

lockf

flock

设置空洞文件进行多线程下载时，可以用文件锁来锁文件。（两个文件同时打开，关闭会导致文件意外解锁的情况）

add.c 

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>
#include <sys/wait.h>

#define FILENAME  "/tmp/out"
#define PROCNUM (20)


void func_add(void);

int main()
{
    pid_t pid;
    int i,j,mark;
    int err; 
    for(i =0;i<PROCNUM;i++)
    {
        pid = fork();
        if(pid ==0)
        {
            func_add();
            exit(0);
        }
        if(pid >0)
        {

        }
    }

    for(i=0;i<PROCNUM;i++)
    {
        wait(NULL);
    }
    return 0;
}

void func_add()
{
    FILE*fp;
    char line_buf[1024];
    int len_size = 1024;

    puts("Begin");

    fp = fopen(FILENAME,"r+");

    int fd = fileno(fp);
    lockf(fd,F_LOCK,0);//全部锁文件

    fgets(line_buf,len_size,fp);
    
    fseek(fp,0,SEEK_SET);

    sleep(1);

    fprintf(fp,"%d \n",atoi(line_buf)+1);

    fflush(fp);
    lockf(fd,F_ULOCK,0);

    fclose(fp);
    puts("End");
 }

管道简单实现

mypipe.c

#include <stdlib.h>
#include <stdio.h>
#include <pthread.h>

#include "mypipe.h"

struct mypipe_st
{
    int head;
    int tail;
    char data[PIPESIZE];
    int datasize;
    int count_rd;
    int count_wr;

    pthread_mutex_t mut;
    pthead_cond_t cond;

};

mypipe_t* mypipe_init(void )
{
    struct mypipe_st*me;
    me = malloc(sizeof(*me));
    if(me ==NULL)
    {
        return me;
    }
    me->head = 0;
    me->tail = 0;
    me->datasize = 0;
    me->count_rd = 0;
    me->cound_wr = 0;

    pthread_mutex_init(&me->mut,NULL);
    pthread_cond_init(&me->cond,NULL);
    return me;
}

int mypipe_register(mypipe_t*ptr,int opmap)
{
    /*if err*/

    struct mypipe_st *me = ptr;
    pthread_mutex_lock(&me->mut);
    if(opmap & MYPIPE_READ)
    {
        me->count_rd++;
    }
    if(opmap & MYPIPE_WRITE)
    {
        me->count_wr++;
    }
    pthread_cond_broadcast(&me->cond);//叫醒其他等待的线程。

    while(me->count_rd <=0 || me->count_wr <= 0)
    {
        pthread_cond_wait(&me->cond,&me->mut);

    }
    pthread_mutex_unlock(&me->mut);
    return 0;
    
}
int mypipe_unregister(mypipe_t*ptr,int opmap)
{
    struct mypipe_st*me = ptr;
    pthread_mutex_lock(&me->mut);
    
    if(opmap & MYPIPE_READ)
    {
        me->count_rd--;
    }
    if(opmap & MYPIPE_WRITE)
    {
        me->count_wr--;
    }
    pthread_cond_broadcast(&me->cond);//叫醒其他等待的线程。
    
    pthread_mutex_unlock(&me->mut);
}

mypipe_readbyte_unlocked(struct mypipe_t*me,char*datap)
{
    if(me->datasize<=0)
        return -1;
        
    *datap = me->data[me->head];
    me->head = next(me->head);
    me->datasize --;
    return 0;
}
int mypipe_read(mypipe_t*ptr,void*buf,size_t count)
{
    struct mypipe_st*me = ptr;
    int i;
    pthread_mutex_lock(&me->mut);
    while(me->datasize<=0 && me->count_wr >0 )
    {
        pthread_cond_wait(&me->cond,&me->mut);
    }
    if(me->datasize<=0 && me->count_wr <=0)
    {
        pthread_mutex_unlock(&me->mut);
        return 0; //没有数据，没有写者就退出。
    }

    for( i=0;i< count;i++)
    {
        int ret;
        ret = mypipe_readbyte_unlocked(me,buf+i);
        if(ret != 0)
        {
            break;
        }
    }
    pthread_cond_broadcast(&me->cond);
    pthread_mutex_unlock(&me->mut);

    return i;
}

int mypipe_write(mypipe_t*ptr,const void*buf,size_t count)
{

}

int mypipe_destroy(mypipe_t* ptr)
{
    struct mypipe_st*me;
    me = ptr;
    pthread_mutex_destroy(&me->mut);
    pthread_cond_destroy(&me->cond);
    free(ptr);

    return 0;
}

mypipe.h

#ifndef MYPIPE_H
#define MYPIPE_H

#define  PIPESIZE 1024
#define MYPIPE_READ  0x00000001UL
#define MYPIPE_WRITE 0x00000002UL

typedef void mypipe_t;

mypipe_t* mypipe_init(void );

int mypipe_register(mypipe_t*,int opmap);

int mypipe_unregister(mypipe_t*,int opmap);

int mypipe_read(mypipe_t*,void*buf,size_t count);

int mypipe_write(mypipe_t*,const void*buf,size_t count);

int mypipe_destroy(mypipe_t* );

#endif

only-lucky
关注
  • 22
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【linux环境高级编程】第1篇：标准IO操作
黑猫奥利奥的博客
10-30 151
1 前言 1.1 声明 本文根据个人工作经验及部分网络资料整理而成，如有错误请留言。 文章为个人辛苦整理，付费内容，禁止私自转载。 文章所在专栏：《黑猫带你学：嵌入式C语言》 1.2 参考链接 标准IO：常用函数集合（写的很不错，墙裂推荐查看）：https://www.cnblogs.com/ye-long/p/7202655.html 标准IO库详解及实例：https://www.cnblogs.com/noticeable/p/8476036.html C 标准库 - <stdio.h>
C语言基础IO.rar
08-21
6. **高级IO操作** - `fseek()`和`ftell()`：用于移动文件指针的位置和获取当前位置。 - `rewind()`：将文件指针重新定位到文件开头。 - `feof()`和`ferror()`：用于检查文件读写是否遇到文件结束或错误。 理解...
LinuxC：高级IO
weixin_48874444的博客
06-02 68
1、非阻塞IO2、IO多路转接3、其他读写函数4、存储映射IO5、文件锁。
C语言：从入门到进阶笔记（完整版）
热门推荐
有道无术, 术尚可求。有术无道, 止于术。
01-17 1万+
本系列适合已经接触过C语言或对C语言有基本的了解的读者观看，适合用来复习巩固和夯实基础。共18大章，每个章节分为若干个小节，部分章节备有配套的练习，并且本系列附带了三套C语言笔试题以及答案详细解析。第一章由于字数原因，以贴链接的方式展示。由于作者水平有限、时间仓促紧迫，本教学有错误和不准确之处在所难免，本人也很想知道这些错误，恳望读者批评指正！从第一章博客的更新到最后一章共历时四个月，难免会有排版、代码风格、图标运用的不一致的地方，还请谅解。文章内有很多表情包，目的是让读者在阅读过程中减少枯燥，并且有些表情
C语言高级操作（二）——文件IO与目录IO
weixin_44463519的博客
03-20 400
本章详细描述了文件IO与目录IO，后续可能会给出更多练习源码
c语言从随机数中显示最大数,c语言： 生成随机数
weixin_34079693的博客
05-18 923
#include srand((unsigned)time(NULL));for(int i=0;i<10;i++){//printf("%d\n",rand()); //生成的最大数：32767printf("%d\n",(int)((double)rand() / RAND_MAX * 9999999)); //这样就能生成一个很大的随机数}rand()%100；产生0-99的随机数。...
C语言:fopen与open的总结
岁月求索
05-05 806
目录 QUESTION:fopen与open的总结? ANSWER: 1.非缓冲文件系统 2.缓冲文件系统 3.具体区别 QUESTION:fopen与open的总结? ANSWER: 1.非缓冲文件系统 缓冲文件系统是借助文件结构体指针来对文件进行管理，通过文件指针来对文件进行访问，既可以读写字符、字符串、格式化数据，也可以读写二进制数 据。非缓冲文件系...
C语言中的标准IO
升级打怪记录
12-29 1158
本文对 Linux 下C语言的标准IO进行总结，所有代码示例均在 Ubuntu-20.04、GCC 11.3.0 环境下运行通过。
io口控制实验c语言程序,c语言io高级编程实验 2010高级语言程序设计实验任务书.doc...
weixin_30334411的博客
05-17 52
c语言io高级编程实验 2010高级语言程序设计实验任务书.docc语言io高级编程实验 2010高级语言程序设计实验任务书导读：就爱阅读网友为您分享以下“2010高级语言程序设计实验任务书”的资讯，希望对您有所帮助，感谢您对92的支持!if ( mark=-1)break;n ++ ;sum=sum + mark ;if( mark > max )max = mark ;if( mark ...
零基础学C语言——文件IO
weixin_40960130的博客
12-27 841
本文详细介绍了C语言的标注I/O功能
C语言高级-进程篇1
m0_52884709的博客
03-07 507
C语言中父进程如何创建、回收进程，进程的退出，exec函数族的使用，如何通过C语言创建一个守护进程。
c-tutorial-main C语言入门教程 IO 进程内存线程并发
01-13
C语言是一种广泛应用于系统编程、嵌入式开发、软件工程等多个领域的高级编程语言。它的语法简洁、效率高，是学习计算机编程的基石。本教程主要针对C语言的基础知识，包括输入/输出（IO）、进程、内存管理和线程并发...
C语言5：将 P1口状态分别送入P0、P2、P3口：认识IO口的引脚功能.rar
11-29
C语言在嵌入式编程中被广泛使用，因为它提供了高级抽象，同时允许直接访问硬件资源。在处理I/O口时，我们需要使用特定的库函数或直接操作寄存器。对于P1口状态的读取，我们通常会访问与该端口相关的数据寄存器；而...
C_example.zip_C语言_HOLTEK C_holtek_holtek C语言_io
09-22
本篇文章将深入探讨“C_example.zip”这个压缩包中的知识点，主要围绕“C语言”，“HOLTEK C”，以及“HOLTEK C语言IO”。 C语言是基础且强大的编程语言，它的语法简洁，效率高，适用于操作系统、驱动程序、游戏...
单片机C语言实例IO输出-点亮多个LED灯方法2.zip
12-14
总之，这个教程旨在教授如何使用C语言在单片机上通过IO端口控制LED灯，不仅涵盖了基础的硬件连接，还可能包括了高级的编程技巧和控制策略。通过学习和实践，开发者能够更好地理解和掌握单片机的IO操作，为更复杂的...
浅谈C/C++指针和引用在Linux和Windows不同环境下的编码风格
最新发布
2301_80868191的博客
08-10 294
本文中介绍了关于C/C++中指针变量和引用变量在不同开发环境下的不同代码风格，解释了为什么C/C++语言会有各种各样不同类型风格的代码。
#include “ascii_font.c“ 引入源文件，Keil5为什么没有提示重复定义错误，详解！！！
weixin_62292999的博客
08-10 517
h头文件处理方式，这个文件通常用于声明函数，变量和宏定义，这个文件不会被编译器，编译而是通过 #include预处理指令，引入在.c文件中包含， 在.c文件中 #include "ascii_font.c" 编译器会将 ascii_font.c 的内容直接插入到，使用#include调用的文件中。同时，#include .h文件，在其他.c文件中，是为了告诉编译器，这个函数声明的存在，但是这里只有声明没有实现部分，在连接阶段，编译器会结合两个.c文件的内容，这样有了声明也有了实现，就能正常调用函数。
C++ - 函数重载
jiaowenjie的专栏
08-06 318
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
Spring事务
c1tenj2的博客
08-07 430
以银行转账为例，一次转账操作伴随着一个账户的扣钱和另一个账户的加钱，这个流程是一个原子操作，要么同时发生，一气呵成，要么都不做。AccountServiceImpl实现AccountService接口，里面只有一个转账方法AccountMapper以及其映射文件account数据库测试代码用1/0模拟程序运行时出现异常的情况由于没有开启事务，出现了莫名其妙少了100块钱的情况，说明这个事务不是连续的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值