线程创建、死锁与互斥锁

已于 2022-04-15 17:47:51 修改
阅读量266 收藏
点赞数
文章标签： c语言 linux
于 2022-04-15 16:42:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47834139/article/details/124057998
版权

文章目录

前言

本文主要介绍线程的创建与死锁、互斥锁的问题。

一、什么是线程？

线程是进程的一条执行路径。线程在Unix系统下，通常被称为轻量级的进程，可以看作是Unix进程的表亲。

二、线程的创建

1.线程相关知识

一个进程创建后，会首先生成一个缺省的线程，通常称这个线程为主线程(或称控制线程)。所有的线程都是在同一进程空间运行，共享该进程中的全部系统资源，如虚拟地址空间，文件描述符和信号处理等。

pthread_create()：主线程调用创建子线程
pthread_self()：获取线程ID

主线程和子线程的默认关系是：无论子线程执行完毕与否，一旦主线程执行完毕退出，所有子线程执行都会终止。

主线程和子线程通常定义以下两种关系：

1.可会合（joinable）：主线程必须会合可会合的子线程。在主线程的线程函数内部调用子线程对象的wait函数实现，即使子线程能够在主线程之前执行完毕，进入终止态，也必须执行会合操作，否则，系统永远不会主动销毁线程，分配给该线程的系统资源也永远不会释放。

2.相分离（detached）：子线程无需和主线程会合，即相分离的，常用在线程数较多的情况下。

将线程设置为分离状态的两种方法（在默认的情况下，线程是非分离状态的）：

  1. 线程里面调用 pthread_detach(pthread_self())
  2. 在创建线程的属性设置里设置PTHREAD_CREATE_DETACHED属性

函数原型：

int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(start_routine)(void *), void *arg);

Compile and link with -pthread.

相关说明：

  • thread: 一个pthread_t类型的指针，他用来返回该线程的线程ID。
  • attr: 线程的属性，其类型是pthread_attr_t类型，其定义如下：
typedef struct
{
	int						detachstte;		//线程的分离状态
	int						schedpolicy;	//线程的调度策略
	struct sched_param		schedparam;		//线程的调度参数
	int						inheritsched;	//线程的继承性
	int						scope;			//线程的作用域
	size_t					guardsize;		//线程栈末尾的警戒缓冲区大小
	int						stackaddr_set;
	void *					stackaddr;		//线程栈的位置
	size_t					stacksize;		//线程栈的大小
}pthread_attr_t;
  • start_routine: 一个函数指针，它指向的函数原型是 void *func(void *)，是所创建的子线程要执行的任务（函数）
  • arg: 所调用的函数的参数，若有多个参数需要传递给子线程则封装到一个结构体里传进去

2.线程创建示例

#include<stdio.h>
#include<string.h>
#include<errno.h>
#include<stdlib.h>
#include<unistd.h>
#include<pthread.h>

void *thread_worker1(void *args);		//函数声明
void *thread_worker2(void *args);

int main(int argc, char **argv)
{
	int				shared_var = 1000;
	pthread_t		tid;
	pthread_attr_t	thread_attr;

	if( pthread_attr_init(&thread_attr) )		//线程属性初始化
	{
		printf("pthread_attr_init() failure:%s\n",strerror(errno));
		return -1;
	}

	if( pthread_attr_setstacksize(&thread_attr,120*1024) )		//设置线程栈的大小
	{
		printf("pthread_attr_setstacksize() failure:%s\n",strerror(errno));
		return -1;
	}

	if( pthread_attr_setdetachstate(&thread_attr,PTHREAD_CREATE_DETACHED) )		//设置线程的分离状态为相分离状态
	{
		printf("pthread_attr_setdetachstate() failure:%s\n",strerror(errno));
		return -1;
	}

	pthread_create(&tid, &thread_attr,thread_worker1,&shared_var);	//创建线程，thread_worker1为线程要执行的函数，&shared_var为传入thread_worker1的参数
	printf("Thread worker1 tid[%ld] created ok\n",tid);

	pthread_create(&tid,NULL,thread_worker2,&shared_var);	//创建线程，此线程为默认的可会合状态
	printf("Thread worker2 tid[%ld] created ok\n",tid);

	pthread_attr_destroy(&thread_attr);		//摧毁释放设置的线程属性

	/* Wait until thread worker2 exit() */
	pthread_join(tid,NULL);		//主线程调用pthread_join等待可会合状态的线程退出

	while(1)
	{
		printf("Main/Control thread shared_var:%d\n",shared_var);
		sleep(10);
	}
}

