Linux学习之系统编程7(线程同步/互斥锁/信号量/条件变量）

最新推荐文章于 2024-05-17 16:41:20 发布
最新推荐文章于 2024-05-17 16:41:20 发布
阅读量1.6k 收藏 23
点赞数 56
分类专栏： Linux 文章标签： linux 学习 Linux系统编程 线程同步 生产者消费者模型 互斥锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yourgrandfather_/article/details/135460669
版权

写在前面：

我的Linux的学习之路非常坎坷。第一次学习Linux是在大一下的开学没多久，结果因为不会安装VMware就无疾而终了，可以说是没开始就失败了。第二次学习Linux是在大一下快放暑假（那个时候刚刚过完考试周），我没什么事做就又重拾Linux，不服输的我选择再战Linux，这一次学习还算顺利，虽然中间有些小插曲但是不影响整体学习进度， 我看着B站上的视频一点点学习Linux，基本上把Linux的基础指令学完了。学完之后我又遇到问题了，视频基本上到这就结束了，而我却不知道下一步该学什么，于是就没怎么碰Linux，结果没过多长时间我就把学的Linux指令忘的一干二净。现在是我第三次学习Linux，我决定重新开始学Linux，同时为了让自己学习的效果更好，我选择以写blog的形式逼迫自己每天把学习到的Linux知识整理下来。这也就是我写这个系列blog的原因。

线程同步

概念：

协同步调，对公共区数据按序访问，防止数据混乱，产生与时间有关的错误。

数据混乱的原因：

  • 资源共享（独享资源则不会）
  • 调度随机（意味着数据访问会出现竞争）
  • 线程间缺乏必要同步机制

解决方法

使用锁。建议锁！对公共数据进行保护。所有线程应该在访问公共数据前先拿锁在访问，但锁本身不具备强制性。

这段话可能有点绕，我在这里稍微解释一下。正确使用锁可以保证线程同步，但你也可以不使用锁直接去访问公共数据，也可以访问到，但这样就不能保证线程同步，就是说程序本身并不能强制你使用锁。

数据混乱的演示

源代码：

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

pthread_mutex_t mutex;

void sys_err(char* str,int errno)
{
	fprintf(stderr,"%s:%s",str,strerror(errno));
	exit(-1);
}

void* fun(void* arg)
{
	while(1)
	{
		printf("hellow ");
		sleep(rand()%3);
		printf("world\n");
		sleep(rand()%3);
	}
	return NULL;
}


int main()
{
	pthread_t tid;
	srand(time(NULL));
	int res=pthread_mutex_init(&mutex,NULL);
	if(res!=0)
		sys_err("init error",res);
	res=pthread_create(&tid,NULL,fun,NULL);
	if(res!=0)
		sys_err("pthread create error",res);
	while(1)
	{
		printf("HELLOW ");
		sleep(rand()%3);
		printf("WORLD\n");
		sleep(rand()%3);
	}
	return 0;
}

效果：
1

我们可以看到，我们的本意是让大写的“HELLOW WORLD”和小写的“hellow world”在一行输出，这里的公共资源是屏幕STDOUT_FILENO，但是由于我们让每一个线程打印完上一句话就睡一下，这样就会导致线程混乱。

借助互斥锁实现线程同步

相关函数的介绍

  • pthread_mutex_t mutex这个不是函数，是一个类型。是后面函数都会用到的参数。
  • int pthread_mutex_init(pthread_mutex_t* restrict mutex,const pthread_mutexattr_t* restrict attr);创建
  • int pthread_mutex_destory(pthread_mutex* mutex);销毁
  • int pthread_mutex_lock(pthread_mutex_t *mutex);上锁
  • int pthread_mutex_trylock(pthread_mutex_t *mutex);尝试上锁
  • int pthread_mutex_unlock(pthread_mutex_t *mutex);解锁

restrict（关键字）: 用来限定指针变量。被该关键字限定的指针变量所指向的内存操作，必须由本指针完成。

pthread_mutex_t 类型，其本质是一个结构体。为简化理解，应用时可忽略其实现细节，简单当成整数看待pthread_mutex_t mutex；变量mutex只有两种取值：0,1

使用锁（互斥量，互斥锁）的一般步骤

  1. pthread_mutex_t lock; 创建锁
  2. pthread_mutex_init; 初始化
  3. pthread_mutex_lock;加锁
  4. 访问共享数据
  5. pthrad_mutext_unlock();解锁
  6. pthead_mutex_destroy；销毁锁

初始化互斥量

  1. 动态初始化：pthread_mutex_init(&mutex,NULL);
  2. 静态初始化：pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER

举个栗子

我们还是实现上面的功能，只不过这次我们加锁，实现大写的在一行，小写的在一行。
源代码：

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

pthread_mutex_t mutex;

void sys_err(char* str,int errno)
{
	fprintf(stderr,"%s:%s\n",str,strerror(errno));
	exit(-1);
}

void* fun(void* arg)
{
	while(1)
	{
		pthread_mutex_lock(&mutex);
		printf("hellow ");
		sleep(rand()%3);
		printf("world\n");
		pthread_mutex_unlock(&mutex);
		sleep(rand()%3);
	}
	return NULL;
}


int main()
{
	pthread_t tid;
	srand(time(NULL));
	int res=pthread_mutex_init(&mutex,NULL);
	if(res!=0)
		sys_err("mutex init",res);
	res=pthread_mutex_init(&mutex,NULL);
	if(res!=0)
		sys_err("init error",res);
	res=pthread_create(&tid,NULL,fun,NULL);
	if(res!=0)
		sys_err("pthread create error",res);
	while(1)
	{
		pthread_mutex_lock(&mutex);
		printf("HELLOW ");
		sleep(rand()%3);
		printf("WORLD\n");
		pthread_mutex_unlock(&mutex);
		sleep(rand()%3);
	}
	return 0;
}

效果：
2

使用技巧

注意事项

  • 尽量保证锁的粒度， 越小越好。（访问共享数据前，加锁。访问结束立即解锁。）
  • 互斥锁，本质是结构体。 我们可以看成整数。 初值为 1。（pthread_mutex_init() 函数调用成功）

技巧

  • 加锁： --操作， 阻塞线程。
  • 解锁： ++操作， 唤醒阻塞在锁上的线程。
  • try锁：尝试加锁，成功–。失败，返回。同时设置错误号 EBUSY

两种死锁

  1. 对一个锁反复加锁
    源代码：
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<pthread.h>

pthread_mutex_t mutex;

int main()
{
	pthread_t tid;
	pthread_mutex_init(&mutex,NULL);
	pthread_mutex_lock(&mutex);
	pthread_mutex_lock(&mutex);
	printf("hello linux\n");
	return 0;
}

效果就是光标一直在闪，程序一直阻塞在那里。

  1. 两个线程，各自持有一把锁，请求另一把锁
    源代码：
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<pthread.h>

pthread_mutex_t mutex1;
pthread_mutex_t mutex2;

void* fun(void* arg)
{
	pthread_mutex_lock(&mutex2);
	sleep(1);
	printf("hello linux\n");
	pthread_mutex_lock(&mutex1);
	return NULL;
}

int main()
{
	pthread_t tid;
	pthread_mutex_init(&mutex1,NULL);
	pthread_mutex_init(&mutex2,NULL);
	pthread_create(&tid,NULL,fun,NULL);
	pthread_mutex_lock(&mutex1);
	sleep(1);
	printf("HELLO LINUX\n");
	pthread_mutex_lock(&mutex2);	
	printf("hello linux\n");
	return 0;
}

效果和上面一种死锁一样，光标一直在那闪。

读写锁

原理

  • 锁只有一把。以读方式给数据加锁——读锁。以写方式给数据加锁——写锁。
  • 读共享，写独占。
  • 写锁优先级高。
  • 相较于互斥量而言，当读线程多的时候，提高访问效率。

相关函数

  • pthread_rwlock_t rwlock;这不是函数，是个类型。
  • pthread_rwlock_init(&rwlock, NULL);:创建
  • pthread_rwlock_rdlock(&rwlock);：加读锁
  • pthread_rwlock_wrlock(&rwlock);：加写锁
  • pthread_rwlock_unlock(&rwlock);：解锁
  • pthread_rwlock_destroy(&rwlock);销毁锁

举个栗子

由于这个读写不是重点，我就不亲自写了。
源代码：
1
效果：
2

条件变量

条件变量不是锁，但是通常结合锁来使用。

相关函数

  • pthread_cond_t cond;这不是函数，是一个类型
  • pthread_cond_init();：创建条件变量
  • pthread_cond_destroy();：销毁条件变量
  • pthread_cond_wait();：阻塞等待条件
  • pthread_cond_timewait();：有时限的阻塞等待条件
  • pthread-cond_signal();：至少通知一个阻塞等待的条件变量
  • pthread-cond_broadcast();通知所有阻塞等待的条件变量

初始化条件变量

  1. 动态初始化：pthread_cond_init(&cond,NULL);
  2. 静态初始化：pthread_cond_t cond=PTHREAD_COND_INITIALIZER;

重点函数讲解

pthread_cond_wait(&cond,&mutex)
作用

  1. 阻塞等待条件变量满足
  2. 解锁已经加锁成功的信号量 （相当于 pthread_mutex_unlock(&mutex)），1,2两步为一个原子操作.
  3. 当条件满足，函数返回时，解除阻塞并重新申请获取互斥锁。重新加锁信号量 （相当于pthread_mutex_lock(&mutex);）

条件变量的生产者和消费者模型

思路：

1

单个消费者模型

源代码：

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

struct mesg
{
	int num;
	struct mesg* next;
};

struct mesg* head;

pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond=PTHREAD_COND_INITIALIZER;

void sys_err(char* str,int errno)
{
	fprintf(stderr,"%s:%s\n",str,strerror(errno));
	exit(-1);
}

void* produser(void* arg)
{
	while(1)
	{
		struct mesg* m=malloc(sizeof (struct mesg));
		m->num=rand()%1000+1;
		printf("---produce:%d\n",m->num);
		pthread_mutex_lock(&mutex);
		m->next=head;
		head=m;
		pthread_mutex_unlock(&mutex);
		pthread_cond_signal(&cond);
		sleep(rand()%3);
	}
	return NULL;
}

void* consumer(void* arg)
{
	while(1)
	{
		struct mesg* m;
		pthread_mutex_lock(&mutex);
		if(head==NULL)
			pthread_cond_wait(&cond,&mutex);
		m=head;
		head=m->next;
		pthread_mutex_unlock(&mutex);
		printf("----------consume:%d\n",m->num);
		free(m);
		sleep(rand()%3);
	}
	return NULL;
}
		


int main()
{
	pthread_t tid_pro,tid_con;
	srand(time(NULL));
	int res=pthread_create(&tid_pro,NULL,produser,NULL);
	if(res!=0)
		sys_err("pthread create error",res);
	res=pthread_create(&tid_con,NULL,consumer,NULL);
	if(res!=0)
		sys_err("pthread create error",res);
	pthread_detach(tid_pro);	//if use this way,must use pthread_exit to exit main pthread.
	pthread_detach(tid_con);
//	pthread_join(tid_pro,NULL);
//	pthread_join(tid_con,NULL);
//	return 0;
	pthread_exit(0);
}

效果：
2

多个消费者模型

源代码：

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

struct mesg
{
	int num;
	struct mesg* next;
};

struct mesg* head;

pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond=PTHREAD_COND_INITIALIZER;

void sys_err(char* str,int errno)
{
	fprintf(stderr,"%s:%s\n",str,strerror(errno));
	exit(-1);
}

void* produser(void* arg)
{
	while(1)
	{
		struct mesg* m=malloc(sizeof (struct mesg));
		m->num=rand()%1000+1;
		printf("---produce:%d\n",m->num);
		pthread_mutex_lock(&mutex);
		m->next=head;
		head=m;
		pthread_mutex_unlock(&mutex);
		pthread_cond_signal(&cond);
		sleep(rand()%3);
	}
	return NULL;
}

void* consumer(void* arg)
{
	int i=(int) arg;
	while(1)
	{
		struct mesg* m;
		pthread_mutex_lock(&mutex);
		while(head==NULL)
			pthread_cond_wait(&cond,&mutex);
		m=head;
		head=m->next;
		pthread_mutex_unlock(&mutex);
		printf("%dth consumer----------consume:%d\n",i,m->num);
		free(m);
		sleep(rand()%3);
	}
	return NULL;
}
		


int main()
{
	pthread_t tid_pro,tid_con1,tid_con2,tid_con3;
	srand(time(NULL));
	int res=pthread_create(&tid_pro,NULL,produser,NULL);
	if(res!=0)
		sys_err("pthread create error",res);
	res=pthread_create(&tid_con1,NULL,consumer,(void*)1);
	if(res!=0)
		sys_err("pthread create error",res);
	res=pthread_create(&tid_con2,NULL,consumer,(void*)2);
	if(res!=0)
		sys_err("pthread create error",res);
	res=pthread_create(&tid_con3,NULL,consumer,(void*)3);
	if(res!=0)
		sys_err("pthread create error",res);
//	pthread_detach(tid_pro);	
//	pthread_detach(tid_con);
	pthread_join(tid_pro,NULL);
	pthread_join(tid_con1,NULL);
	pthread_join(tid_con2,NULL);
	pthread_join(tid_con3,NULL);
	return 0;
}

效果：
3

注意事项
我们在多个消费者模型一定在消费者线程中把等待阻塞的判断从if改成while.

  1. 两个消费者都阻塞在条件变量上，就是说没有数据可以消费。
  2. 完事儿都把锁还回去了，生产者此时生产了一个数据，会同时唤醒两个因条件变量阻塞的消费者，完事儿两个消费者去抢锁。
  3. 结果就是A消费者拿到锁，开始消费数据，B消费者阻塞在锁上（如下图）。
  4. 之后A消费完数据，把锁归还，B被唤醒，然而此时已经没有数据供B消费了。
  5. 所以这里有个逻辑错误，消费者阻塞在条件变量那里应该使用while循环。这样A消费完数据后，B做的第一件事不是去拿锁，而是判定条件变量。
    4
    实测，如果不改的话就会发生段错误。

信号量实现生产者和消费者模型

信号量的作用

  • 应用于线程、进程间同步。
  • 相当于 初始化值为 N 的互斥量。 N值，表示可以同时访问共享数据区的线程数。

相关的函数

  • sem_t sem这不是函数，是类型。
  • int sem_init(sem_t *sem, int pshared, unsigned int value);创建信号量
  • sem_destroy();:销毁信号量
  • sem_wait();:一次调用，做一次-- 操作， 当信号量的值为 0 时，再次 – 就会阻塞。 （对比 pthread_mutex_lock）
  • sem_post();:一次调用，做一次++ 操作. 当信号量的值为 N 时, 再次 ++ 就会阻塞。（对比 pthread_mutex_unlock）

重要函数

int sem_init(sem_t *sem, int pshared, unsigned int value);
参数：

  • sem:信号量
  • pshared:0表示线程同步，1表示进程同步
  • value:N值。（指定同时访问的线程数）

模型

源代码：

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

#define MAX 5
sem_t blank,product;
int queue[MAX];

void* producer(void* arg)
{
	int i=0;
	while(1)
	{
		sem_wait(&blank);
		queue[i]=rand()%1000+1;
		sem_post(&product);
		printf("-------------producer:%d\n",queue[i]);
		i=(i+1)%MAX;
		sleep(rand()%2);
	}
	return NULL;
}

void* consumer(void* arg)
{
	int i=0;
	while(1)
	{
		sem_wait(&product);
		printf("---consumer:%d\n",queue[i]);
		sem_post(&blank);
		i=(i+1)%MAX;
		sleep(rand()%2);
	}
	return NULL;
}


int main()
{
	pthread_t ctid,ptid;

	srand(time(NULL));
		
	sem_init(&blank,0,MAX);
	sem_init(&product,0,0);		//why set 0?This is mean 0 pthread visit in the same time?

	pthread_create(&ctid,NULL,producer,NULL);
	pthread_create(&ptid,NULL,consumer,NULL);

	pthread_join(ctid,NULL);
	pthread_join(ptid,NULL);

	sem_destroy(&blank);
	sem_destroy(&product);

	return 0;
}

效果：
1

写在最后

个人亲身经验：我们学习的一系列Linux命令，一定要自己亲手去敲。不要只是看别人敲代码，不要只是停留在眼睛看，脑袋以为自己懂了，等你实际上手去敲会发现许许多多的这样那样的问题。毕竟“实践出真知”。

如果你觉得我写的题解还不错的，请各位王子公主移步到我的其他题解看看

  1. 数据结构与算法部分（还在更新中）：
  1. Linux部分（还在更新中）：

✨🎉总结

“种一颗树最好的是十年前,其次就是现在”
所以,
“让我们一起努力吧,去奔赴更高更远的山海”
在这里插入图片描述
如果有错误❌,欢迎指正哟😋

🎉如果觉得收获满满,可以动动小手,点点赞👍,支持一下哟🎉

_snowstorm_
关注
  • 56
    点赞
  • 踩
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
十一.linux多线程同步之互斥锁、信号量、条件量
Mr.Wang的博客
05-04 2725
笔记：https://note.youdao.com/ynoteshare1/index.html?id=1b529d966d34b16f3bdd828be48364e4&type=note 目录 一.线程同步之信号量 1、任务：用户从终端输入任意字符然后统计个数显示，输入end则结束 2、信号量的介绍和使用（多线程实行的引入） (1)、信号量初始化 (2)、等待信号量 (3...
Linux线程管理必备:解析互斥量与条件变量的详解
01-20
互斥量的实现与进程中的信号量（无名信号量）是类似的，当然，信号量也可以用于线程，区别在于初始化的时候，其本质都是P/V操作。编译时，记得加上-lpthread或-lrt哦。  有关进程间通信(消息队列)见：进程间通信之...
【Linux C | 多线程编程】线程同步 | 互斥量(互斥锁)介绍和使用
wkd_007的博客
04-08 1155
本文介绍了Linux系统下，多线程编程常用的互斥量，先是介绍了需要互斥量的原因，然后介绍互斥量的使用，并给出使用例子。
【Linux C | 多线程编程】互斥量、信号量、条件变量对比总结
wkd_007的博客
04-20 1134
👉本文总结了“互斥量与信号量使用的区别”、“信号量与条件变量使用的区别”、互斥量与条件变量的关系，并给出部分例子解析这些差异的存在。
多线程的同步与互斥（互斥锁、条件变量、读写锁、自旋锁、信号量）
热门推荐
青萍之末的博客
10-06 7万+
一、同步与互斥的概念   现代操作系统基本都是多任务操作系统，即同时有大量可调度实体在运行。在多任务操作系统中，同时运行的多个任务可能： 都需要访问/使用同一种资源； 多个任务之间有依赖关系，某个任务的运行依赖于另一个任务。 【同步】：   是指散步在不同任务之间的若干程序片断，它们的运行必须严格按照规定的某种先后次序来运行，这种先后次序依赖于要完成的特定的任务。最基本的场景就是：两个或两个以...
Linux应用开发：线程间通信（同步互斥机制）（互斥锁、条件变量、信号量）
W__winter的博客
05-11 948
互斥锁主要用来保护临界资源，每个临界资源都由一个互斥锁来保护，任何时刻最多只能有一个线程能访问该资源。线程必须先获得互斥锁才能访问临界资源，访问完资源后释放该锁。如果无法获得锁，线程会阻塞直到获得锁为止。条件变量是利用线程间共享的全局变量进行同步的一种机制。主要包括两个动作，一个线程等待“条件变量的条件成立”而挂起，另一个线程使“条件成立” （给出条件成立信号 ）并唤醒挂起线程。为了防止竞争，条件变量的使用总是和一个互斥锁结合在一起。对条件的测试是在互斥锁（互斥）的保护下进行的。
Linux——线程同步（条件变量、POSIX信号量）和线程池
weixin_61857742的博客
02-15 894
thrmgr防止线程长期得不到调度的方式也很简单，当线程没有任务时，采用pthread_cond_timedwait函数阻塞等待，该函数第三个参数为设定的timespec时间类型结构体，当检测超时后自动停止阻塞并返回特定值，根据返回值就能判断线程是否是因为超时而停止阻塞，一旦判断超时，线程跳出等待任务的循环然后结束本线程。首先简单说一下什么是循环队列，本质就是长度固定的数组，从头开始插入资源，当插入资源位于最后一个位置的下一个时，再从头开始插入资源，也就是把线性的数组“头尾相连”，变成逻辑上的环形结构。
linux系统编程—线程—互斥锁与条件变量
2301_77164542的博客
06-13 1339
如果调用pthread_mutex_trylock时互斥量处于未锁住状态，那么pthread_mutex_trylock将锁住互斥量，不会出现阻塞并返回0，否则pthread_mutex_trylock就会失败，不能锁住互斥量，而返回EBUSY。pthread_mutex_init和pthread_mutex_destroy参数一和通过pthread_mutex_t创建，参数需要的是一个指针。pthread_cond_wait参数一：等待的条件变量(由pthread_cond_t 创建)
【Linux C | 多线程编程】线程同步 | 条件变量(万字详解)
wkd_007的博客
04-15 1490
本文介绍了Linux多线程编程中常见的条件变量，先是介绍了条件变量相关接口函数，然后介绍了怎么使用条件变量，最后给出了使用条件变量的例子。
线程的互斥与同步、锁与信号量
lijianyi0219的博客
03-29 1145
文章目录前言一、互斥1、加锁互斥锁自旋锁读写锁乐观锁2、信号量概念实现互斥二、同步1、信号量总结 前言 我在阅读 “小林coding” 公众号的图解操作系统系列文章后感觉受益良多，因此进行一些小总结，方便日后查阅。本篇是针对线程间互斥与同步的实现方法进行的总结。 原文链接： 面试官：你说说互斥锁、自旋锁、读写锁、悲观锁、乐观锁的应用场景 多个线程为了同个资源打起架来了，该如何让他们安分？ 线程之间存在两种常见的协作关系：互斥和同步，为了实现进程/线程间正确的协作，操作系统必须提供实现线程协作的措施和方
Linux系统编程之线程同步
05-08
Linux中提供一把互斥锁mutex（也称之为互斥量）。 每个线程在对资源操作前都尝试先加锁，成功加锁才能操作，操作结束解锁。 资源还是共享的，线程间也还是竞争的， 但通过“锁”就将资源的访问变成互斥操作...
Linux线程同步之条件变量
01-09
条件变量是线程可用的另一种同步机制。条件变量给多个线程提供了一个会合的场所。条件本身是由互斥量保护的。线程在改变 条件状态前必须首先锁住互斥量。 　条件变量的初始化 pthread_cond_init 　去除初始化 ...
Linux下多线程编程的互斥与同步
07-31
本文将说明如何使用信号量实现线程之间的互斥与同步。互斥锁只有0，1两中状态，适合于线程对共享资源的独占...信号量实际是一种非负整型计数器，可以很好的控制线程之间资源访问，互斥锁能实现的功能，信号量同样可以。
mutexes-variables-semaphores.rar_linux 线程锁_mutexes_锁和信号量
09-20
Linux多线程编程中互斥锁、条件变量和信号量
linux---进程通信
最新发布
m0_74979625的博客
05-17 551
提示：以下是本篇文章正文内容，下面案例可供参考。
【Linux】Centos7安装Redis
m0_72166275的博客
05-17 317
Reid 官网下载 Redis 7.2。
Linux动静态库
2301_80163789的博客
05-14 629
在程序翻译的链接阶段，其实就是把一堆.o文件链接在一起形成.exe文件。如果一个程序中需要链接很多个.o文件，那么这些.o文件就需要被打包才方便管理，**库文件本质就是把.o文件打包。**库文件是一种提高开发效率的手段。对于静态库，使用静态库形成可执行程序后，静态库被加载到了可执行程序的代码里，不需要让系统知道静态库在哪里；但对于动态库，由于动态库不加载到可执行程序里，而是动态加载到内存中，所以使用动态库要告诉系统动态库在哪（因为是系统来加载动态库）。动态库在编译时代码不会被复制到可执行文件中，而是。
Linux 三十六章
一怀明月的博客
05-17 986
信号量 sem_init sem_destroy sem_wait sem_post 基于环形队列的CP问题 环形队列的生产者消费者模型 线程池 localtime时间戳转化 mkdir系统调用 bind绑定成员函数 懒汉饿汉单例模式 懒汉模式： 饿汉模式： 懒汉和饿汉相同点： 线程池源码实现
C语言线程同步和互斥锁
05-11
常用的线程同步方法有：信号量、互斥锁、条件变量等。 2. 互斥锁：互斥锁是一种用于保护共享资源不被多个线程同时访问的锁。在访问共享资源前，需要获取互斥锁，访问结束后需要释放互斥锁。常见的互斥锁有：pthread...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值