线程之间的同步|线程锁|线程的创建、取消

最新推荐文章于 2022-05-21 15:41:10 发布

DearLord

最新推荐文章于 2022-05-21 15:41:10 发布

阅读量241

点赞数

本文链接：https://blog.csdn.net/DearLord/article/details/103056285

版权

/*
通过线程之间互相聊天这个练习，我们可以知道，在一个多线程并发的进程当中，到底是哪一个线程在运行，我们是没有办法控制的。
那么，我了能够控制线程之间的运行关系，我们在多线程编程的时候，对所有的线程做同步处理。
什么叫同步处理：也就是说，当一个线程不满足逻辑运行条件的时候，我们就应该让这个线程处于阻塞状态，以便不会影响到选择其他线程的时候的运行效果
在聊天这个功能当中，我们使用了大量的标志位来确保线程之间的同步，但是，使用标志位来确保同步的话，有一个非常致命的问题：
当我们自己编写的同步逻辑在执行过程中，由于他也是属于线程的一部分，如果此时，同步逻辑执行到一半，线程的时间片结束，那么此时，就有可能导致有一部分的线程没有被同步到位，导致逻辑错误：
举例，有5个线程1,2,3,4,5，同步要求是严格的按照顺序依次执行
1号线程中有4个标志位，在1号线程开始运行的时候，会关闭4个标志位，导致2,3,4,5号无法运行。当1号线程完成运行的时候，再打开4个标志位
问题在于，如果1号线程运行到关闭2,3号标志位的时候，时间片使用完毕，4,5号线程没有被关闭，那么下一次时间片的抢夺就会由1,4,5来抢夺。
所以，我们在进程线程间同步操作的时候，必须使用原子操作法
什么是原子操作法：这里的原子操作，保证操作的完整性，也就是说，不会因为时间片结束而在原子操作中的某一步中断操作。原子操作一定是从到到位一次性执行完毕
/
/
线程之间的同步，有哪些手段：
① 互斥锁：pthread_mutex_t mutex;
互斥锁的使用原理：在那个上创建一把虚拟的锁，该锁初始化后处于打开状态。互斥锁的特性为：如果关闭锁后，想要再次关闭，必须等待互斥锁打开后才能关闭。如果互斥锁处于打开状态，如果有其他线程想要打开互斥锁，该互斥锁不会有任何的改变
互斥锁的使用方式：
1：创建一个互斥锁: pthread_mutex_t mutex
2：初始化互斥锁(将真正的锁绑定到变量mutex上):pthread_mutex_init(&mutex,0);第二个参数0代表互斥锁属性为默认
3：加锁或者解锁：pthread_mutex_lock(&mutex)以及pthread_mutex_unlock(&mutex)
4：互斥锁使用完毕后记得销毁，pthread_mutex_destroy(&mutex)
② 信号量:
信号量的工作原理：在同步原理上和互斥锁是相似的，但是在操作范围上，他的可操作范围比互斥锁更大。
互斥锁打开的状态再次打开不会有任何变化，也就是说，打开2次，也只需关闭一次就关闭了
但是信号量是一个可叠加的量。当信号量为0的时候，此时信号量已经没有量了，所以无法再次做减量操作，所以这个时候一旦做减量操作就会阻塞。直到信号量>0的时候，该减量操作才会解除阻塞
如果一个信号量通过增量操作或者初始化的时候为2，那么此时对他进行1次减量操作不会阻塞，2次也不会阻塞，第三次减量操作阻塞。
信号量的操作方式：
1：创建信号量 sem_t sem
2：初始化信号量:sem_init
参数有: sem_t semid , int pshared , unsigned int value
参数分析:初始化指定semid的信号量，并将该信号量的值初始化成value(当value为0时，该信号量做减量操作就会阻塞)，并且将该信号量设置成pshared类型。通常情况下，pshared传0，代表该信号量在同一个用户内通用(可以在多个进程间共享)
3:对信号量做增量或者减量操作
增量操作:sem_post(&sem)
减量操作:sem_wait(&sem);
4:摧毁信号量：sem_destroy(&sem);
*/

线程的创建|取消