void *thread_worker1(void *args)	//子线程1执行的函数
{
	 int		*ptr = (int *)args;

	 if( !args )
	 {
		printf("%s() get invalid arguments\n",__FUNCTION__);
		pthread_exit(NULL);
	 }

	 printf("Thread worker 1 [%ld] start running...\n",pthread_self());

	 while(1)	//让子线程1一直运行
	 {
	 	printf("+++:%s before shared_var++:%d\n",__FUNCTION__,*ptr);	//打印shared_var的值
		*ptr += 1;	//shared_var值加1
		sleep(2);	//睡眠2s
		printf("+++:%s after sleep shared_var:%d\n",__FUNCTION__,*ptr);	//再次打印shared_var的值
	 }

	 printf("Thread worker 1 exit...\n");

	 return NULL;
}

void *thread_worker2(void *args)	//子线程2执行的函数
{
	int		*ptr = (int *)args;

	if( !args )
	{
		printf("%s() get invalid arguments\n",__FUNCTION__);
		pthread_exit(NULL);
	}

	printf("Thread worker 2 [%ld] start running...",pthread_self());

	while(1)	//让子线程2一直运行
	{
		printf("---:%s before shared_var++:%d\n",__FUNCTION__,*ptr);	//打印shared_var的值
		*ptr += 1;	//shared_var的值加1
		sleep(2);	//睡眠2s
		printf("---:%s after sleep shared_var:%d\n",__FUNCTION__,*ptr);	//再次打印shared_var的值
	}

	printf("Thread worker 2 exit...\n");

	return NULL;
}

程序运行结果如下：
在这里插入图片描述

三、互斥锁与死锁

两个或多个线程需要使用同一资源便会产生互斥现象

如果多个线程要调用多个对象，则在上锁的时候可能会出现“死锁”。

死锁产生的4个必要条件：

  • 互斥 ：某种资源一次只允许一个进程访问
  • 占有且等待 ：一个进程本身占有资源，同时还有资源未满足
  • 不可抢占 ：其他进程已占有
  • 循环等待 ：存在一个进程链，每个进程都占有下一个进程所需的至少一种资源

只要这四个条件中至少有一个条件得不到满足，就不可能发生死锁了。由于互斥条件是非共享资源所必须的，应加以保证，所以，主要是破坏产生死锁的其他三个条件。

代码如下（示例）：

 #include <stdio.h>
 #include <string.h>
 #include <errno.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <pthread.h>

 void *thread_worker1(void *args);
 void *thread_worker2(void *args);

 typedef struct worker_ctx_s	//以结构体封装要传递的共享变量shared_var和它相应的互斥锁lock
 {
 		int shared_var;
 		pthread_mutex_t lock;
 } worker_ctx_t;

 int main(int argc, char **argv)
 {
 		worker_ctx_t 		worker_ctx;
 		pthread_t 			tid;
 		pthread_attr_t 		thread_attr;

 		worker_ctx.shared_var = 1000;
 		pthread_mutex_init(&worker_ctx.lock, NULL);		//初始化互斥锁


 		if( pthread_attr_init(&thread_attr) )
 		{
 			printf("pthread_attr_init() failure: %s\n", strerror(errno));
 			return -1;
 		}

 		if( pthread_attr_setstacksize(&thread_attr, 120*1024) )		//设置线程栈大小
 		{
 			printf("pthread_attr_setstacksize() failure: %s\n", strerror(errno));
 			return -1;
 		}

 		if( pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED) )		//设置线程分离状态为相分离
 		{
 			printf("pthread_attr_setdetachstate() failure: %s\n", strerror(errno));
 			return -1;
 		}
 		pthread_create(&tid, &thread_attr, thread_worker1, &worker_ctx);	//创建子线程1
 		printf("Thread worker1 tid[%ld] created ok\n", tid);

 		pthread_create(&tid, &thread_attr, thread_worker2, &worker_ctx);	//创建子线程2
 		printf("Thread worker2 tid[%ld] created ok\n", tid);

 		while(1)	//两子线程均为相分离状态，主线程可运行到此
 		{
 			printf("Main/Control thread shared_var: %d\n", worker_ctx.shared_var);
 			sleep(10);
 		}

 		pthread_mutex_destroy(&worker_ctx.lock);	//摧毁互斥锁
 }

 void *thread_worker1(void *args)		//子线程1执行函数
 {
 		worker_ctx_t *ctx = (worker_ctx_t *)args;

 		if( !args )
 		{
 			printf("%s() get invalid arguments\n", __FUNCTION__);
 			pthread_exit(NULL);
 		}

 		printf("Thread workder 1 [%ld] start running...\n", pthread_self());

 		while(1)
 		{
 			pthread_mutex_lock(&ctx->lock);		//申请锁，阻塞锁,锁被别的线程持有则函数不会返回

 			printf("+++: %s before shared_var++: %d\n", __FUNCTION__, ctx->shared_var);
 			ctx->shared_var ++;
 			sleep(2);
 			printf("+++: %s after sleep shared_var: %d\n", __FUNCTION__, ctx->shared_var);

 			pthread_mutex_unlock(&ctx->lock);	//释放锁，让其他线程可访问shared_var

 			sleep(1);	//延时，否则一个线程拿到锁之后会一直占有该锁，而另一个线程则不能获取到锁
 		}

 		printf("Thread workder 1 exit...\n");

 		return NULL;
 }

 void *thread_worker2(void *args)
 {
 		worker_ctx_t *ctx = (worker_ctx_t *)args;

 		if( !args )
 		{
 			printf("%s() get invalid arguments\n", __FUNCTION__);
 			pthread_exit(NULL);
 		}

	 	printf("Thread workder 2 [%ld] start running...\n", pthread_self());

	 	while(1)
	 	{
	 		if(0 != pthread_mutex_trylock(&ctx->lock) )		//申请锁，非阻塞锁,锁被别的线程占用则返回非0值，没有被占用则返回0
			{
				continue;
	 		}

	 		printf("---: %s before shared_var++: %d\n", __FUNCTION__, ctx->shared_var);
	 		ctx->shared_var ++;
	 		sleep(2);
	 		printf("---: %s after sleep shared_var: %d\n", __FUNCTION__, ctx->shared_var);

	 		pthread_mutex_unlock(&ctx->lock);	//释放锁

	 		sleep(1);	//延时，否则一个线程拿到锁之后会一直占有该锁，另外一个线程则不能获取到锁
	 	}

	 	printf("Thread workder 2 exit...\n");

	 	return NULL;
	 }

