1.多线程练习
新年快乐
1.头文件
**main.h**
#ifndef __MAIN_H__
#define __MAIN_H__
#include <time.h>
typedef struct mydata
{
float temp;
float hum ;
float oxy;
struct tm tim;
}data_t;
#endif
**pthread.h**
#ifndef __PTHREAD_H__
#define __PTHREAD_H__
#include <pthread.h>
typedef void *(*thread_task) (void *);
typedef struct task
{
pthread_t tid;
thread_task task;
}thread_t;
extern int pthread_init(thread_t *tasks,int len);
extern int destroy_pthread(thread_t *tasks,int len);
#endif
2.c文件
**main.c**
#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include "main.h"
#include "pthread.h"
data_t data_g;//全局结构体变量
void *get_data(void *arg)
{
time_t sec;
struct tm *ptm =NULL;
while(1)
{
time(&sec);
ptm = localtime(&sec);
data_g.tim = *ptm;//获得时间；
data_g.temp = 30.5;
data_g.hum = 35.7;
data_g.oxy = 45.5;
sleep(1);
}
return NULL;
}
void *store_data(void *arg)
{
mkdir("../source",0777);
FILE *fp = fopen("../source/data.txt","a");//只写
if(fp == NULL)
{
perror("fail fopen\n");
return NULL;
}
while(1)
{
fprintf(fp,"[%d-%02d-%02d %d:%d:%d] %f, %f, %f\n",
data_g.tim.tm_year+1900,data_g.tim.tm_mon+1,
data_g.tim.tm_mday,data_g.tim.tm_hour,data_g.tim.tm_min,data_g.tim.tm_sec,
data_g.temp,data_g.hum,data_g.oxy);
fflush(fp);//刷新缓冲区
sleep(1);
}
fclose(fp);
return NULL;
}
void *show_data(void *arg)
{
while(1)
{
printf("[%d-%02d-%02d %d:%d:%d] %f, %f, %f\n",
data_g.tim.tm_year+1900,data_g.tim.tm_mon+1,
data_g.tim.tm_mday,data_g.tim.tm_hour,data_g.tim.tm_min,data_g.tim.tm_sec,
data_g.temp,data_g.hum,data_g.oxy);
sleep(1);
}
return NULL;
}
thread_t tasks[]= {//初始化结构体数组
{
.task = get_data,
},
{
.task = store_data,
},
{
.task = show_data,
},
};
**pthread.c**
int main(int argc, char *argv[] )
{
pthread_init(tasks,sizeof(tasks)/sizeof(tasks[0]));
destroy_pthread(tasks,sizeof(tasks)/sizeof(tasks[0]));
return 0;
}
#include <stdio.h>
#include <unistd.h>
#include "pthread.h"
int pthread_init (thread_t *tasks , int len )
{
for(int i = 0;i<len;++i)
{
int ret = pthread_create(&(tasks[i].tid),NULL,tasks[i].task,NULL);
if(ret != 0)
{
perror("fail create!");
return -1;
}
}
return 0;
}
int destroy_pthread(thread_t *tasks,int len)
{
for(int i = 0;i<len;i++)
{
pthread_join(tasks[i].tid,NULL);
}
return 0;
}
2 .互斥
问题：
多个线程在操作临界资源时存在资源竞争问题；
临界资源：多个线程可以同时访问到的资源，如：共享变量，全局变量，共享内存等（堆区，数据区，文本区）。。。
解决方法：
互斥机制：
在多线程中对临界资源的排他性访问。
锁一定要成对出现，
互斥机制 ===》互斥锁 ===》解决多线程操作共享空间引发的资源竞争问题。
流程：
定义互斥锁 ==》初始化锁 ==》加锁 ==》解锁 ==》销毁
互斥锁一般全局变量，初始化放main函数里
1、定义：
pthread_mutex_t mutex;
2、初始化锁
int pthread_mutex_init(
pthread_mutex_t *mutex,
const pthread_mutexattr_t *attr);
功能：将已经定义好的互斥锁初始化。
参数：mutex 要初始化的互斥锁
atrr 初始化的值，一般是NULL表示默认锁
返回值：成功 0
失败 非零
3、加锁：
int pthread_mutex_lock(pthread_mutex_t *mutex);
功能：用指定的互斥锁开始加锁代码
加锁后的代码到解锁部分的代码属于原子操作，
在加锁期间其他进程/线程都不能操作该部分代码
如果该函数在执行的时候，mutex已经被其他部分
使用则代码阻塞，等待资源被解锁。
参数： mutex 用来给代码加锁的互斥锁
返回值：成功 0
失败 非零
4、解锁
int pthread_mutex_unlock(pthread_mutex_t *mutex);
功能：将指定的互斥锁解锁。
解锁之后代码不再排他访问，一般加锁解锁同时出现。
参数：用来解锁的互斥锁
返回值：成功 0
失败 非零
5、销毁
int pthread_mutex_destroy(pthread_mutex_t *mutex);
功能：使用互斥锁完毕后需要销毁互斥锁
参数：mutex 要销毁的互斥锁
返回值：成功 0
失败 非零
练习ATM取钱问题:
int atm = 3
有3个ATM机,10个人取钱,用线程模拟取钱的过程
获得ATM机atm-1
sleep(rand()%10) 模拟取钱消耗时间
释放ATM机atm+1
创建10个线程,模拟进入ATM机取钱的过程
#include <stdio.h>
#include <pthread.h>
int atm = 3;
pthread_mutex_t mutex;
void *task(void *arg)
{
while(1)
{
pthread_mutex_lock(&mutex);
if(atm>0)
{
atm--;
printf("%lx get atm\n", pthread_self());
pthread_mutex_unlock(&mutex);
sleep(rand()%10);
pthread_mutex_lock(&mutex);
atm++;
printf("%lx realse atm \n",pthread_self());
pthread_mutex_unlock(&mutex);
break;
}
else
{
pthread_mutex_unlock(&mutex);//特别注意，🔓要成对出现
}
}
return NULL;
}
int main(int argc,char *argv[])
{
pthread_mutex_init(&mutex,NULL);
pthread_t tid[10];
for(int i= 0; i<10;i++)
{
pthread_create(&tid[i],NULL,task,NULL);
}
for(int i =0 ; i<10;i++)
{
pthread_join(tid[i],NULL);
}
pthread_mutex_destroy(&mutex);
return 0;
}
同步
线程的同步 ===》同步
===》有一定先后顺序的对资源的排他性访问。以同步方式访问临界资源，具备互斥的效果
原因：互斥锁可以控制排他访问但没有次序
异步：多个任务同时工作，之间没有干扰
linux下的线程同步 ===》信号量机制 ===》semaphore.h posix
sem_open();
信号量的分类：
1、无名信号量 ==》线程间通信
2、有名信号量 ==》进程间通信
框架：
信号量的定义 ===》信号量的初始化 ==》信号量的PV操作===》信号量的销毁。
1、信号量的定义 ：
sem_t sem;
信号量的类型 信号量的变量
2、信号量的初始化：
int sem_init(sem_t *sem, int pshared, unsigned int value);
功能：将已经定义好的信号量赋值。
参数：sem 要初始化的信号量
pshared = 0 ;表示线程间使用信号量
!=0 ;表示进程间使用信号量
value 信号量的初始值，一般无名信号量
都是二值信号量，0 1 （同步用二值信号量， 计数信号量）
0 表示红灯，进程暂停阻塞
1 表示绿灯，进程可以通过执行
返回值：成功 0
失败 -1；
3、信号量的PV 操作
P ===》申请资源===》申请一个信号量
V ===》释放资源===》释放一个信号量
P操作对应函数 ==》sem_wait();
V操作对应函数 ==》sem_post();
int sem_wait(sem_t *sem);
功能：判断当前sem信号量是否有资源可用。
如果sem有资源(==1)，则申请该资源，程序继续运行
如果sem没有资源(==0)，则线程阻塞等待，一旦有资源
则自动申请资源并继续运行程序。
注意：sem 申请资源后会自动执行 sem = sem - 1;
参数：sem 要判断的信号量资源
返回值：成功 0
失败 -1
int sem_post(sem_t *sem);
功能：函数可以将指定的sem信号量资源释放
并默认执行，sem = sem+1;
线程在该函数上不会阻塞。
参数：sem 要释放资源的信号量
返回值：成功 0
失败 -1；
4、信号量的销毁
int sem_destroy(sem_t *sem);
功能：使用完毕将指定的信号量销毁
参数：sem要销毁的信号量
返回值：成功 0
失败 -1；
1.编写3个线程,线程1负责循环打印A,线程2负责循环打印B,线程3负责循环打印C, 但是要求打印出来的字母顺序总为 A B C
在这里插入代码片
atm练习
#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#include <unistd.h>
#include <stdlib.h>
sem_t sem;
void *task(void *arg)
{
int num = *(int *)arg;
sem_wait(&sem);
printf("%d get ATM\n", num);
sleep(rand()%5);
printf("%d realse ATM\n", num);
sem_post(&sem);
return NULL;
}
int main(int argc, const char *argv[])
{
pthread_t tid[10];
int num[10] = {0};
sem_init(&sem, 0, 3);
for (int i = 0; i < 10; i++)
{
num[i] = i+1;
pthread_create(&tid[i], NULL, task, &num[i]);
}
for (int i = 0; i < 10; i++)
{
pthread_join(tid[i], NULL);
}
sem_destroy(&sem);
return 0;
}