/*
线程的概念：线程是进程的最小组成部分，一个进程最起码是由一个线程所构成的。
当一个进程抢占到时间片之后，会将时间片继续分配给属于该进程的线程去抢夺，抢占到时间片的线程则会运行自己。
不同于进程，开辟一个新的进程需要完整的复制父进程的所有资源，开辟一个线程只需要在线程表上多一个序号。因为一个进程中的所有线程，共享该进程的所有资源。也就是说，当一个线程修改一个进程的全局变量的时候，另一个线程也会访问到修改的数据。
那么如何创建一个线程：使用函数 pthread_create
函数名：pthread_create
头文件：pthread.h,注意pthread系列函数，他的库文件并不会在编译的时候自动链接，所以我们如果使用到线程，那么在编译的时候，必须最后加上 -lpthread
函数参数：pthread_t* thread , const pthread_attr_t* attr , void* (start)(void),void* arg
参数分析：
1：thread 想要启动的线程id。他的工作原理是，先创建一个毫不相干的thread，然后在启动线程的时候将&thread传入，让这个线程的id与thread绑定。所以本质上来说，启动一个线程的时候，线程的id是自动分配，只不过我们为了在线程外部获取到该线程的id，我们会传入一个能够保存线程id的地址，然后让该线程的id保存到该地址上
2：attr 线程的属性，最常用的属性为分离式属性，但是分离式线程有更简单的设定方法，所以通常情况下，attr我们都会设置成NULL。
反过来说，如果要设置线程属性的话，必须先创建一个attr，然后通过特定方式更改attr的属性，然后传入&attr，以attr当前的属性来设置线程的属性
3：start 线程的入口函数，所有线程，都是从start开始运行的
4：arg start函数的参数，也就是说，如果一个线程想要传递给另一个线程特定的数据，只能通过这一个参数来传递
/
/
线程也是需要回收资源的，使用函数pthread_join来回收资源
函数名：pthread_join
函数参数：pthread_t thread , void** retval
函数分析：指定回收线程thread，并且将thread线程的返回值赋值给retval
线程也可以函数来结束运行：分别为pthread_exit 和 pthread_cancel
pthread_exit只能线程本身自行结束，pthread_cancel可以结束自己，也可以结束别的线程
函数名：pthread_exit
函数参数：void* retval
函数分析：立刻结束线程自身，并且将retval作为线程的返回值返回

	函数名：pthread_cancel
	函数参数：pthread_t thread
	函数分析：指定结束线程号为thread的线程

	当然，还有第三种方法可以回收线程的资源：使用函数pthread_detach
		函数名:pthread_detach
		函数参数:pthread_t thread
		函数分析:将线程号为thread的线程，设置成分离式线程，分离式线程的特点就是，当线程结束运行之后，他的资源就会有系统自动回收，无需再次调用join，所以也就不存在因为join的原因而将主线程阻塞。但是，使用这种方式，主线程将无法获得子线程的返回值。

/*
编写一个程序，该程序是3个同步运行的线程，1号线程打印A，2号线程打印B，3号线程打印C
要求，打印数学永远是A_B_C_A_B_C,_代表休眠1秒
使用信号量实现
*/
#include<stdio.h>
#include<sys/types.h>
#include<pthread.h>
#include<unistd.h>
#include<string.h>
#include<semaphore.h>
#include<signal.h>
#include<stdlib.h>

sem_t sem1;
sem_t sem2;
sem_t sem3;
pthread_t t1;
pthread_t t2;

void* thread1_start(void* arg){
while(1){
sem_wait(&sem2);
printf(“B\n”);
sleep(1);
sem_post(&sem3);
}
}

void* thread2_start(void* arg){
while(1){
sem_wait(&sem3);
printf(“C\n”);
sleep(1);
sem_post(&sem1);
}
}

void sighandler(int signum){
if(signum == SIGINT){
pthread_cancel(t1);
pthread_cancel(t2);
pthread_join(t1,0);
pthread_join(t2,0);
sem_destroy(&sem1);
sem_destroy(&sem2);
sem_destroy(&sem3);
exit(0);
}
}

int main(){
sem_init(&sem1,0,1);
sem_init(&sem2,0,0);
sem_init(&sem3,0,0);
pthread_t thread1;
pthread_t thread2;
pthread_create(&thread1,0,thread1_start,0);
pthread_create(&thread2,0,thread2_start,0);
//pthread_detach(thread1);
//pthread_detach(thread2);
t1 = thread1;
t2 = thread2;
signal(SIGINT,sighandler);
while(1){
sem_wait(&sem1);
printf(“A\n”);
sleep(1);
sem_post(&sem2);
}
return 0;
}