程序运行结果如下：
在这里插入图片描述

此木7785
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
互斥锁产生死锁、银行家算法解锁
dianxinlaozong的博客
09-02 477
互斥锁： 操作系统创建一个线程最大的问题就是临界资源和临界区的互斥访问，例如公共换衣就是临界资源，我们在进入到换衣间（临界区）后，就首先上锁； 然后用完离开换衣间（临界区）之后，把锁释放供别人使用。如果有人想去换衣间时发现门锁上了，他也有两种策略： 1、在换衣间门口那里等（阻塞）； 2、暂时先离开等会再过来看（非阻塞）； 死锁： 死锁是指两个或两个以上的线程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在
线程安全(互斥锁)
y2zaijian的博客
08-20 265
线程安全 (这些接口都是C库实现的) 黄牛抢票(黄牛---线程, 票 --- 临界资源) 两个黄牛抢到同一张票, 1. 线程安全指的是多个线程同时运行访问临界资源, 不会导致程序的结果产生二义性, 临界资源: 在同一时刻, 该资源只能被一个执行流所访问, 涉及临界资源的区域 --> 临界区 访问: 在临界区当中对临界资源进行非原子操作,意味着可以被打断 (原子操作是一步完成的,当前操作只有两个结果, 要不完成, 要不未开始) .
【多线程】死锁详解
weixin_48271092的博客
04-18 4043
一、什么是死锁 死锁是指两个或两个以上的线程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞现象，若无外力作用，他们都将无法进行下去。也就是说两个线程在拥有锁的情况下，又尝试获取对方的锁，从而导致程序进入阻塞状态。 手撕死锁代码(面试常考)~ import java.util.concurrent.TimeUnit; /** * 死锁示例 */ public class ThreadDemo17 { public static void main(String[] args) {
java 互锁_同步锁、互锁（死锁）
weixin_42349277的博客
02-13 649
经历了精心动魄的考试系统之后，对锁、多线程的理解进一步加深了，记得在单例模式的时候接触过一点，但那都是皮毛，简单的理解，还是实践后对问题理解的深刻，接下来和大家共同分享学习。死锁的问题出现cpu分给每个线程的时间片是随机的并且有好多都是多个线程共用一个资源，比如现在我们很多的抢火车卖票，火车票是一定的，但卖火车票的窗口到处都有，每个窗口就相当于一个线程，这么多的线程共用所有的火车票这个资源。如果在...
Python Threading 线程/互斥锁/死锁/GIL锁
09-19
总的来说，Python Threading 提供了基本的多线程功能，但需要注意互斥锁的使用以防止数据错误和死锁，同时理解 GIL 对多线程的影响以及如何在适当情况下规避它的限制。正确理解和应用这些概念将有助于编写高效且并发...
【Linux】互斥锁和死锁
DanteKing的博客
04-02 1358
线程互斥、互斥锁、死锁
Python实现的多线程同步与互斥锁功能示例
09-21
### Python实现的多线程同步与互斥锁功能详解 在多线程编程中，确保线程间的正确同步是至关重要的。特别是在多个线程访问共享资源时，如果没有正确的同步机制，可能会导致竞态条件（race condition），从而引发不可...
php 多线程 互斥 锁,互斥锁- pthread_mutex(示例代码)
weixin_39871162的博客
03-18 504
一. 什么是互斥锁计算机中，当多个进程或者线程共享一个临界区(例如：共享内存空间或者全局变量)，如果仅对该临界区读取，不进行内容修改，即使同时多次读取都是没有问题的。但是，当我们需要修改临界区内的内容时，我们就必须面对一个情况：同时有多个操作对临界区的内容进行修改，在操作完后，保留的是那一次操作的结果？为了解决这个问题，可以规定对临界区的修改操作，同时最多只能有一个来修改。程序中实现的方法之一就是...
互斥锁和死锁
weixin_51052238的博客
10-07 1076
线程的创建 pthread_create 功能：创建一个新的线程 头文件：#include <pthread.h>（下面函数都包含该头文件） 函数原型：int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg); 参数： thread：线程的ID（只需要定义一个相同类型的变量，将其地址放入即可） attr：
线程间通信-互斥锁，死锁
蒲公英的诗与远方
03-18 459
（一）临界资源的概念 临界资源是指一次只允许一个任务（进程、线程）访问的共享资源，具有独占性。 （二）临界区 临界区就是指访问临界资源的代码。 （三）互斥机制（互斥锁） linux下提供一个互斥机制：mutex互斥锁，即任务（进程、线程）访问临界资源前申请锁，访问完后释放锁。 （四）互斥锁和信号量(灯)、互斥和同步的区别 信号量是一个线程完成了某一任务后，通过信号量告诉别的线程可以进行操作了。 互...
Java中的锁（1）：同步、异步、互斥、死锁
区块链之美
08-14 4955
主线：互斥锁 ---&gt; 死锁 ---&gt; 乐观锁与悲观锁 ---&gt; 数据库中的锁（并发插入如何避免重复插入） 一、线程同步、异步、互斥 1、线程同步：          是指多个线程通过特定的设置（如互斥量、事件对象、临界区）来控制线程之间的执行顺序。这里的同步不是同时进行。    也就是说，线程之间通过同步建立起执行顺序的关系，如果没有同步，那线程之间是各自运行各自的！  ...
多线程中的互锁现象
To_be_Designer
08-04 9419
互锁现象　　在多线程中经常会出现线程间的互锁现象。 　　进程间的互锁，假设有两个线程，线程1的完成需要用线程2 的资源，线程2的完成需要用线程1的资源。当两个线程都启动后，线程1 等待线程2 的资源， 线程2 等待线程1 的资源，以致于两个线程都没办法完成，都在等待状态。这种现象就叫做线程间的互锁。//线程1 public class LockRunnable1 implements Runna
同步锁、互锁（死锁）
01-15 5703
经历了精心动魄的活动之后，对，锁、多线程的理解进一步加深了，记得在单例模式的时候接触过一点，但那都是皮毛，简单的理解。接下来和大家共同分享学习 java中cpu分给每个线程的时间片是随机的并且在java中好多都是多个线程共用一个资源，比如现在我们很多的抢火车卖票，火车票是一定的，但卖火车票的窗口到处都有，每个窗口就相当于一个线程，这么多的线程共用所有的火车票这个资源。如果在一个时间点上，两个线程
线程的互斥与死锁问题
simplehap的博客
05-25 1334
线程的互斥 图中g_count是全局变量，从0开始。线程1和线程2对g_count进行++（5000次）操作。 如果线程1刚拿到g_count，被切断，然后线程2进行对g_count进行++，然后被g_count++到5000，线程2结束，此时将g_count变为了5000，再进行线程1操作，此时线程1拿到了最开始的0，就从0开始++，结果将g_count覆盖。 正常结果应该加到10000，但
线程之互斥锁与死锁
热门推荐
心飞扬
06-05 1万+
互斥锁： 1、互斥锁基本原理： 互斥锁是一个二元变量，其状态为开锁(允许0)和上锁(禁止1)，将某个共享资源与某个特定互斥锁在逻辑上绑定(要申请该资源必须先获取锁)。 (1)访问公共资源前，必须申请该互斥锁，若处于开锁状态，则申请到锁对象，并立即占有该锁，以防止其他线程访问该资源；如果该互斥锁处于锁定状态，则阻塞当前线程。 (2)只有锁定该互斥锁的进程才能释放
线程的创建与互斥锁
qq_40674996的博客
09-02 378
一、创建线程 1、编译链接库 gcc –lpthead 2、定义变量 pthread_t th; 3、创建 int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg); pthread_create(&th, NULL, ...
Python线程同步互斥与死锁解析
"本文主要探讨了Python线程中的同步互斥和死锁问题，强调了在多线程环境中，如何通过同步互斥机制确保共享资源的有序访问，防止数据混乱和错误。文中提到了线程间通信的方式，尤其是通过全局变量进行通信，以及线程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值