当前位置：主页 > 查看内容

嵌入式学习DAY28 --- 线程、同步和互斥问题、如何实现同步和互斥

发布时间：2021-04-16 00:00| 有位朋友查看

简介：嵌入式入门学习笔记遇到的问题以及心得体会 DAY28 概述一、线程二、同步和互斥问题三、如何实现同步四、如何实现互斥笔记一、线程 1、什么是线程 1线程是轻量级的进程 2线程存在于进程内不能独立存在 3线程参与CPU调度进程是系统资源分配最小单位线程……

嵌入式入门学习笔记，遇到的问题以及心得体会！
DAY28

概述：

一、线程
二、同步和互斥问题
三、如何实现同步
四、如何实现互斥

笔记：

一、线程

1、什么是线程：

（1）线程是轻量级的进程

（2）线程存在于进程内，不能独立存在

（3）线程参与CPU调度，进程是系统资源分配最小单位，线程是系统调度的最小单位

（4）在单核CPU中，多线程并发属于伪并发，但是不牵扯虚拟地址空间的切换，所以开销比进程间切换要小很多

（5）在多核CPU中，多线程可以实现真并发

前面我们已经提到，进程是系统中程序执行和资源分配的基本单位每个进程都拥有自己的数据段，代码段和堆
栈段，这就造成了进程在进行切换时，操作系统的开销比较大。
为了提高效率，操作系统又引入了另一个概念——线程，也称轻量级的进程。线程可以对进程的内存空间和资源进行访问，并与同一进程中的其他线程共享。因此，线程的上下文切换的开销比进程小得多。
一个进程可以拥有多个线程，其中每一个线程共享该进程所拥有的资源。要注意的是，由于线程共享了进程的资源和地址空间，因此，任何线程对于系统资源的操作都会给其他线程带来影响。由此可知，多线程中的同步是非常重要的问题。在多线程系统中，进程与线程的关系图如下:

在这里插入图片描述

2、哪些是多线程共享的资源，哪些是线程私有的资源:

线程(Thread)：有时候被称为轻量级进程(Lightweight Process, LWP),是程序执行流的最小单元。一个标准的线程由线程ID、当前指令指针(PC)、寄存器集合和堆栈组成。

通常一个进程由一个到多个线程组成，各个线程之间共享程序的内存空间(包括代码段、数据段、堆等)以及一些进成级的资源(如打开文件和信号)。一个经典的线程与进程的关系图如下：

	|---------------------------------------------------|
	|代码		|数据		|进程空间	|打开文件		|
	|---------------------------------------------------|
	|													|
	|	|-----------|	|-----------|	|-----------|	|
	|	|寄存器		|	|寄存器		|	|寄存器		|	|
	|	|-----------|	|-----------|	|-----------|	|
	|	|栈			|	|栈			|	|栈			|	|
	|	|-----------|	|-----------|	|-----------|	|
	|	|			|	|			|	|			|	|
	|	|			|	|			|	|			|	|
	|	|			|	|			|	|			|	|
	|	|			|	|			|	|			|	|
	|	|			|	|			|	|			|	|
	|	|			|	|			|	|			|	|
	|	|MainThread	|	|Thread1	|	|Thread2	|	|
	|	|-----------|	|-----------|	|-----------|	|
	|													|
	|		进程的地址空间使用分配图						|
	|---------------------------------------------------|

3、使用多线程的原因：

<1>某个操作可能会陷入长时间等待，等待的线程会进入睡眠状态，无法继续执行。多线程执行可以有效利用等待的时间。典型的例子是等待网络响应。这可能要花费数秒甚至数十秒。

<2>某个操作(常常是计算)会消耗大量的时间，如果只有一个线程，程序和用户之间的交互会中断。多线程可以让一个线程负责交互，另一个线程负责计算。

<3>程序逻辑本身要求并发操作，例如一个多端下载软件(Bittorrent)

<4>多CPU或多核计算机，本身具备同时执行多个线程的能力，因此单线程程序无法全面地发挥计算机地全部计算能力。

<5>相对于多进程应用程序，多线程在数据共享方面效率要高很多。

4、线程地访问权限：

线程地访问非常自由，它可以访问进程内存里的所有数据，甚至包括其他线程的堆栈(如果它知道其他线程的堆栈地址，那么这就是很少见的情况)，但实际运用中线程也拥有自己的私有存储空间，包括以下几个方面：
<1>栈:尽管并非完全无法被其他线程访问，但一般情况下仍然可以认为是私有的。
<2>线程局部存储(Thread Local Storage, TLS):线程局部存储是某些操作系统为线程单独提供的私有空间，但通常只具有很有限的容量。
<3>寄存器(包括PC寄存器):寄存器是执行流的基本数据，因此为线程私有。

