1.带有缓存的getchar实现。
getchar每次从文件获取一个字符,这样显得很没有效率,因为每读一个字符计算机都要读一次磁盘,而读磁盘的速度是很慢的。getchar实际上在函数内部声明了一个静态字符缓冲区(字符数组),首次调用getchar,getchar一次性读入n个字符,但每次函数只返回一个字符,只有缓冲区为空(n次getchar调用)之后才需要再次从文件中读取n个字符。这样n次调用只需要读取一个文件,效率大大提高。我们来看看具体怎么实现吧!
int getchar(int fd,char *c)
{//返回-1表示读取失败或者文件结束,1表示正常读取返回
static int len = 0;
static char buf[1024];
char* ptr;
if(len <= 0){
again:if((len = read(fd,buf,sizeof(buf)) < 0)
{
if(errno == EINTR)
goto again;//read阻塞时程序中断处理应该重新读文件
return -1;
}else if(len == 0)
{//读取0个字节表示读取到文件结束了
return -1;
}
ptr = buf;
}else
{
*c = *ptr++;
len --;
}
return 1;
}
2.遍历目录树
//interface to be learned are:DIR* opendir(const char*);struct dirent* readdir(DIR*);int closedir(DIR*);int stat(const char*,struct stat*);
//and stl queue;
#include <iostream>
#include <cstring>
#include <queue>
#include <dirent.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <cstdlib>
#include <cstdio>
#include <cerrno>
using namespace std;
char path_max[1024];
void walkDir(const char *path)
{
queue<char*> q;
struct stat statbuf;
struct dirent *ent;
int fcount,dcount,ocount;
char *p = new char[strlen(path)+1];//easy to make mistake here for rookies,must be strlen+1
strcpy(p,path);
q.push(p);
fcount = dcount = ocount = 0;
dcount++;
while(!q.empty())
{//all file in q is directory
p = q.front();
q.pop();
DIR *dir = opendir(p);
if(!dir){perror("opendir:");exit(-1);}
while((ent = readdir(dir)) != NULL)
{
if(strcmp(ent->d_name,".") == 0 || strcmp(ent->d_name,"..") == 0)//escape .. directory to avoid infinite loop
continue;
strcpy(path_max,p);
strcat(path_max,"/");
strcat(path_max,ent->d_name);
if(lstat(path_max,&statbuf) < 0)//use lstat instead of stat to avoid infinite loop because a link may point to his ancester directory
{
printf("%s:%s \n",path_max,strerror(errno));
exit(-1);
}
if((statbuf.st_mode&S_IFMT) == S_IFREG)
{
fcount++;
cout<<"file:"<<path_max<<" size:"<<statbuf.st_size<<endl;
}
else if((statbuf.st_mode&S_IFMT) == S_IFDIR)
{
char* p = new char[strlen(path_max)+1];//easy to make mistake here for rookies,must be strlen+1
strcpy(p,path_max);
q.push(p);
cout<<"dir:"<<p<<endl;
dcount++;
}
else if((statbuf.st_mode & S_IFMT) == S_IFLNK)
{
cout<<"link:"<<path_max;
ssize_t s;
if((s = readlink(path_max,path_max,sizeof(path_max)))<0)
{printf("%s\n",strerror(errno));exit(-1);}
path_max[s] = 0;
cout<<" to "<<path_max;
ocount ++;
}else
{
cout <<"other:"<<path_max<<endl;
ocount++;
}
}
closedir(dir);//remember to closedir or "too much open error" will occur
delete []p;//release the member
}
cout<<"files:"<<fcount<<' '<<"dirs:"<<dcount<<' '<<"other:"<<ocount<<endl;
}
3.实现简单的具备重定向的shell程序
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <fcntl.h>
char *arg[10];
int main(int argc,char* argv[])
{
int i,status;
char *saveptr;
char buf[80];
char *p = NULL,*q;
int fd,infd,outfd;
pid_t pid;
i = 0;
infd = STDIN_FILENO;outfd = STDOUT_FILENO;//如果发生重定向infd和outfd用来保存标准输入输出的内核文件结构
while(1)
{
fprintf(stderr,"[My Shell]#");
fgets(buf,80,stdin);
printf("%s",buf);
i = 0;
p = buf;
while((p = strtok_r(p," \n",&saveptr)))
{//处理命令参数,must add '\n' as a delimiter or one of the token will include '\n' which leads to error
if((q = strchr(p,'<')))
{
if((fd = open(q+1,O_RDONLY)) < 0){perror("open:");exit(-1);}
infd = dup(STDIN_FILENO);//复制标准输入的内核文件结构
dup2(fd,STDIN_FILENO);//重定向
close(fd);
p = NULL;
continue;
}
if((q = strchr(p,'>')))
{
//printf("%s\n",q+1);
if((fd = open(q+1,O_WRONLY|O_CREAT|O_TRUNC,0664)) < 0)
{//文件存在则打开并清空文件,否则创建文件,权限为0664
perror("open:");
exit(-1);
}
outfd = dup(STDOUT_FILENO);//复制标准输入的内核文件结构
dup2(fd,STDOUT_FILENO);//重定向
close(fd);
p = NULL;
continue;
}
arg[i++] = p;
p = NULL;
}
arg[i] = NULL;
pid = fork();
if(pid > 0)
{
wait(&status);
/*如果标准输入输出被重定向了,必须修改STDIN_FILENO和STDOUT_FILENO回标准输入输出*/
if(infd != STDIN_FILENO){dup2(infd,STDIN_FILENO);close(infd);infd = STDIN_FILENO;}
if(outfd != STDOUT_FILENO){dup2(outfd,STDOUT_FILENO);close(outfd);outfd = STDOUT_FILENO;}
}
else if(pid == 0)
{
if(execvp(arg[0],arg)<0)
{
perror("execvp:");
exit(-1);
}
}
else{perror("fork:");exit(-1);}
}
}
4.linux信号处理
#include <signal.h>
#include <unistd.h>
#include <stdio.h>
//信号集的处理sigdelset,sigaddset,sigemptyset,sigfillset,sigismember;
//信号屏蔽字设置sigprocmask
//信号处理函数设置sigaction,信号处理函数类型void (*sa_handler)(int);
void alarm_handle(int sig)
{
printf("awaked!\n");
}
unsigned int mysleep(unsigned int seconds)
{
struct sigaction action,oaction;
sigset_t nset,oset;
action.sa_handler = alarm_handle;
action.sa_flags = 0;
sigemptyset(&action.sa_mask);
sigemptyset(&nset);
sigaddset(&nset,SIGALRM);//屏蔽SIGALRM信号
sigprocmask(SIG_BLOCK,&nset,&oset);
sigaction(SIGALRM,&action,&oaction);
alarm(seconds);//设置闹钟
nset = oset;
sigdelset(&nset,SIGALRM);//开放SIGALARM信号
sigaddset(&nset,SIGINT);//屏蔽SIGINT信号
sigsuspend(&nset);//等待信号发生
sigaction(SIGALRM,&oaction,NULL);//恢复原来信号处理函数
sigprocmask(SIG_SETMASK,&oset,NULL);//恢复原来信号掩码
return alarm(0);
}
5.生产者消费者问题,线程同步练习
#include <pthread.h>
#include <stdio.h>
#include <semaphore.h>
#include <unistd.h>
#include <stdlib.h>
#define NUM 10 //定义循环缓冲区大小为10
struct MyBuf
{
int r,w;
int buf[NUM];
pthread_mutex_t rlock,wlock;
sem_t spaceleft,productleft;
};//buf为缓冲区rlock为读指针r的互斥锁,wlock为写指针w的互斥锁,spaceleft,productleft为可用空间和产品数的信号量
struct ThreadAttr{
struct MyBuf *b;
int n;
};//传给thread的参数结构
void initMyBuf(struct MyBuf *b)
{
b->r = b->w = 0;
pthread_mutex_init(&b->rlock,NULL);
pthread_mutex_init(&b->wlock,NULL);
sem_init(&b->spaceleft,0,NUM);
sem_init(&b->productleft,0,0);
}
void destroyMyBuf(struct MyBuf* b)
{
pthread_mutex_destroy(&b->rlock);
pthread_mutex_destroy(&b->wlock);
sem_destroy(&b->spaceleft);
sem_destroy(&b->productleft);
}
void produceProducts(struct MyBuf *b,int n)
{//生产n个产品,放入struct MyBuf里面
for(int i = 0;i < n;i++)
{
sem_wait(&b->spaceleft);
pthread_mutex_lock(&b->wlock);
b->w = b->w%NUM;
b->buf[b->w++] = (int)pthread_self();
printf("%d add \n",(int)pthread_self());
pthread_mutex_unlock(&b->wlock);
sem_post(&b->productleft);
sleep(rand()%3);
}
}
void* producer(void *taddr)
{
struct ThreadAttr* taddr2 = (struct ThreadAttr*)taddr;
produceProducts(taddr2->b,taddr2->n);
return (void*)1;
}
void consumeProducts(struct MyBuf* b,int n)
{//消费n个产品,放入struct MyBuf里面
for(int i = 0;i < n;i++)
{
sem_wait(&b->productleft);
pthread_mutex_lock(&b->rlock);
b->r = b->r%NUM;
printf("%d del \n",b->buf[b->r++]);
pthread_mutex_unlock(&b->rlock);
sem_post(&b->spaceleft);
sleep(rand()%3);
}
}
void* consumer(void *taddr)
{
struct ThreadAttr* taddr2 = (struct ThreadAttr*)taddr;
consumeProducts(taddr2->b,taddr2->n);
return (void*)2;
}
int main(void )
{
struct MyBuf buf;
struct ThreadAttr attr;
attr.b = &buf;
attr.n = 5;
pthread_t c,c1,p,p1,p2;
srand(time(NULL));
initMyBuf(&buf);
pthread_create(&c,0,consumer,&attr);
pthread_create(&c1,0,consumer,&attr);
pthread_create(&p,0,producer,&attr);
pthread_create(&p1,0,producer,&attr);
pthread_create(&p2,0,producer,&attr);
pthread_join(c,NULL);
pthread_join(c1,NULL);
pthread_join(p,NULL);
pthread_join(p1,NULL);
pthread_join(p2,NULL);
destroyMyBuf(&buf);
}