/*
编写一个程序，该程序有父子两个线程，父线程打印A，子线程打印B
要求，父子线程交替打印，并且父线程打印完成后1秒，子线程再打印，子线程打印完成后1秒，父线程继续打印
*/
#include<stdio.h>
#include<sys/types.h>
#include<pthread.h>
#include<unistd.h>
#include<string.h>
#include<signal.h>
#include<stdlib.h>

pthread_mutex_t mutex1;
pthread_mutex_t mutex2;
pthread_t temp;

void* thread_start(void* arg){
while(1){
pthread_mutex_lock(&mutex2);
printf(“a\n”);
sleep(1);
pthread_mutex_unlock(&mutex1);
}
}

void sighandler(int signum){
if(signum == SIGINT){
pthread_cancel(temp);
pthread_join(temp,0);
pthread_mutex_destroy(&mutex1);
pthread_mutex_destroy(&mutex2);
exit(0);
}
}

int main(){
pthread_mutex_init(&mutex1,0);
pthread_mutex_init(&mutex2,0);
signal(SIGINT,sighandler);
pthread_t thread;
pthread_create(&thread,0,thread_start,0);
temp = thread;
pthread_mutex_lock(&mutex2);
while(1){
pthread_mutex_lock(&mutex1);
printf(“A\n”);
sleep(1);
pthread_mutex_unlock(&mutex2);
}
return 0;
}

/*
编写一个程序，实现功能：一个进程中的2个线程之间互相聊天
要求：不能做成只能一读一写
由于结构限制，可以设定最多一次性接受多少条消息
*/
#include<stdio.h>
#include<sys/types.h>
#include<pthread.h>
#include<unistd.h>
#include<string.h>

typedef struct Pack{
int thread1_readok;//当有消息发送到1号线程的时候，这个数据从0变成非0
int thread1_ok;
int thread2_readok;
int thread2_ok;
int lock1;
int lock2;
char text1[100];
char text2[100];
//char text3[100];
}pack_t;

pack_t pack;

void* thread1_read_start(void* arg){
while(1){
if(pack.thread1_readok!=0){
printf(“2号线程发来消息:%s\n”,pack.text1);
pack.thread1_readok–;
}
}
}

void* thread2_read_start(void* arg){
while(1){
if(pack.thread2_readok!=0){
printf(“1号线程发来消息:%s\n”,pack.text1);
pack.thread2_readok–;
}
}
}

void* thread1_start(void* arg){
pthread_t thread1_read;
pthread_create(&thread1_read,0,thread1_read_start,0);
while(1){
if(pack.lock1!=0){
printf(“1号线程发送内容:\n”);
scanf("%s",pack.text1);
while(getchar()!=10);
pack.thread2_readok++;
pack.thread2_ok++;
pack.lock1 = 0;
}
}
}

void* thread2_start(void* arg){
pthread_t thread2_read;
pthread_create(&thread2_read,0,thread2_read_start,0);
while(1){
if(pack.lock2!=0){
printf(“2号线程发送内容:\n”);
scanf("%s",pack.text1);
while(getchar()!=10);
pack.thread1_readok++;
pack.thread1_ok++;
pack.lock2 = 0;
}
}
}

int main(){
memset(&pack,0,sizeof(pack_t));
pthread_t thread1;
pthread_t thread2;
pthread_create(&thread1,0,thread1_start,0);
pthread_create(&thread2,0,thread2_start,0);
int ch = 0;
while(1){
printf(“1:1号线程发送消息\n”);
printf(“2:2号线程发送消息\n”);
printf(“请选择:”);
scanf("%d",&ch);
while(getchar()!=10);
switch(ch){
case 1:
pack.lock1 = 1;
break;
case 2:
pack.lock2 = 1;
break;
}
while(pack.thread1_ok0 && pack.thread2_ok0);
pack.thread1_ok = 0;
pack.thread2_ok = 0;
printf(“下一次循环\n”);
}
/if(ch1){
pack.lock2 = 0;
}
if(ch2){
pack.lock1 = 0;
}/
return 0;
}

pthread_mutex_t mutex1;
pthread_mutex_t mutex2;
pthread_t temp;

void* thread_start(void* arg){
while(1){
pthread_mutex_lock(&mutex2);
printf(“a\n”);
sleep(1);
pthread_mutex_unlock(&mutex1);
}
}