从C程序员的角度来分析，数据在线程之间是否私有如下表：
|-----------------------|-----------------------------------------------|
|线程私有				|线程之间共享(进程所有)							|
|-----------------------|-----------------------------------------------|
|局部变量				|全局变量										|
|函数的参数				|堆上的数据										|
|TLS数据				|函数里的静态变量								|
|						|程序代码，任何线程都有权利读取并执行任何代码	    |
|						|打开的文件，A线程打开的文件可以由B线程读写		|	
|-----------------------|-----------------------------------------------|

在这里插入图片描述

5、如何创建线程：

pthread_create()

头文件：
#include <pthread.h>
		
			/*
			 *函数名：pthread_create
			 *函数功能：创建一个线程
			 *函数参数：
			 *			pthread_t *thread:
			 *			const pthread_attr_t *attr:创建线程时的参数的指针
			 *			void *(*start_routine) (void *)：线程处理函数的指针
			 *			void *arg:线程处理函数的参数
			 *函数返回值：int：成功返回0，失败返回非零
			 */
			int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);

注意：Compile and link with -pthread. 编译时加-lpthread

6、如何让线程执行特定任务：

通过线程处理函数来实现

7、线程的释放：

(1)pthread_detach

头文件：
#include <pthread.h>
		/*
		 *函数名：pthread_detach
		 *函数功能：销毁一个线程
		 *函数的参数：
		 *			pthread_t thread：要销毁的线程
		 *函数返回值：int：成功反回0，失败错误码
		 */
		int pthread_detach(pthread_t thread);

(2)pthread_join

头文件：
#include <pthread.h>
		/*
		 *函数名：pthread_join
		 *函数功能：等待线程的退出
		 *函数参数：
		 *			pthread_t thread:要等待的线程
		 *			void **retval：线程的退出状态
		 *函数返回值：int：成功反回0，失败错误码
		 */
		int pthread_join(pthread_t thread, void **retval);

(3)pthread_exit

(4)pthread_cancel

8.线程代码演示

#include <stdio.h>
#include <pthread.h>

void *t1f(void *arg)
{
	while(1)
	{
		printf("Tom and Jerry!\n");
	}
	return NULL;
}

void *t2f(void *arg)
{
	while(1)
	{
		printf("Tomats\n");
	}
	return NULL;
}

int main()
{
	//create thread two
	pthread_t tid1, tid2;
	int ret = pthread_create(&tid1, NULL, t1f ,NULL);
	if(ret != 0)
	{
		puts("create thread 1 error.");
		return -1;
	}
	ret = pthread_create(&tid2, NULL, t2f ,NULL);
	if(ret != 0)
	{
		puts("create thread 1 error.");
		return -1;
	}
	pthread_detach(tid1);
	pthread_detach(tid2);
	//detach thread
	while(1)
	{};
	return 0;
}

二、同步和互斥问题

1.什么是临界资源

并发编程中，多线程/进程共享的资源，都叫临界资源

2.什么是临界区

代码中操作临界资源的部分，称为临界区

3.操作临界资源的使用要注意哪些问题

读读不互斥
读写互斥
写写互斥

4.如何安全的操作临界资源

同步
互斥

三、同步

1.什么是同步：

多进程/多线程在访问临界资源时，按照一定的操作顺序来访问。

2.什么时候使用同步

需要按照一定的顺序访问临界资源时使用

3.实现同步的方法

1.信号量

有名信号量：进程使用
无名信号量：线程使用

2.能够共享的变量

（1）进程：

管道
------------有名管道
------------无名管道
共享内存
消息队列

（2）线程：

全局变量
静态变量

4.如何实现无名信号量

（1）sem_init

/*需要包含的头文件*/
#include <semaphore.h>
	/*
	 *函数名：sem_init
	 *函数功能：初始化一个无名信号量
	 *函数参数：
	 *		sem_t *sem:信号量操作对象的指针
	 *		int pshare:默认为0为线程使用
	 *		unsigned int value:信号量的初始值
	 *函数返回值：int：成功返回0，失败返回-1
	 */
int sem_init(sem_t *sem, int pshare, unsigned int value);

（2）sem_wait

（3）sem_post

（4）sem_destroy

/*需要包含的头文件*/
#include <semaphore.h>
	/*
	 *函数名:sem_destroy
	 *函数功能：销毁一个无名信号量
	 *函数参数：sem_t *sem:被销毁的无名信号量的操作对象指针
	 *函数返回值：int ：成功0，失败-1
	 */
