思维导图：
将互斥机制代码重新实现一遍
代码：
#include
#include
#include
#include
#include
#include
#include
char buf[128]; //全局数组，临界资源
//1、创建一个互斥锁
pthread_mutex_t mutex;
//定义分支线程
void *task(void *arg)
{
while(1)
{
//3、获取锁资源
pthread_mutex_lock(&mutex);
printf("分支线程中：buf=%s\n",buf);
strcpy(buf,"I love China\n");
//４释放锁资源
pthread_mutex_unlock(&mutex);
}
}
int main(int argc, const char *argv[])
{
//定义线程号变量
pthread_t tid;
//2初始化互斥锁
pthread_mutex_init(&mutex,NULL);
//创建线程
if(pthread_create(&tid,NULL,task,NULL)!=0)
{
printf("tid create error\n");
return -1;
}
//主线程
while(1)
{
//获取锁资源
pthread_mutex_lock(&mutex);
printf("主线程中buf=%s\n",buf); //访问临界资源
strcpy(buf,"hello world\n");
//释放锁资源
pthread_mutex_unlock(&mutex);
}
pthread_join(tid,NULL); //阻塞回收线程资源
//销毁锁资源
pthread_mutex_destroy(&mutex);
return 0;
}
运行效果：
将同步机制代码重新实现一遍
代码：
#include
#include
#include
#include
#include
#include
//1创建一个无名信号量
sem_t sem;
//生产者线程
void *task1(void *arg)
{
while(1)
{
sleep(2);
printf("我生产了一辆特斯拉\n");
//4释放资源
sem_post(&sem);
}
}
//消费者线程
void *task2(void *arg)
{
while(1)
{
//3申请资源，如果没有资源
sem_wait(&sem);
printf("我消费了一辆特斯拉\n");
}
}
int main(int argc, const char *argv[])
{
//创建两个线程
pthread_t tid1,tid2;
//初始化无名信号量
sem_init(&sem,0,0);
//第一个0：表示线程之间的通信
//第二个0：表示value初始值为0
//创建生产者线程
if(pthread_create(&tid1,NULL,task1,NULL)!=0)
{
printf("tid1 create error\n");
return -1;
}
//创建消费者线程
if(pthread_create(&tid2,NULL,task2,NULL)!=0)
{
printf("tid2 create error\n");
return -1;
}
//主线程回收资源
pthread_join(tid1,NULL);
pthread_join(tid2,NULL);
//销毁无名信号量
sem_destroy(&sem);
return 0;
}
运行效果：
使用三个线程完成两个文件的拷贝，线程1完成拷贝前一半，线程2完成拷贝后一半，主线程回收两个分支线程的资源。
代码：
#include
#include
#include
#include
#include
#include
#include
#include
//定义传参结构体
struct INFO
{
const char *r; //读取的文件
const char *w; //写入的文件
int start; //开始位置
int len; //长度
};
//定义求文档长度函数
int lenstr(const char *r)
{
//以只读的形式打开源文件
FILE *rfp=NULL;
if((rfp=fopen(r,"r"))==NULL)
{
perror("rfp error");
return -1;
}
//使用fseek和ftell函数定位到文件的数量
//fseek(文件指针，偏移量，开始的位置)
//ftell(文件中指针)，直接返回文件的位置，既把指针最后的位置，返回文件数量
int len=0; //计数
fseek(rfp,0,SEEK_END); //光标偏移到文件最后的位置
len=ftell(rfp); //返回值就是文件的数量
fclose(rfp);
return len;
}
//定义拷贝函数
int file_cpy(const char *r,const char *w,int start, int len)
{
char buf[128]=""; //数据搬运工
//以只读的形式打开源文件
FILE *rfp=NULL;
if((rfp=fopen(r,"r"))==NULL)
{
perror("rfp error");
return -1;
}
//以追加写的形式打开被写的文件
FILE *wfp=NULL;
if((wfp=fopen(w,"a"))==NULL)
{
perror("wfp error");
return -1;
}
//bzero(清零的地址，空间字节数)
//防止buf中有内容影响操作
//bzero(buf,sizeof(buf)); //清零buf
//由于读文件已经打开，故需要把光标定位到开头
fseek(rfp,start,SEEK_SET); //光标定位到开始偏移的位置
//由于需要限制位置，所以使用fread函数来进行读取
int count=fread(buf,sizeof(buf[0]),len,rfp);
//写入使用fwrite函数
fwrite(buf,sizeof(buf[0]),count,wfp);
//关闭文件
fclose(rfp);
fclose(wfp);
return 0;
}
void *task1(void *arg)
{
while(1)
{
struct INFO * fap = (struct INFO *)arg;
//调用文件拷贝函数进行拷贝
file_cpy(fap->r,fap->w,fap->start,fap->len);
printf("我是分支线程1\n");
sleep(1);
//将输入的拷贝函数的各个参数分解
//将输入的拷贝函数的各参数结构体拆包到一个结构体变量中
//获取当前线程的线程号
printf("我是分支线程1:tid1=%#lx\n",pthread_self());
//退出当前线程
printf("分支线程1资源退出\n");
pthread_exit(NULL);
}
}
void *task2(void *arg)
{
while(1)
{
printf("我是分支线程2\n");
sleep(1);
//将输入的拷贝函数的各个参数分解
struct INFO * fap = (struct INFO *)arg;
//调用文件拷贝函数进行拷贝
file_cpy(fap->r,fap->w,fap->start,fap->len);
printf("我是分支线程1:tid1=%#lx\n",pthread_self());
//退出当前线程
printf("分支线程2资源退出\n");
pthread_exit(NULL);
}
}
int main(int argc, const char *argv[])
{
if(argc!=3)
{
printf("内容错误\n");
return -1;
}
int len=lenstr(argv[1]);
//定义结构体变量
struct INFO t1={argv[1],argv[2],0,len/2};
struct INFO t2={argv[1],argv[2],len/2,len-len/2};
//定义一个线程号变量
pthread_t tid1=0;
//创建出一个分支线程
if(pthread_create(&tid1,NULL,task1,&t1)!=0)
{
printf("tid1 create error\n");
return -1;
}
printf("tid1 create success tid=%#lx\n",tid1);
//创建一个分支线程
pthread_t tid2=0;
if(pthread_create(&tid2,NULL,task2,&t2)!=0)
{
printf("tid2 create error\n");
return -1;
}
printf("tid2 create success tid2=%#lx\n",tid2);
// while(1)
{
printf("我是主线程\n");
sleep(1);
}
//主线程回收分支线程
pthread_join(tid1,NULL);
pthread_join(tid2,NULL);
printf("主线程成功回收分支线程的资源\n");
return 0;
}
运行效果：
使用三个线程完成线程1输出字符'A'，线程2输出字符'B'，线程3输出字符'C'，要求输出结果为ABCABCABCABCABCABC...
代码：
#include
//1创建一个无名信号量
sem_t sem1,sem2;
//A线程
void *task1(void *arg)
{
while(1)
{
sleep(2);
printf("A");
//释放资源
sem_post(&sem1);
}
}
//B线程资源
void *task2(void *arg)
{
while(1)
{
//申请资源，如果没有资源则在该出堵塞
sem_wait(&sem1);
printf("B");
//释放资源
sem_post(&sem2);
}
}
//B线程资源
void *task3(void *arg)
{
while(1)
{
//申请资源，如果没有资源则在该出堵塞
sem_wait(&sem2);
printf("C");
fflush(stdout); // 刷新 stdout 缓冲区
}
}
int main(int argc, const char *argv[])
{
//创建三个线程
pthread_t tid1,tid2,tid3;
//初始化无名信号量
sem_init(&sem1,0,0);
sem_init(&sem2,0,0);
//第一个0：表示用于线程之间的通信
//第二个0：表示value初始值为0
//创建A线程
if(pthread_create(&tid1,NULL,task1,NULL)!=0)
{
printf("tid1 create error\n");
return -1;
}
//创建B线程
if(pthread_create(&tid2,NULL,task2,NULL)!=0)
{
printf("tid2 create\n");
return -1;
}
//创建C线程
if(pthread_create(&tid3,NULL,task3,NULL)!=0)
{
printf("tid3 create\n");
return -1;
}
//主线程回收资源
pthread_join(tid1,NULL);
pthread_join(tid2,NULL);
pthread_join(tid3,NULL);
//销毁无名信号量
sem_destroy(&sem1);
sem_destroy(&sem2);
return 0;
}
运行效果：