void sighandler(int signum){
if(signum == SIGINT){
pthread_cancel(temp);
pthread_join(temp,0);
pthread_mutex_destroy(&mutex1);
pthread_mutex_destroy(&mutex2);
exit(0);
}
}

pack_t pack;

void* thread1_read_start(void* arg){
while(1){
if(pack.thread1_readok!=0){
printf(“2号线程发来消息:%s\n”,pack.text1);
pack.thread1_readok–;
}
}
}

void* thread2_read_start(void* arg){
while(1){
if(pack.thread2_readok!=0){
printf(“1号线程发来消息:%s\n”,pack.text1);
pack.thread2_readok–;
}
}
}

#include<stdio.h>
#include<sys/types.h>
#include<pthread.h>
#include<unistd.h>
#include<string.h>
#include<semaphore.h>

sem_t sem1;
sem_t sem2;

void* thread_start(void* arg){
while(1){
sem_wait(&sem2);
printf(“接收到的内容为:%s\n”,(char*)arg);
sem_post(&sem1);
}
}

int main(){
char text[100] = {0};
sem_init(&sem1,0,1);
sem_init(&sem2,0,0);

pthread_t thread;
pthread_create(&thread,0,thread_start,text);

while(1){
	sem_wait(&sem1);
	printf("请输入发送内容:");
	scanf("%s",text);
	while(getchar()!=10);
	sem_post(&sem2);
}
return 0;

}

#include<stdio.h>
#include<sys/types.h>
#include<pthread.h>
#include<unistd.h>
#include<string.h>

pthread_mutex_t mutex1;
pthread_mutex_t mutex2;

void* thread_start(void* arg){
while(1){
pthread_mutex_lock(&mutex2);
printf(“接收到的内容为:%s\n”,(char*)arg);
pthread_mutex_unlock(&mutex1);
}
}

int main(){
char text[100] = {0};
pthread_t thread;
pthread_mutex_init(&mutex1,0);
pthread_mutex_init(&mutex2,0);
pthread_create(&thread,0,thread_start,text);
pthread_mutex_lock(&mutex2);
while(1){
pthread_mutex_lock(&mutex1);
printf(“请输入发送内容:”);
scanf("%s",text);
while(getchar()!=10);
pthread_mutex_unlock(&mutex2);
}
return 0;
}

#include<stdio.h>
#include<sys/types.h>
#include<pthread.h>
#include<unistd.h>

int i = 0;

void* thread_start(void* arg){
for(;1;i++){
printf("%d\n",i);
sleep(1);
}
}

int main(){
pthread_t thread;
pthread_create(&thread,0,thread_start,0);
//char buf[20] = {0};
while(1){
if(i>=5){
pthread_cancel(thread);
pthread_join(thread,0);
printf(“子线程资源回收完毕\n”);
break;
}
}
return 0;
}

#include<stdio.h>
#include<sys/types.h>
#include<pthread.h>
#include<unistd.h>

void* thread_start(void* arg){
static char buf[20] = “hello world”;
pthread_exit(buf);
//return buf;
}

int main(){
pthread_t thread;
pthread_create(&thread,0,thread_start,0);
//char buf[20] = {0};
void* pbuf = 0;
pthread_join(thread,&pbuf);
printf(“buf = %s\n”,(char*)pbuf);
return 0;
}

#include<stdio.h>
#include<sys/types.h>
#include<pthread.h>
#include<unistd.h>

void* thread_start(void* arg){
char* str = (char*)arg;
while(1){
printf("%s\n",str);
sleep(1);
}
}

int main(){
char buf[20] = “world”;
pthread_t thread;
pthread_create(&thread,0,thread_start,buf);
pthread_detach(thread);
while(1){
printf("hello ");
sleep(1);
}
return 0;
}

DearLord

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
线程之间的同步|线程锁|线程的创建、取消

/*通过线程之间互相聊天这个练习，我们可以知道，在一个多线程并发的进程当中，到底是哪一个线程在运行，我们是没有办法控制的。那么，我了能够控制线程之间的运行关系，我们在多线程编程的时候，对所有的线程做同步处理。什么叫同步处理：也就是说，当一个线程不满足逻辑运行条件的时候，我们就应该让这个线程处于阻塞状态，以便不会影响到选择其他线程的时候的运行效果在聊天这个功能当中，我们使用了大量的标志位来确...
复制链接

扫一扫