系统与网络编程
小作业
- 公交车停发车程序
#include
#include
#include //fork ()
#include
#include //kill()
#include //signal()
pid_t pid = -1;
//司机:到站停车 --> SIGINT ctrl+c
// 关门开车 --> SIGUSR1
void handleDriver(int sig)
{
if (SIGINT == sig)
{
printf("到站了...\n");
sleep(1);
printf("司机开始停车...\n");
sleep(1);
int ret = 0;
ret = kill(pid, SIGUSR2); //发送信号给售票员让她开门
if (-1 == ret)
{
perror("kill");
}
}
else if (SIGUSR1 == sig)
{
printf("司机开始开车...\n");
sleep(1);
printf("车正在跑...\n");
sleep(1);
}
}
//售票员:开门 -->SIGUSR2
void handleConductor(int sig)
{
if (SIGUSR2 == sig)
{
printf("售票员开门...\n");
sleep(1);
printf("乘客上车...\n");
sleep(1);
printf("售票员关门...\n");
sleep(1);
kill(getppid(), SIGUSR1); //售票员发送信号给司机开车
}
}
int main(void)
{
pid = fork();
if (pid > 0) //driver
{
signal(SIGINT, handleDriver);
signal(SIGUSR1, handleDriver);
printf("司机等待售票员做好开车准备...\n");
while (1)
{
pause();
}
}
else if (0 == pid) //conductor
{
signal(SIGINT, SIG_IGN);
signal(
![Paste_Image.png](http://upload-images.jianshu.io/upload_images/3238825-425024fd6d3a07ff.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)SIGUSR2, handleConductor);
sleep(1);
//发送一个开车信号让其开车
kill(getppid(), SIGUSR1);
while (1)
{
pause();
}
}
else if (-1 == pid)
{
perror("fork");
return -1;
}
return 0;
}
线程
并发执行:看起来像同时运行,实际上在单核cpu里只有一个。将其排成进程列表,每个进程分配执行时间,执行完后挂起,下个进程开始进行。
-
创建线程:
- int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
void (start_routine) (void *), void *arg); - 第一个参数:线程的标识,第二个参数:线程的属性,第三个参数:指定线程执行的代码,第四个参数:传给这个线程的实参。
- 编译的时候要加上-pthread。
#include
#include #include #include #include void *thread_run(void *arg) { while(1) { printf("this is thread_run...\n"); sleep(1); } return NULL; } int main() { pthread_t thread;//线程的标识 int ret=0; ret=pthread_create(&thread,NULL,thread_run,NULL); if(ret!=0) { printf("errno:%d,error:%s\n",ret,strerror(ret)); return -1; } while(1) { printf("this is main...\n"); sleep(1); } return 0; } - int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
-
线程特点
- 一个进程创建后,创建的线程从属于该进程,不独立于进程,共享进程的所有资源
- 线程是最小的执行单元
- 若一个进程创建线程后,我们可以将该进程称之为主线程
- 一个进程可以创建多个线程,线程之间资源共享
- 若一个进程没有创建线程既可以把它看作是进程,也可以把它看做是线程
-
使用return只能结束当前线程
-
exit(1)会将线程所属的进程挂掉,当然线程也会挂掉
-
线程资源共享
- 电脑会分配给每部分一段运行时间,当运行时间到了以后就会切换到下一个进程
#include
#include #include #include #include int g_data=0; void *thread_run(void *arg) { while(1) { g_data++; printf("this is thread_run...%d\n",g_data); // sleep(1); } return NULL; } int main() { pthread_t thread;//线程的标识 int ret=0; ret=pthread_create(&thread,NULL,thread_run,NULL); if(ret!=0) { printf("errno:%d,error:%s\n",ret,strerror(ret)); return -1; } while(1) { g_data++; printf("this is main%d\n",g_data); // sleep(1); } return 0; } - 解决方法:定义一个锁
#include
#include #include #include #include pthread_mutex_t mutex; //互斥量,锁 int g_data=0; void *thread_run(void *arg) { while(1) { pthread_mutex_lock(&mutex); g_data++; printf("this is thread_run...%d\n",g_data); pthread_mutex_unlock(&mutex); // sleep(1); } return NULL; } int main() { //初始化互斥量 pthread_mutex_init(&mutex,NULL);//NULL:使用默认属性 pthread_t thread;//线程的标识 int ret=0; ret=pthread_create(&thread,NULL,thread_run,NULL); if(ret!=0) { printf("errno:%d,error:%s\n",ret,strerror(ret)); return -1; } while(1) { g_data++; printf("this is main%d\n",g_data); // sleep(1); } return 0; } - 实现文件读与打印的线程
#include
#include //write() read() #include //errno #include //strerror() /*open()*/ #include #include #include #include //pthread_create pthread_mutex_t mutex; #define NAME_LEN 32 typedef struct Student { int iId; char caName[NAME_LEN]; char cSex; float fScore; }Student; int myOpen(const char *pathname) { int fd = -1; if (NULL != pathname) { fd = open(pathname, O_RDONLY | O_CREAT , S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH); if (-1 == fd) { printf("open error: %s\n", strerror(errno)); } } return fd; } int g_iSign = 0; void *read_thread(void *arg) { int fd = -1; fd = myOpen("stu.info"); if (-1 != fd) { int ret = -1; Student *pStu = (Student *)arg; while (1) { if (0 == g_iSign) { pthread_mutex_lock(&mutex); memset(pStu, '\0', sizeof(Student)); ret = read(fd, pStu, sizeof(Student)); if (0 == ret) { printf("reached the file end\n"); pthread_mutex_unlock(&mutex); g_iSign = 1; break; } else if (-1 == ret) { printf("read error:%s\n", strerror(errno)); pthread_mutex_unlock(&mutex); g_iSign = 1; break; } pthread_mutex_unlock(&mutex); g_iSign = 1; } } close(fd); } return NULL; } void *print_thread(void *arg) { Student *pStu = (Student *)arg; int i = 0; while (1) { if (1 == g_iSign) { pthread_mutex_lock(&mutex); if (0 == pStu->iId) { pthread_mutex_unlock(&mutex); break; } printf("id:%d, name:%s, sex:%c, score:%.1f\n" , pStu->iId, pStu->caName , pStu->cSex, pStu->fScore); pthread_mutex_unlock(&mutex); g_iSign = 0; } } return NULL; } int main(void) { pthread_mutex_init(&mutex, NULL); Student stu; pthread_t pthr_read; pthread_t pthr_show; pthread_create(&pthr_read, NULL, read_thread, &stu); pthread_create(&pthr_show, NULL, print_thread, &stu); pthread_join(pthr_read, NULL); pthread_join(pthr_show, NULL); return 0; } -
线程结束
- 发送一个结束线程请求给指定的线,默认情况下线程是会同意该结束线程请求,还可以设置不同意
- 在线程函数中调用pthread_setcancelstate来设置,不同意结束线程结束请求,阻塞线程结束请求,直到线程允许接收线程结束请求
#include
#include #include #include #include void *thread_run(void *arg) { //在线程函数中调用pthread_setcancelstate来设置 //不同意结束线程结束请求,阻塞线程结束请求 //直到线程允许接收线程结束请求 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,NULL); while(1) { printf("this is thread_run...\n"); sleep(1); } return NULL; } int main() { pthread_t thread;//线程的标识 int ret=0; ret=pthread_create(&thread,NULL,thread_run,NULL); if(ret!=0) { printf("errno:%d,error:%s\n",ret,strerror(ret)); return -1; } sleep(3); //发送一个结束线程请求给指定的线程 //默认情况下线程是会同意该结束线程请求 //还可以设置不同意 pthread_cancel(thread);//挂起线程 while(1) { printf("this is main\n"); sleep(1); } return 0; }
- pthread_exit(NULL);
#include
#include #include #include #include void *thread_run(void *arg) { pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,NULL); while(1) { printf("this is thread_run...\n"); sleep(1); break; pthread_exit(NULL);//结束所属线程 } return NULL; } int main() { pthread_t thread;//线程的标识 int ret=0; ret=pthread_create(&thread,NULL,thread_run,NULL); if(ret!=0) { printf("errno:%d,error:%s\n",ret,strerror(ret)); return -1; } sleep(3); pthread_exit(NULL);//等待其他线程结束,此过程会阻塞,随后结束主函数。 while(1) { printf("this is main\n"); sleep(1); } return 0; } - pthread_join(thread,NULL);//若线程在运行,则阻塞等待,若不在运行,则立即返回
#include
#include #include #include #include void *thread_run(void *arg) { pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,NULL); while(1) { printf("this is thread_run...\n"); sleep(1); } return NULL; } int main() { pthread_t thread;//线程的标识 int ret=0; ret=pthread_create(&thread,NULL,thread_run,NULL); if(ret!=0) { printf("errno:%d,error:%s\n",ret,strerror(ret)); return -1; } pthread_join(thread,NULL); while(1) { printf("this is main\n"); sleep(1); } return 0; } -
信号量:
- int sem_init(sem_t *sem, int pshared, unsigned int value);
- 第一个是信号量,第二个是初始线程还是进程,第三个值表示满足不满足
#include
#include //write() read() #include //errno #include //strerror() /*open()*/ #include #include #include #include //pthread_create #include pthread_mutex_t mutex; sem_t read_sem; //整形 sem_t show_sem; #define NAME_LEN 32 typedef struct Student { int iId; char caName[NAME_LEN]; char cSex; float fScore; }Student; int myOpen(const char *pathname) { int fd = -1; if (NULL != pathname) { fd = open(pathname, O_RDONLY | O_CREAT , S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH); if (-1 == fd) { printf("open error: %s\n", strerror(errno)); } } return fd; } void *read_thread(void *arg) { int fd = -1; fd = myOpen("stu.info"); if (-1 != fd) { int ret = -1; Student *pStu = (Student *)arg; while (1) { //如果read_sem大于0,接着往下执行,并且将该变量减一 //如果read_sem等于0,则阻塞,直到该值大于0 sem_wait(&read_sem); pthread_mutex_lock(&mutex); memset(pStu, '\0', sizeof(Student)); ret = read(fd, pStu, sizeof(Student)); if (0 == ret) { printf("reached the file end\n"); pthread_mutex_unlock(&mutex); sem_post(&show_sem); break; } else if (-1 == ret) { printf("read error:%s\n", strerror(errno)); pthread_mutex_unlock(&mutex); sem_post(&show_sem); break; } pthread_mutex_unlock(&mutex); //将信号量的值加一 sem_post(&show_sem); } } close(fd); return NULL; } void *print_thread(void *arg) { Student *pStu = (Student *)arg; int i = 0; while (1) { { //如果show_sem大于0,接着往下执行,并且将该变量减一 //如果show_sem等于0,则阻塞,直到该值大于0 sem_wait(&show_sem); pthread_mutex_lock(&mutex); if (0 == pStu->iId) { pthread_mutex_unlock(&mutex); sem_post(&read_sem); break; } printf("id:%d, name:%s, sex:%c, score:%.1f\n" , pStu->iId, pStu->caName , pStu->cSex, pStu->fScore); pthread_mutex_unlock(&mutex); //将信号量的值加一 sem_post(&read_sem); } } return NULL; } int main(void) { pthread_mutex_init(&mutex, NULL); //初始化信号量 sem_init(&read_sem, 0, 1); //将read_sem值置为1 sem_init(&show_sem, 0, 0); //将show_sem值置为0 Student stu; pthread_t pthr_read; pthread_t pthr_show; pthread_create(&pthr_read, NULL, read_thread, &stu); pthread_create(&pthr_show, NULL, print_thread, &stu); pthread_join(pthr_read, NULL); pthread_join(pthr_show, NULL); return 0; }
pthread_addNum
#include //pthread_create()
#include
#include//strerror()
#include //errno
#include
int g_iData=0;
void *thread_run(void *arg)
{
while(1)
{
++g_iData;
printf("thread :data=%d\n",g_iData);
}
return NULL;
}
int main()
{
pthread_t thread;
int ret=0;
ret=pthread_create(&thread,NULL,thread_run,NULL);//现在线程的属性默认为NULL
if(0!=ret)
{
printf("errno:%d,error:%s\n",ret,strerror(ret));
return -1;
}
while(1)
{
++g_iData;
printf("main :data=%d\n",g_iData);
}
return 0;
}
- g_iData=0;A线程++g_iData,如果线程A时间足够的话,则g_iData=1;B线程再执行,则变为2;
- 若A时间片不够,虽然++了但++后的值还没有返回到g_iData里,所以B线程++后的值仍然为1
如下,会出现中断的情况
- 解决以上情况,则定义一个原子锁
#include //pthread_create()
#include
#include//strerror()
#include //errno
#include
pthread_mutex_t mutex; //互斥量或者称为锁
int g_iData=0;
void *thread_run(void *arg)
{
while(1)
{
//使用pthread_mutex_lock和pthread_mutex_unlock
//使它们之间的语句合成原子操作
pthread_mutex_lock(&mutex);
++g_iData;
printf("thread :data=%d\n",g_iData);
pthread_mutex_unlock(&mutex);
}
return NULL;
}
int main()
{
//初始化互斥量,NULL表示使用默认属性初始化该互斥量
pthread_mutex_init(&mutex,NULL);//使用他的默认属性进行初始化
pthread_t thread;
int ret=0;
ret=pthread_create(&thread,NULL,thread_run,NULL);//现在线程的属性默认为NULL
if(0!=ret)
{
printf("errno:%d,error:%s\n",ret,strerror(ret));
return -1;
}
while(1)
{
pthread_mutex_lock(&mutex);
++g_iData;
printf("main :data=%d\n",g_iData);
pthread_mutex_unlock(&mutex);
}
return 0;
}
- 这样就不会出现中断的情况
一个线程从文件读取数据,另一个线程打印出来
- 先通过以前的代码,在文件里写入几个同学的信息
#include
#include //write() read()
#include //errno
#include //strerror()
/*open()*/
#include
#include
#include
#include //pthread_create
pthread_mutex_t mutex;
#define NAME_LEN 32
typedef struct Student
{
int iId;
char caName[NAME_LEN];
char cSex;
float fScore;
}Student;
int myOpen(const char *pathname)
{
int fd = -1;
if (NULL != pathname)
{
fd = open(pathname, O_RDONLY | O_CREAT
, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
if (-1 == fd)
{
printf("open error: %s\n", strerror(errno));
}
}
return fd;
}
int g_iSign = 0;
void *read_thread(void *arg)
{
int fd = -1;
fd = myOpen("stu.info");
if (-1 != fd)
{
int ret = -1;
Student *pStu = (Student *)arg;
while (1)
{
if (0 == g_iSign)
{
pthread_mutex_lock(&mutex);
memset(pStu, '\0', sizeof(Student));
ret = read(fd, pStu, sizeof(Student));
if (0 == ret)
{
printf("reached the file end\n");
pthread_mutex_unlock(&mutex);
g_iSign = 1;
break;
}
else if (-1 == ret)
{
printf("read error:%s\n", strerror(errno));
pthread_mutex_unlock(&mutex);
g_iSign = 1;
break;
}
pthread_mutex_unlock(&mutex);
g_iSign = 1;
}
}
close(fd);
}
return NULL;
}
void *print_thread(void *arg)
{
Student *pStu = (Student *)arg;
int i = 0;
while (1)
{
if (1 == g_iSign)
{
pthread_mutex_lock(&mutex);
if (0 == pStu->iId)
{
pthread_mutex_unlock(&mutex);
break;
}
printf("id:%d, name:%s, sex:%c, score:%.1f\n"
, pStu->iId, pStu->caName
, pStu->cSex, pStu->fScore);
pthread_mutex_unlock(&mutex);
g_iSign = 0;
}
}
return NULL;
}
int main(void)
{
pthread_mutex_init(&mutex, NULL);
Student stu;
pthread_t pthr_read;
pthread_t pthr_show;
pthread_create(&pthr_read, NULL, read_thread, &stu);
pthread_create(&pthr_show, NULL, print_thread, &stu);
pthread_join(pthr_read, NULL);
pthread_join(pthr_show, NULL);
return 0;
}
信号量(sem_wait)
//int sem_init();//pshared
#include
#include //write() read()
#include //errno
#include //strerror()
/*open()*/
#include
#include
#include
#include //pthread_create
#include
pthread_mutex_t mutex;
sem_t read_sem;//读的信号量
sem_t print_sem;//显示的信号量
#define NAME_LEN 32
typedef struct Student
{
int iId;
char caName[NAME_LEN];
char cSex;
float fScore;
}Student;
int myOpen(const char *pathname)
{
int fd = -1;
if (NULL != pathname)
{
fd = open(pathname, O_RDONLY | O_CREAT
, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
if (-1 == fd)
{
printf("open error: %s\n", strerror(errno));
}
}
return fd;
}
void *read_thread(void *arg)
{
int fd = -1;
fd = myOpen("stu.info");
if (-1 != fd)
{
int ret = -1;
Student *pStu = (Student *)arg;
while (1)
{
//如果read_sem大于0,接着往下执行,并且将该变量减1,如果等于0,则阻塞,直到该值大于0
sem_wait(&read_sem);//此时read_sem=1
pthread_mutex_lock(&mutex);
memset(pStu, '\0', sizeof(Student));
ret = read(fd, pStu, sizeof(Student));
if (0 == ret)
{
printf("reached the file end\n");
pthread_mutex_unlock(&mutex);
sem_post(&print_sem);//出错了,发送这个信号
break;
}
else if (-1 == ret)
{
printf("read error:%s\n", strerror(errno));
pthread_mutex_unlock(&mutex);
sem_post(&print_sem);//出错了,发送这个信号
break;
}
pthread_mutex_unlock(&mutex);
sem_post(&print_sem);//出错了,发送这个信号
}
close(fd);
}
return NULL;
}
void *print_thread(void *arg)
{
Student *pStu = (Student *)arg;
int i = 0;
while (1)
{
//如果print_sem大于0,接着往下执行,并且将该变量减1,如果等于0,则阻塞,直到该值大于0
sem_wait(&print_sem);
pthread_mutex_lock(&mutex);
if (0 == pStu->iId)
{
pthread_mutex_unlock(&mutex);
sem_post(&read_sem);
break;
}
printf("id:%d, name:%s, sex:%c, score:%.1f\n"
, pStu->iId, pStu->caName
, pStu->cSex, pStu->fScore);
pthread_mutex_unlock(&mutex);
//将信号量的值加1
sem_post(&read_sem);
}
return NULL;
}
int main(void)
{
pthread_mutex_init(&mutex, NULL);
sem_init(&read_sem,0,1);//对信号量的初始化,必须先读才能再显示,将read_sem的值置为1
sem_init(&print_sem,0,0);//将print_sem的值置为0
Student stu;
pthread_t pthr_read;
pthread_t pthr_show;
pthread_create(&pthr_read, NULL, read_thread, &stu);
pthread_create(&pthr_show, NULL, print_thread, &stu);
pthread_join(pthr_read, NULL);
pthread_join(pthr_show, NULL);
return 0;
}
用代码模仿5个哲学家进餐问题
- 创建5根筷子(5个信号量创建一组信号量)
- 创建5科学家
- 获得筷子
- 放下筷子
- 继续思考
int semop(int semid, struct sembuf *sops, unsigned nsops);
参数
- semid:信号集的识别码,可通过semget获取。
- sops:指向存储信号操作结构的数组指针,信号操作结构的原型如下
struct sembuf
{
unsigned short sem_num; /* semaphore number */
short sem_op; /* semaphore operation */
short sem_flg; /* operation flags */
};
- 这三个字段的意义分别为:
- sem_num:操作信号在信号集中的编号,第一个信号的编号是0。
- sem_op:
- 1, 如果其值为正数,该值会加到现有的信号内含值中。
通常用于释放所控资源的使用权; - 2, 如果sem_op的值为负数,而其绝对值又大于信号的现值,
操作将会阻塞,直到信号值大于或等于sem_op的绝对值。
通常用于获取资源的使用权; - 3, 如果sem_op的值为0,如果没有设置IPC_NOWAIT,
则调用该操作的进程或者线程将暂时睡眠,直到信号量的值为0; 否则,进程或者线程不会睡眠,函数返回错误EAGAIN。
- sem_flg:信号操作标志,可能的选择有两种
- 1, IPC_NOWAIT //对信号的操作不能满足时,semop()不会阻塞,
并立即返回,同时设定错误信息。 - 2, SEM_UNDO //程序结束时(不论正常或不正常),
保证信号值会被重设为semop()调用前的值。
这样做的目的在于避免程序在异常情况下结束时
未将锁定的资源解锁,造成该资源永远锁定。
- nsops:信号操作结构的数量,恒大于或等于1。
#include
#include
#include
#include //perror()
#include
#include
#include
#include
#include
union semun
{
int val;
struct semid_ds *buf;
unsigned short *array;
struct seminfo *__buf;
};
void getChopsticks(int iNum,int *semfd)
{
int iLeft=iNum;
int iRight=(iNum+1)%5;
struct sembuf semope[2]={{iLeft,-1,0},
{iRight,-1,0}};
semop(*semfd,semope,2);//拿筷子,获得左右两边的筷子
}
void putChopsticks(int iNum,int *semfd)
{
int iLeft=iNum;
int iRight=(iNum+1)%5;
struct sembuf semope[2]={{iLeft,1,0},
{iRight,1,0}};
semop(*semfd,semope,2);//拿筷子,获得左右两边的筷子
}
void thinkAndEat(int iNum,int *semfd)
{
while(1)
{
printf("%d say:I am thinking...\n",iNum);
/*拿筷子吃饭*/
getChopsticks(iNum,semfd);
sleep(1);
printf("%d say:I am eatting...\n",iNum);
/*放下筷子*/
putChopsticks(iNum,semfd);
printf("%d say:I am puting chopsticks...\n",iNum);
sleep(1);
}
}
int main(void)
{
int semfd=-1;
//获得信号量集的标识,若信号量集不存在则创建
semfd=semget(0x1024,5,IPC_CREAT | 0777);//5,代表5个信号量
if(-1==semfd)
{
perror("semget");
return -1;
}
//对信号集中的信号量进行赋值
union semun sem;
sem.val=1;
int i=0;
for(;i<5;i++)
{
if(-1==semctl(semfd,i,SETVAL,sem))
{
perror("semctl");
return -1;
}
}
//创建5个哲学家进程
int iNum=0;//用来保存表示第几个科学家
pid_t pid=-1;
for(i=0;i<4;i++)
{
pid=fork();
if(pid>0)//parent
{
iNum=4;
}
else if(pid==0)//child
{
iNum=i;
break;//
}
else if(pid==-1)//error
{
return -1;
}
}
thinkAndEat(iNum,&semfd);
return 0;
}
- 生产者消费者问题
link