int sem_destroy(sem_t *sem);

5.如何使用无名信号量

多线程需要同步访问临界资源时使用

6.同步代码演示

（1）flags

create_thread-------------------------------------------------------------------------------------------------代码如下

#include <stdio.h>
#include <pthread.h>

int c;
int flag;

void *t1f(void *arg)
{
	while(1)
	{
		if(flag == 0)
		{
			if(c < 100)
			{
				c++;
			}
			else
			{
				c = 0;
			}
			flag = 1;
		}

	}
	return NULL;
}

void *t2f(void *arg)
{
	while(1)
	{
		if(flag == 1)
		{
			printf("c:%d\n",c);
			flag = 0;
		}
	}
	return NULL;
}

int main()
{
	//create thread two
	pthread_t tid1, tid2;
	int ret = pthread_create(&tid1, NULL, t1f ,NULL);
	if(ret != 0)
	{
		puts("create thread 1 error.");
		return -1;
	}
	ret = pthread_create(&tid2, NULL, t2f ,NULL);
	if(ret != 0)
	{
		puts("create thread 1 error.");
		return -1;
	}
	pthread_detach(tid1);
	pthread_detach(tid2);
	//detach thread
	while(1)
	{};
	return 0;
}

（2）unamed_sem

create_thread-------------------------------------------------------------------------------------------------代码如下

#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>

int c;
sem_t mysem;

void *t1f(void *arg)
{
	while(1)
	{
		int sval = 0;
		sem_getvalue(&mysem, &sval);
		if(sval == 2)
		{
			sem_wait(&mysem);		
			if(c < 100)
			{
				c++;
			}
			else
			{
				c = 0;
			}
		}
	}
	return NULL;
}

void *t2f(void *arg)
{
	while(1)
	{
		int sval = 0;
		sem_getvalue(&mysem, &sval);
		if(sval == 1)
		{
			sem_wait(&mysem);
			printf("c:%d\n",c);
			sem_post(&mysem);
			sem_post(&mysem);
		}
	}
	return NULL;
}

int main()
{
	//sem_init
	int ret = sem_init(&mysem,0,2);
	if(ret != 0)
	{
		puts("sem_init error.");
		return -1;
	}
	//create thread two
	pthread_t tid1, tid2;
	ret = pthread_create(&tid1, NULL, t1f ,NULL);
	if(ret != 0)
	{
		puts("create thread 1 error.");
		return -1;
	}
	ret = pthread_create(&tid2, NULL, t2f ,NULL);
	if(ret != 0)
	{
		puts("create thread 1 error.");
		return -1;
	}
	pthread_detach(tid1);
	pthread_detach(tid2);
	//detach thread
	//sem_destroy
	sem_destroy(&mysem);
	while(1)
	{};
	return 0;
}

四、互斥

1.什么是互斥

多线程/多进程访问临界资源时，没有顺序要求，只需要满足写写互斥和读写互斥时，此时说的就是不能同时访问临界资源。

2.什么时候使用互斥

写写互斥，读写互斥

3.如何实现互斥锁

<1>初始化互斥锁

头文件：
#include <pthread.h>
		/*
		 *函数名：pthread_mutex_init
		 *函数功能：初始化互斥锁
		 *函数参数：
		 *		pthread_mutex_t *mutex：锁的指针
		 *		pthread_mutexattr_t *attr：锁的参数的指针，通常为NULL
		 *函数返回值：成功为0，失败返回-1
		 */
		 
		int pthread_mutex_init(pthread_mutex_t *mutex, pthread_mutexattr_t *attr);

<2>加锁

头文件：#include <pthread.h>
			
			/*
			 *函数名：pthread_mutex_lock
			 *函数功能：申请锁资源
			 *函数参数：pthread_mutex_t *mutex：锁的指针
			 *函数返回值：成功返回0，失败-1
			 */
			int pthread_mutex_lock(pthread_mutex_t *mutex);

<3>解锁

头文件：
#include <pthread.h>
			
			/*
			 *函数名：pthread_mutex_unlock
			 *函数功能：释放互斥锁
			 *函数参数：pthread_mutex_t *mutex：锁的指针
			 *函数返回值：成功返回0，失败-1
			 */
			int pthread_mutex_unlock(pthread_mutex_t *mutex);

4.互斥代码演示：

create_thread-------------------------------------------------------------------------------------------------代码如下

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

char buf[100];

pthread_mutex_t mutex;

void *t1f(void *arg)
{
	while(1)
	{
		pthread_mutex_lock(&mutex);
		puts(buf);
		memset(buf,0,100);
		strcpy(buf,"Jerry is a student.");
		pthread_mutex_unlock(&mutex);
	}
	return NULL;
}

