回忆昨天内容
一、并发服务器的实现
多进程实现并发服务器
父进程 子进程 各自负责的任务
信号 头文件 动态库的制作和生成 使用
使用多线程也可以实现服务器的并发
二、基于udp的编程实现
模型
实现
服务器 客户端
不需要连接 基于数据包的
recvfrom(2) sendto(2)
三、线程的基础
每个线程有自己的tid tcb
每个线程有自己私有的资源
一个进程中有多个线程 进程中的线程共享进程的资源
进程是资源分配的基本单位 线程是执行的基本单位
获取线程的tid pthread_self(3)
获取进程的pid getpid(2)
线程的创建 pthread_create(3) 私有资源为栈帧
线程执行函数 返回值 形参
线程的终止 汇合 分离
return exit(3)的区别
线程中不要使用exit(3)
pthread_exit(3) 终止当前调用其的线程
pthread_cancel(3)向线程发送取消请求 取消线程终止时终止状态标记为PTHREAD_CANCELED
pthread_detach(3) 线程的分离 分离线程终止时，自动释放资源给系统，不需要其他线程来回收
pthread_join(3) 让进程的一个线程收另外一个线程的资源
今天的内容
一、线程汇合：
pthread_join
#include <pthread.h>
int pthread_join(pthread_t thread, void **retval);
Compile and link with -pthread.
功能：汇合一个已经终止的线程，等待一个线程终止，回收其资源，如果已经终止，立即返回
参数：thread 指定要被汇合的线程的tid
retval 将目标线程的退出状态码拷贝到*retval指向的地址中
返回值：成功 0
错误 错误码
举例说明 线程的终止 汇合
代码参见 pthread_e.c
二、线程同步：
1）可重入函数
函数只能访问自己栈帧里的资源 不去访问共有资源，这样的函数称为可重入函数
如果这个函数访问了静态局部变量 全局变量和malloc申请的变量，则是不可重入函数
举例说明 多个线程异步访问临界资源产生错误的情况
代码参见 count.c
2）mutex锁
pthread_mutex_t mutex锁类型
mutex锁是一个互斥设备 用于对共享数据的保护
两种类型 一种unlocked：不被任何进程占有
locked：被一个进程占有
任何一个mutex不能同时被两个线程占有
若一个线程要加锁的资源已经被另一个线程锁住，需等待另一个线程解锁
跟类型相关的操作
//静态初始化mutex锁
pthread_mutex_t fastmutex=PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_init(3)
int pthread_mutex_init(pthread_mutex_t *mutex,const pthread_mutexattr_t *mutexattr);
功能：使用属性初始化mutex指定的锁
参数：
mutex 指定要初始化的锁
mutexattr NULL 缺省属性
返回值 总是0
int pthread_mutex_lock(pthread_mutex_t *mutex);
功能：加锁 如果锁处于解锁状态，立即加锁并返回，如果要加的锁被其他线程占用，则阻塞等待其他线程释放锁
参数：
mutex指定要操作的锁
返回值 成功0
错误 非0的错误码 errno被设置
int pthread_mutex_trylock(pthread_mutex_t *mutex);
功能：尝试加锁 如果锁处于解锁状态，立即加锁并返回，如果要加的锁被其他线程占用，则立即返回EBUSY
参数：
mutex 指定要操作的锁
返回值 成功0
错误 非0的错误码 errno被设置
int pthread_mutex_unlock(pthread_mutex_t *mutex);
功能：解锁 mutex被假定为被当前线程占用且被锁定的状态
参数：
mutex 指定要操作的锁
返回值 成功0
错误 非0的错误码 errno被设置
int pthread_mutex_destroy(pthread_mutex_t *mutex);
功能：销毁mutex锁，释放锁住的资源
参数：
mutex 指定要销毁的mutex锁
返回值 成功0
错误 非0的错误码 errno被设置
3）条件变量
什么是条件变量？
是一个同步设备。允许多个线程挂起执行，并且放弃cpu，直到条件被满足。
signal the condition (when the predicate becomes true),
发送信号。条件变为真的时候，发送这个信号
wait for the condition
等待条件变为真
一个条件变量跟一个mutex相关联
pthread_cond_t 条件变量类型
跟条件变量类型相关的操作
#include <pthread.h>
//条件变量的静态初始化
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);
功能：初始化条件变量
参数：
cond:指定要初始化的条件变量
cond_attr:指定条件变量的属性，默认NULL。使用这个属性来初始化条件变量
返回值： 成功0
错误 非0错误码
int pthread_cond_signal(pthread_cond_t *cond);
功能：启用等待条件变为真的所有的线程中的一个线程。如果没有线程等待条件变为真，do nothing
参数：
cond:指定条件变量。从在这个条件变量上等待的线程中取一个线程
返回值:
int pthread_cond_broadcast(pthread_cond_t *cond);
功能：启用等待条件变为真的所有的线程，如果没有线程等待条件变为真，do nothing
参数：
cond:指定条件变量。启动所有在这个条件变量上等待的线程
返回值: 成功0
错误 非0错误码
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
功能：
参数：
cond:指定条件变量
mutex:指定mutex锁
返回值: 成功0
错误 非0错误码
步骤：
1、原子的解锁和等待条件变为真
2、只有条件变量变为真的时候，这个函数才返回。返回来的时候，重新加锁mutex.
int pthread_cond_timedwait(pthread_cond_t *cond,pthread_mutex_t *mutex, const struct timespec *abstime);
功能：指定了一个等待周期，超时就不再等待。
参数：
cond:
返回值: 成功0
错误 非0错误码
int pthread_cond_destroy(pthread_cond_t *cond);
功能：销毁条件变量
参数：
cond:指定要销毁的条件变量
返回值:
成功 0
错误 非0的错误码
举例说明 使用条件变量实现生产者和消费者的例子
没有生产就不能消费
数据结构 链表
生产者线程 生产一个新的节点，将这个节点插入到链表的头部
消费者线程 从链表的头部取出一个节点，消费这个节点
代码参见 p_c_cond.c
信号量
sem_t 类型
什么是信号量？
跟类型相关的操作
#include <semaphore.h>
int sem_init(sem_t *sem, int pshared, unsigned int value);
功能：初始化匿名信号量。在sem指定的地址空间里初始化。
参数：
sem:指定信号量的地址
shared:0 多线程 非0 多进程
value:信号量的初始值
返回值：
成功 0
错误 -1 errno被设置
Link with -pthread.
sem_destroy(3)
#include <semaphore.h>
int sem_destroy(sem_t *sem);
功能：销毁一个匿名信号量
参数：
sem:指定要销毁的信号量
返回值：
成功 0
错误 -1 errno被设置
+1/-1
sem_post(3)
#include <semaphore.h>
int sem_post(sem_t *sem);
功能：加1操作。如果semval>0,会唤醒等待semval>0的线程，这些线程在继续获取信号量（-1）.
参数：
sem:指定要操作的信号量
返回值：
成功 0
错误 -1 errno被设置
sem_wait(3)
#include <semaphore.h>
int sem_wait(sem_t *sem);
功能：减一操作 semval>0 立即返回
semval==0 阻塞，直到另一个线程将其变为大于0为止。
参数：
sem:指定要操作的信号量
返回值：
成功 0
错误 -1 errno被设置
举例说明 使用环状队列实现生产者和消费者的例子
代码参见 p_c_sem.c
pthread_e.c
#include<t_stdio.h>
#include<pthread.h>
#include<unistd.h>
void *handle(void *arg){
printf("handle running...\n");
return ((void *)2);
}
void *handle1(void *arg){
printf("handle1 running...\n");
pthread_exit((void *)5);
}
void *handle2(void *arg){
while(1){
sleep(1);
printf("handle2 running...\n");
}
pthread_exit((void *)5);
}
int main(void){
pthread_t tid;
void *ret;
//创建一个新的线程
pthread_create(&tid,NULL,handle,NULL);
//等待新线程终止 汇合新的线程
pthread_join(tid,&ret);
printf("handle exit code...%d\n",(int)ret);
//再创建一个新的线程,用pthread_exit
pthread_create(&tid,NULL,handle1,NULL);
//等待新线程终止 汇合新的线程
pthread_join(tid,&ret);
printf("handle1 exit code...%d\n",(int)ret);
//再创建一个新的线程,用pthread_cancel；
pthread_create(&tid,NULL,handle2,NULL);
sleep(4);
//给tid线程发送取消请求
pthread_cancel(tid);
//等待新线程终止 汇合新的线程
pthread_join(tid,&ret);
if(PTHREAD_CANCELED==ret)
//printf("handle2 exit code...%d\n",(int)ret);
printf("handle2 exit code...%d\n",(int)PTHREAD_CANCELED);
return 0;
}
count.c
#include<stdio.h>
#include<pthread.h>
//定义锁类型的变量,静态初始化
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
//线程异步，所以最后val并不是10000
int val=0;
void *handle(void *arg){
int temp;
for(int i=0;i<5000;i++){
//加锁
pthread_mutex_lock(&mutex);
temp=val;
temp++;
printf("my tid=%ld,temp=%d\n",pthread_self(),temp);
val=temp;
//解锁
pthread_mutex_unlock(&mutex);
}
return NULL;
}
int main(){
pthread_t tid,pid;
//创建两个线程
pthread_create(&tid,NULL,handle,NULL);
pthread_create(&pid,NULL,handle,NULL);
//等待线程汇合
pthread_join(tid,NULL);
pthread_join(pid,NULL);
//销毁mutex锁
pthread_mutex_destroy(&mutex);
return 0;
}
p_c_sem.c
#include<stdio.h>
#include<pthread.h>
#include<unistd.h>
#include<time.h>
#include<stdlib.h>
#include <semaphore.h>
typedef int que_t[6];
que_t q;//定义了一个循环队列
sem_t p,c;//可生产的数量和可消费的数量
//生产者线程
void *product(void *arg){
int i=0;//数组下标
while(1){
//判断是否可以生产
sem_wait(&p);
q[i]=rand()%1000+1;
printf("p:%d\n",q[i]);
sem_post(&c);
i=(i+1)%6;
sleep(rand()%5+1);
}
}
//消费者线程
void *consume(void *arg){
int r=0,tmp;
while(1){
sem_wait(&c);//判断是否可以消费
tmp=q[r];
q[r]=-1;
sem_post(&p);
printf("c:%d\n",tmp);
r=(r+1)%6;
sleep(rand()%5+1);
}
}
int main(){
srand(time(NULL));
//初始化信号量的值
sem_init(&p,0,6);
sem_init(&c,0,0);
pthread_t pid,cid;
//创建两个线程 一个是生产者 一个是消费者
pthread_create(&pid,NULL,product,NULL);
pthread_create(&cid,NULL,consume,NULL);
//等待线程的汇合
pthread_join(pid,NULL);
pthread_join(cid,NULL);
sem_destroy(&p);
sem_destroy(&c);
return 0;
}
p_c_cond.c
#include<stdio.h>
#include<pthread.h>
#include<unistd.h>
#include<time.h>
#include<stdlib.h>
#include <semaphore.h>
//声明条件变量
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
//定义一个mutex锁
pthread_mutex_t mutex= PTHREAD_MUTEX_INITIALIZER;
//链表定义
typedef struct node{
int data;
struct node *next;
}node_t;
typedef node_t *list_t;
list_t head=NULL;//空链表
//生产者线程,生产一个节点，插入链表头部
void *product(void *arg){
node_t *new;
while(1){
//生产节点
new=(node_t *)malloc(sizeof(node_t));
new->data=rand()%1000+1;
new->next=NULL;
printf("p:%d\n",new->data);
//插入链表头部
//加锁
pthread_mutex_lock(&mutex);
new->next=head;
head=new;
//解锁
pthread_mutex_unlock(&mutex);
pthread_cond_signal(&cond);
sleep(rand()%5+1);
}
}
//消费者线程，从链表头部取出一个节点，消费节点
void *consume(void *arg){
node_t *temp;
while(1){
//从链表头部取出一个节点
//加锁
pthread_mutex_lock(&mutex);
/* if(head->next==NULL)
//等待生产，等待head->next不为空
pthread_cond_wait(&cond,&mutex);
else{
temp=head->next;
head->next=temp->next;
}*/
while(head==NULL)
//等待生产，等待head->next不为空
pthread_cond_wait(&cond,&mutex);
temp=head;
head=head->next;
//解锁
pthread_mutex_unlock(&mutex);
//消费该节点
printf("c:%d\n",temp->data);
free(temp);
sleep(rand()%5+1);
}
}
![sudo apt-get update 出错 Updating from such a repository can‘t be done securely, and is therefore[图]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)