void *t2f(void *arg)
{
	while(1)
	{
		pthread_mutex_lock(&mutex);
		puts(buf);
		memset(buf,0,100);
		strcpy(buf,"Ben is a teacher.");
		pthread_mutex_unlock(&mutex);
	}
	return NULL;
}

int main()
{
	pthread_mutex_init(&mutex, NULL);
	//create thread two
	pthread_t tid1, tid2;
	int ret = pthread_create(&tid1, NULL, t1f ,NULL);
	if(ret != 0)
	{
		puts("create thread 1 error.");
		return -1;
	}
	ret = pthread_create(&tid2, NULL, t2f ,NULL);
	if(ret != 0)
	{
		puts("create thread 1 error.");
		return -1;
	}
	pthread_detach(tid1);
	pthread_detach(tid2);
	//detach thread
	pthread_mutex_destroy(&mutex);
	while(1)
	{};
	return 0;
}

5.注意：

互斥锁只能由加锁的线程解锁
当临界资源加锁后没有解锁，其他线程/进程无法访问临界资源时，就会产生死锁。

附加：并发编程中经典问题：

1.哲学家共餐问题
2.生产者消费者问题

；原文链接：https://blog.csdn.net/SpringWJN/article/details/115406282
本站部分内容转载于网络，版权归原作者所有，转载之目的在于传播更多优秀技术内容，如有侵权请联系QQ/微信：153890879删除，谢谢！

上一篇：普歌-允异团队-【Java知识点】这些Java学习路上你必须知道的底层 下一篇：【图像加密】基于行列像素置乱+DWT小波变换图像隐藏加密【含Matl

随机推荐

面试官：能说一说MySQL缓存池吗？

大家好，我是狂聊君。今天来聊一聊 Mysql 缓存池原理。提纲附上，话不多说，直...
flash 报错捕获(Catch All Exception in

在Flash Player 10.1及以上版本中，adobe新增了全局错误处理程序UncaughtErrorEv...
.NET Core 处理 WebAPI JSON 返回烦人的n

前言项目开发中不管是前台还是后台都会遇到烦人的null，数据库表中字段允许空值...
flex项目中server的名称修改方法探讨

问题：我们在做flex的开发中，如果用到别人搭建好的框架，而别人的server名称往...
最新IntelliJ IDEA 2020.2永久激活码(亲

idea官方推送了2020.2.4版本的更新，那么大家最关心的问题来了，之前激活idea202...
OBLOG4.0 OBLOG4.5漏洞利用分析

来源：DeepenStudy 漏洞文件：js.asp % Dimoblog setoblog=newclass_sys oblog.a...
AJAX+Servlet实现的数据处理显示功能示例

本文实例讲述了AJAX+Servlet实现的数据处理显示功能。分享给大家供大家参考，具...
深入了解MySQL主从复制的原理

本文转载自微信公众号「SH的全栈笔记」，作者SH。转载本文请联系SH的全栈笔记公...
关于CKeditor的非主流个性应用的设置

CKeditor，以前叫FCKeditor，已经使用过好多年了，功能自然没的说。最近升级到3....
巧用Spt_Values解决SQL中的连续日期问题

本文转载自微信公众号「SQL数据库」，作者丶平凡世界。转载本文请联系开发公众...

嵌入式学习DAY28 --- 线程、同步和互斥问题、如何实现同步和互斥

概述：

笔记：

一、线程

1、什么是线程：

2、哪些是多线程共享的资源，哪些是线程私有的资源:

3、使用多线程的原因：

4、线程地访问权限：

5、如何创建线程：

6、如何让线程执行特定任务：

7、线程的释放：

(1)pthread_detach

(2)pthread_join

(3)pthread_exit

(4)pthread_cancel

8.线程代码演示

二、同步和互斥问题

1.什么是临界资源

2.什么是临界区

3.操作临界资源的使用要注意哪些问题

4.如何安全的操作临界资源

三、同步

1.什么是同步：

2.什么时候使用同步

3.实现同步的方法

1.信号量

2.能够共享的变量

4.如何实现无名信号量

（1）sem_init

（2）sem_wait

（3）sem_post

（4）sem_destroy

5.如何使用无名信号量

6.同步代码演示

（1）flags

（2）unamed_sem

四、互斥

1.什么是互斥

2.什么时候使用互斥

3.如何实现互斥锁

<1>初始化互斥锁

<2>加锁

<3>解锁

4.互斥代码演示：

5.注意：

附加：并发编程中经典问题：

推荐图文

随机推荐

关于我们