嵌入式——线程

最新推荐文章于 2024-05-10 20:17:43 发布
最新推荐文章于 2024-05-10 20:17:43 发布
阅读量1k 收藏 22
点赞数 31
文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72168217/article/details/136702020
版权

嵌入式——线程

🛑线程

一个进程可以有多个线程，他们共享这个进程资源
早期的操作系统都是以进程作为独立运行的基本单位的，直到后期计算机科学家们又提出了更小的能独立运行的基本单位，也就是线程。
线程又称为迷你进程，但是它比进程更容易创建，也更容易撤销
用严谨的语言描述来说就是：由于创建或撤销进程时，系统都要为之分配或回收资源，如内存空间、I/O 设备等，需要较大的时空开销，限制了并发程度的进一步提高。为减少进程切换的开销，把进程作为资源分配单位和调度单位这两个属性分开处理，即进程还是作为资源分配的基本单位，但是不作为调度的基本单位（很少调度或切换），把调度执行与切换的责任交给线程，即线程成为独立调度的基本单位，它比进程更容易（更快）创建，也更容易撤销。

🍃线程优缺点

线程的特征和进程差不多，进程有的他基本都有，比如：

  • 线程具有就绪、阻塞、运行三种基本状态，同样具有状态之间的转换关系
  • 线程间可以并发执行
  • 在多 CPU 环境下，各个线程也可以分派到不同的CPU 上并行执行

线程的优点

  • 一个进程中可以同时存在多个线程，这些线程共享该进程的资源。进程间的通信必须请求操作系统服务（因为 CPU要切换到内核态），开销很大。而同进程下的线程间通信，无需操作系统干预，开销更小
    不过，需要注意的是：从属于不同进程的线程间通信，也必须请求操作系统服务
  • 线程间的并发比进程的开销更小，系统并发性提升
    同样，需要注意的是：从属于不同进程的线程间切换，它是会导致进程切换的，所以开销也大

线程的缺点

  • 当进程中的一个线程奔溃时，会导致其所属进程的所有线程奔溃

🍃创建线程

头文件：
#include <pthread.h>

函数原型：
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg);

函数功能：创建线程，把pid线程和参数3start_routine绑定起来

函数参数：
函数参数1：pthread_t pid &pid创建的线程是谁
函数参数2：指定线程的属性，一般传NULL
函数参数3：线程执行的工作，是一个函数指针，指向的函数的数据类型是void * (void *)
函数参数4：传递给线程执行的参数

函数返回值：成功返回0，失败返回-1

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

//线程1执行函数
void *Func_1(void *argv)
{
	while(1)
	{
		printf("采集环境声\n");
		sleep(1);
	}
}

void *Func_2(void *arg)
{
	for( ; ; )
	{
		printf("和互联网进行链接\n");
		sleep(1);
	}
}

int main(int argc, const char *argv[])
{
	//定义变量
	pthread_t pid_1, pid_2;
	//创建线程
	pthread_create(&pid_1, NULL, Func_1, NULL);//pthread_t * , NULL, 函数指针, void *arg
	pthread_create(&pid_2, NULL, Func_2, NULL);
	while(1)
	{
		printf("控制显示\n");
		sleep(1);
	}
	return 0;
}

在这里插入图片描述

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

//线程1执行函数
void *Func_1(void *argv)
{
	while(1)
	{
		printf("采集环境声\n");
		sleep(1);
	}
}

void *Func_2(void *arg)
{
	for( ; ; )
	{
		printf("和互联网进行链接\n");
		sleep(1);
	}
}

int main(int argc, const char *argv[])
{
	//定义变量
	pthread_t pid_1, pid_2;
	//创建线程
	pthread_create(&pid_1, NULL, Func_1, NULL); //pthread_t * , NULL, 函数指针, void*arg
	pthread_create(&pid_2, NULL, Func_2, NULL);
	int i = 0;
	while(1)
	{
		printf("控制显示\n");
		sleep(1);
		if(i++ == 15)
		{
			break;
		}
	}
	printf("主线程退出\n");
	return 0;
}

在这里插入图片描述

🍃线程的结束

🌿主动结束

头文件：
#include<stdio,h>

函数原型：
void pthread_exit(void *retval);

函数参数：
value_ptr 线程退出时返回的值

函数返回值：
成功：0
失败：-1

🌿被动结束

头文件：
#include <pthread.h>

函数原型：
int pthread_cancel(pthread_t thread);

函数参数：
thread 要取消的线程

函数返回值：
成功：0
失败：-1

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

//线程1执行函数
void *Func_1(void *argv)
{
	int i = 0;
	while(1)
	{
		if(i++ == 10)
		{
			printf("线程1将要主动退出！！！\n");
			pthread_exit(NULL);//主动退回，没有返回值
		}
		printf("采集环境声\n");
		sleep(1);
	}
}

void *Func_2(void *arg)
{
	for( ; ; )
	{
		printf("和互联网进行链接\n");
		sleep(1);
	}
}

int main(int argc, const char *argv[])
{
	//定义变量
	pthread_t pid_1, pid_2;
	//创建线程
	pthread_create(&pid_1, NULL, Func_1, NULL); //pthread_t * , NULL, 函数指针, void*arg
	pthread_create(&pid_2, NULL, Func_2, NULL);
	int i = 0;
	while(1)
	{
		printf("控制显示\n");
		sleep(1);
		if(i++ == 13)
		{
			//取消线程2的任务
			printf("线程2被动退出！！！！\n");
			pthread_cancel(pid_2);
		}
	}
	printf("主线程退出\n");
	return 0;
}

在这里插入图片描述

🍃回收线程资源

🌿阻塞回收

头文件：
#include<stdio.h>

函数原型：
int pthread_join(pthread_t thread, void **value_ptr)

函数参数：
thread:要等待的线程
value_ptr:指针*value_ptr指向线程返回的参数

函数返回值：
成功：0
失败：-1

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

//线程1执行函数
void *Func_1(void *argv)
{
	int i=0;
	while(1)
	{
		if(i++ == 15)
		{
			pthread_exit(NULL);
		}
		printf("采集环境声\n");
		sleep(1);
	}
}

void *Func_2(void *arg)
{
	for( ; ; )
	{
		printf("和互联网进行链接\n");
		sleep(1);
	}
}

int main(int argc, const char *argv[])
{
	//定义变量
	pthread_t pid_1, pid_2;
	//创建线程
	pthread_create(&pid_1, NULL, Func_1, NULL); //pthread_t * , NULL, 函数指针, void*arg
	pthread_create(&pid_2, NULL, Func_2, NULL);
	int i = 0;
	pthread_join(pid_1, NULL);//阻塞等待指定的线程，
	// join(pthread_t pid, *);
	while(1)
	{
		printf("控制显示\n");
		sleep(1);
		if(i++ == 5)
		{
			break;
		}
	}
	printf("主线程退出\n");
	return 0;
}

在这里插入图片描述
在这里插入图片描述

🌿不阻塞回收

头文件：
#include <pthread.h>

函数原型：
int pthread_detach(pthread_t thread);

把主线程和指定的thread线程剥离
作用:从状态上实现线程分离，注意不是指该线程独自占用地址空间。
线程分离状态:指定该状态，线程主动与主控线程断开关系。线程结束后〈不会产生僵尸线程)，具退出认念个出只化或性次大以，且这自己自动释放（自己清理掉PCB的残留资源)。网络、多线程一服务器常用。
进程若有该机制，将不会产生僵尸进程。僵尸进程的产生主要由于进程死后，大部分资源被释放，一点残留资源仍存于系统中，导致内核认为该进程仍存在。(注意进程没有这一机制)

🌿线程之间的数据传输

验证：除了栈区之外的数据，都是共享的：

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

static int c = 20;

//线程1执行函数
void *Func_1(void *argv)
{
	printf("c = %d\n", c);
	c+=20;
	int *p = (int *)argv;
	int i=0; //局部变量
	while(1)
	{
		if(i++ == 15)
		{
			*p = 15 ;
			pthread_exit(NULL);
		}
	printf("采集环境声\n");
	sleep(1);
	}
}

void *Func_2(void *arg)
{
	for( ; ; )
	{
		printf("和互联网进行链接\n");
		sleep(1);
	}
}

int main(int argc, const char *argv[])
{
	int *p = NULL;
	p = (int *) malloc(sizeof(int)); //堆区
	*p = 0;
	printf("*p = %d\n", *p);
	//定义变量
	pthread_t pid_1, pid_2;
	//创建线程
	pthread_create(&pid_1, NULL, Func_1, p); //pthread_t * , NULL, 函数指针, void*arg
	pthread_create(&pid_2, NULL, Func_2, NULL);
	int i = 0; //主线程的局部变量
	while(1)
	{
		printf("控制显示\n");
		sleep(1);
		if(i++ == 5)
		{
			break;
		}
	}
	printf("主线程退出\n");
	printf("c = %d \n", c);
	pthread_join(pid_1, NULL);
	printf("*p = %d\n", *p);
	return 0;
}

在这里插入图片描述
在这里插入图片描述

🍃主线程给子线程传递数据

通过pthrad_create的第四个参数

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

//线程1执行函数
void *Func_1(void *arg)
{
	//str1 ==> arg
	char *pstr = (char *)arg; //传过来的是什么类型的数据
	//要转换成一样类型的
	printf("线程1:%s\n", pstr);
	pthread_exit(NULL);
}

void *Func_2(void *arg)
{
	//str2 ==> arg
	char *pstr = (char *)arg; //传过来的是什么类型的数据
	//要转换成一样类型的
	printf("线程2:%s\n", pstr);
	pthread_exit(NULL);
}

void *Func_3(void *arg)
{
	//str3 ==> arg
	char *pstr = (char *)arg; //传过来的是什么类型的数据
	//要转换成一样类型的
	printf("线程3:%s\n", pstr);
	pthread_exit(NULL);
}

int main(int argc, const char *argv[])
{
	//在栈区定义变量
	char str1[20] = "ABCDEFG";
	char str2[20] = "abcdefg";
	char str3[20] = "0123456";
	//定义变量
	pthread_t pid_1, pid_2, pid_3;
	//创建线程
	pthread_create(&pid_1, NULL, Func_1, str1); //pthread_t * , NULL, 函数指针, void*arg
	pthread_create(&pid_2, NULL, Func_2, str2);
	pthread_create(&pid_3, NULL, Func_3, str3);
	//阻塞等待线程退出
	pthread_join(pid_1, NULL);
	pthread_join(pid_2, NULL);
	pthread_join(pid_3, NULL);
	return 0;
}

🍃子线程给主线程传递数据

通过pthread_exit()传递

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

//线程1执行函数
void *Func_1(void *arg)
{
	//str1 ==> arg
	char *pstr = (char *)arg; //传过来的是什么类型的数据
	//要转换成一样类型的
	char *ps = (char *)malloc(sizeof(char) * 50);
	memset(ps, 0, sizeof(char)*50);
	strcat(ps, pstr);
	strcat(ps, "xiancheng1");
	//printf("线程1:%s\n", pstr);
	pthread_exit(ps);
}

void *Func_2(void *arg)
{
	//str2 ==> arg
	char *pstr = (char *)arg; //传过来的是什么类型的数据
	//要转换成一样类型的
	char *ps = (char *)malloc(sizeof(char) * 50);
	memset(ps, 0, sizeof(char)*50);
	strcat(ps, pstr);
	strcat(ps, "xiancheng2");
	//printf("线程2:%s\n", pstr);
	pthread_exit(ps);
}

void *Func_3(void *arg)
{
	//str3 ==> arg
	char *pstr = (char *)arg; //传过来的是什么类型的数据
	//要转换成一样类型的
	char *ps = (char *)malloc(sizeof(char) * 50);
	memset(ps, 0, sizeof(char)*50);
	strcat(ps, pstr);
	strcat(ps, "xiancheng3");
	//printf("线程3:%s\n", pstr);
	pthread_exit(ps);
}

int main(int argc, const char *argv[])
{
	//在栈区定义变量
	char str1[20] = "ABCDEFG";
	char str2[20] = "abcdefg";
	char str3[20] = "0123456";
	char *ps1 = NULL;
	char *ps2 = NULL;
	char *ps3 = NULL;
	//定义变量
	pthread_t pid_1, pid_2, pid_3;
	//创建线程
	pthread_create(&pid_1, NULL, Func_1, str1); //pthread_t * , NULL, 函数指针, void*arg
	pthread_create(&pid_2, NULL, Func_2, str2);
	pthread_create(&pid_3, NULL, Func_3, str3);
	//阻塞等待线程退出
	pthread_join(pid_1, (void **)&ps1); //void ** ps1 char *
	pthread_join(pid_2, (void **)&ps2);
	pthread_join(pid_3, (void **)&ps3);
	//在主线程使用值
	printf("ps1 = %s\n", ps1);
	printf("ps2 = %s\n", ps2);
	printf("ps3 = %s\n", ps3);
	return 0;
}

🍃互斥

引入互斥(mutual exclusion)锁的目的是用来保证共享数据操作（临界资源）的完整性。
互斥锁主要用来保护临界资源
每个临界资源都由一个互斥锁来保护，任何时刻最多只能有一个线程能访问该资源
线程必须先获得互斥锁才能访问临界资源，访问完资源后释放该锁。如果无法获得锁，线程会阻塞直到获得锁为止

🌿定义互斥锁

pthread_mutex_t mutex_1;
//要给多个线程访问，所以得定义在共享的地方，全局变量

🌿初始化锁

头文件：
#include<pthread.h>

函数原型：
int pthread_mutex_init(pthread_mutex_t *mutex, pthread_mutexattr_t *attr)

函数参数：
mutex:互斥锁
attr:互斥锁属性//NULL表示缺少属性

函数返回值：
成功：0
失败：-1

🌿上锁

头文件：
#include<pthread.h>

函数原型：
int pthread_mutex_lock(pthread_mutex_t *mutex)

函数参数：
mutex:互斥锁

函数返回值：
成功：0
失败：-1

🌿释放锁

头文件：
#include<pthread.h>

函数原型：
int pthread_mutex_unlock(pthread_mutex_t *mutex)

函数参数：
mutex:互斥锁

函数返回值：
成功：0
失败：-1

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

//定义互斥锁
pthread_mutex_t mymutex;
char str[20] = {0}; //共享的资源，每一个线程都能访问到

//线程1执行函数
void *Func_1(void *arg)
{
	int i = 0;
	//str1 ==> arg
	char *pstr = (char *)arg; //传过来的是什么类型的数据
	//要转换成一样类型的
	//上锁
	pthread_mutex_lock(&mymutex);
	//要将pstr指示的数据，放到str里面
	while(pstr[i] != '\0')
	{
		str[i] = pstr[i];
		printf("str = %s\n", str);
		sleep(1);
		i++;
	}
	str[i] = '\0';
	printf("str = %s\n", str);
	//释放锁
	pthread_mutex_unlock(&mymutex);
	pthread_exit(NULL);
}

void *Func_2(void *arg)
{
	int i = 0;
	//str2 ==> arg
	char *pstr = (char *)arg; //传过来的是什么类型的数据
	//要转换成一样类型的
	//上锁
	pthread_mutex_lock(&mymutex);
	//要将pstr指示的数据，放到str里面
	while(pstr[i] != '\0')
	{
		str[i] = pstr[i];
		printf("str = %s\n", str);
		sleep(1);
		i++;
	}
	str[i] = '\0';
	printf("str = %s\n", str);
	//释放锁
	pthread_mutex_unlock(&mymutex);
	pthread_exit(NULL);
}

void *Func_3(void *arg)
{
	int i = 0;
	//str3 ==> arg
	char *pstr = (char *)arg; //传过来的是什么类型的数据
	//要转换成一样类型的
	//上锁
	pthread_mutex_lock(&mymutex);
	//要将pstr指示的数据，放到str里面
	while(pstr[i] != '\0')
	{
		str[i] = pstr[i];
		printf("str = %s\n", str);
		sleep(1);
		i++;
	}
	str[i] = '\0';
	printf("str = %s\n", str);
	//释放锁
	pthread_mutex_unlock(&mymutex);
	pthread_exit(NULL);
}

int main(int argc, const char *argv[])
{
	//在栈区定义变量
	char str1[20] = "ABCDEFG";
	char str2[20] = "abcdefg";
	char str3[20] = "0123456";
	//初始化锁
	pthread_mutex_init(&mymutex, NULL);
	//定义变量
	pthread_t pid_1, pid_2, pid_3;
	//创建线程
	pthread_create(&pid_1, NULL, Func_1, str1); //pthread_t * , NULL, 函数指针, void *arg
	pthread_create(&pid_2, NULL, Func_2, str2);
	pthread_create(&pid_3, NULL, Func_3, str3);
	//阻塞等待线程退出
	pthread_join(pid_1, NULL); //void ** ps1 char *
	pthread_join(pid_2, NULL);
	pthread_join(pid_3, NULL);
	//销毁锁
	pthread_mutex_destroy(&mymutex);
	return 0;
}

在这里插入图片描述

🍃同步

同步(synchronization)指的是多个任务(线程) 按照约定的顺序相互配合完成一件事情

🌿定义信号量

sem_t mysem;

🌿初始化信号量

头文件:
#include<semaphore.h>

函数原型：
int sem_init(sem_t *sem, int pshared, unsigned int value)

函数参数：
sem: 初始化的信号量
pshared：信号量共享的范围（0：线程间使用 非0：进程间使用）
value：信号量初值

函数返回值：
成功：0
失败：-1

🌿pv操作

头文件：
#include<semaphore.h>

函数原型：
int sem_wait(sem_t *sem) // P操作

函数参数：
sem：信号量

函数返回值：
成功：0
失败：-1

P操作：

  • Ｐ(Ｓ) 含义如下:
  • 可用：申请资源的任务继续运行；信号量的值减一
  • 不可用：申请资源的任务阻塞

头文件：
#include<semaphore.h>

函数原型：
int sem_post(sem_t *sem) // V操作

函数参数：
sem：信号量

函数返回值：
成功：0
失败：-1

V操作：

  • V(Ｓ) 含义如下:
  • 没有任务在等待该资源，信号量的值加一
  • 唤醒第一个等待的任务，让其继续运行
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
#include <semaphore.h>

//定义信号量
sem_t sem_1,sem_2;

//线程1的执行函数
void *Func_1(void *arg)
{
	while(1)
	{
		//P
		sem_wait(&sem_1);
		printf("我生产了一台电脑\n");
		sleep(1);
		//V
		sem_post(&sem_2);
	}
}

//线程2的执行函数
void *Func_2(void *arg)
{
	while(1)
	{
		//P
		sem_wait(&sem_2);
		printf("我买了一台电脑\n\n\n");
		sleep(1);
		//V
		sem_post(&sem_1);
	}
}

int main(int argc, const char *argv[])
{
	pthread_t pid_1, pid_2;
	//信号量初始化
	//sem_init(sem_t *, int , int );
	sem_init(&sem_1, 0, 1);
	sem_init(&sem_2, 0, 0);
	//创建两个进程
	pthread_create(&pid_1, NULL, Func_1, NULL);
	pthread_create(&pid_2, NULL, Func_2, NULL);
	//等待
	pthread_join(pid_1, NULL);
	pthread_join(pid_2, NULL);
	return 0;
}

在这里插入图片描述

🍃线程池

任务执行的时间有可能远远低于线程创建和销毁的时间，可以搞一个线程池（不销毁的，同步做的）

设计思路
实现线程池有以下几个步骤：

  1. 设置一个生产者消费者队列，作为临界资源。
  2. 初始化n个线程，并让其运行起来，加锁去队列里取任务运行
  3. 当任务队列为空时，所有线程阻塞。
  4. 当生产者队列来了一个任务后，先对队列加锁，把任务挂到队列上，然后使用条件变量去通知阻塞中的一个线
    程来处理。

线程池中线程数量：

  • 线程数量和哪些因素有关：CPU，IO、并行、并发
  • 如果是CPU密集型应用，则线程池大小设置为：CPU数目+1
  • 如果是IO密集型应用，则线程池大小设置为：2*CPU数目+1
  • 最佳线程数目 = （线程等待时间与线程CPU时间之比 + 1）* CPU数目
    所以线程等待时间所占比例越高，需要越多线程。线程CPU时间所占比例越高，需要越少线程。

为什么要创建线程池：
创建线程和销毁线程的花销是比较大的，这些时间有可能比处理业务的时间还要长。这样频繁的创建线程和销毁线程，再加上业务工作线程，消耗系统资源的时间，可能导致系统资源不足。同时线程池也是为了提升系统效率。

线程池的核心线程与普通线程：
任务队列可以存放100个任务，此时为空，线程池里有10个核心线程，若突然来了10个任务，那么刚好10个核心线程直接处理；若又来了90个任务，此时核心线程来不及处理，那么有80个任务先入队列，再创建核心线程处理任务；若又来了120个任务，此时任务队列已满，不得已，就得创建20个普通线程来处理多余的任务。 以上是线程池的工作流程。

不编程的鑫心
关注
嵌入式——线程实验.ppt
04-07
线程实验.ppt嵌入式试验资料。。。。。
嵌入式开发------------线程
weixin_46581245的博客
05-03 182
1.多线程访问临界资源时,没有顺序而言，若线程A访问临界资源,不允许其他线程访问资源。2.引入互斥锁:用来保证共享数据操作的完整性。
线程（嵌入式学习）
JiaYu的博客
03-28 517
线程（英语：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程（kernel thread），而把用户线程（user thread）称为线程。 线程是独立调度和分派的基本单位。线程可以为操作系统内核调度的内核线程，如Win32线程；由用户
嵌入式学习记录——线程
weixin_71422178的博客
03-05 1001
线程:线程是一个轻量级的进程,位于进程空间内部,一个进程中可以创建多个线程。
在linux嵌入式应用当中，如何创建多线程任务，C语言实现的具体过程
m0_67545273的博客
03-18 710
类型的数组来存放线程的标识符，以及一些变量用于循环和错误检查。函数创建了多个线程，并将其与指定的线程函数进行关联。类型，然后打印出相应的线程号。该函数是由每个线程执行的实际任务。最后，我们打印一条消息表示所有线程已经完成，并退出程序。上述代码中，我们首先包含了必要的头文件。类型的参数，并在函数中将其转换为。函数等待所有线程执行完毕。接着定义了一个线程函数。函数中，我们声明了一个。
2021-07-02嵌入式学习---线程
kangxiansen的博客
07-02 349
1、线程与进程 　　典型的UNIX/Linux进程可以看成只有一个控制线程：一个进程在同一时刻只做一件事情。有了多个控制线程后，在程序设计时可以把进程设计成在同一时刻做不止一件事，每个线程各自处理独立的任务。　　 　　进程是程序执行时的一个实例，是担当分配系统资源（CPU时间、内存等）的基本单位。在面向线程设计的系统中，进程本身不是基本运行单位，而是线程的容器。程序本身只是指令、数据及其组织形式的描述，进程才是程序（那些指令和数据）的真正运行实例。 　　线程是操作系统能够进行运算调度的最小单位。它被包含在进
嵌入式系统/ARM技术中的MIPS发布嵌入式多线程多处理器IP核MIPS32 1004K
11-21
MIPS科技推出业界首款嵌入式多线程和多处理器可授权IP核MIPS32 1004K——一致处理系统（coherent processing system）。新的多核产品可为多处理器系统配置多达4个单线程或多线程处理器，加上先进的一致性系统来提供...
创新的嵌入式Linux——TenHz Linux.pdf
09-07
《创新的嵌入式Linux——TenHz Linux》 腾思软件在2003年上半年推出的TenHz Linux是一款专为嵌入式系统设计的操作系统，它基于GPL协议，开放全部源代码，无需任何额外的开发和生产许可协议。这一创新使得用户能够在...
嵌入式软件设计基础
09-17
《嵌入式软件设计基础：基于ARM Cortex-M3(原书第2版)》以实践中常运用的方式讲解汇编语言——实现小型、快速或特殊目的的例程，这些例程由主程序(高级语言编写，如C)调用。通过运用嵌入式软件环境，本书介绍多线程...
QT编程——嵌入式QT编程
12-17
在提供的PDF文档《QT编程——嵌入式QT编程》中，读者可以期待找到关于这些主题的详细解释，包括实例代码和最佳实践。这份参考资料将帮助开发者快速理解和掌握在嵌入式设备上使用QT进行开发的技巧，从而提升项目的...
嵌入式系统/ARM技术中的线程解析（一）
11-09
作者：曹忠明，华清远见嵌入式学院讲师。 　　在使用线程之前我们要知道线程是个怎样的概念，它的作用是什么？ 　　在学多进程或多线程编程的时候，有这样一个概念----进程是资源管理的最小单位，线程是程序执行的最小单位，相对于进程，线程上下文切换花费的开销更少。因为线程共享了内存空间，不同线程可以访问同一个变量，即多有线程都可以访问已经声明了的全局变量。在多进程中这种情况需要使用IPC(进程间通信)对象实现，这样增加了额外的开销，从而降低了性能，并且增加了代码的复杂度。 　　在执行方面线程也有着它的优势，因为在创建线程的过程中系统无需复制内存空间和文件描述符等，这样节省了很多的cpu时间。
嵌入式学习之多线程编程
09-15
请遵循 “署名-非商业用途-保持一致” 的创作共用协议，代码仅适合学习使用，未经过任何的工业级检测，请慎用
嵌入式实时操作系统的多线程计算--基于ThreadX和ARM--随书光盘（自己备份）
10-07
Express Logic's ThreadX for Win32 Demo Using Visual C/C++ This demo program is intended for use with the book titled "Real-Time Embedded Multithreading: Using ThreadX and ARM" by Edward L. Lamie.
嵌入式学习之线程
一棵小树苗的博客
05-14 1335
线程概述 一个程序中的多个执行路线叫做线程，线程是一个进程内部的控制序列。 所有的进程都至少有一个执行线程(初始线程)。 初始线程随进程的创建而创建， 其他线程则需要通过显式的函数调用来创建。 进程与线程： ①进程拥有自己的PID和变量，独立的内存单元进行调度，执行(几乎)独立于父进程。 ②新线程拥有自己独立的栈(eg.局部变量)，但与创建者共享全局变量、文件描述符、信号句柄、当前目录状态。 ③独立进程和共享线程使得程序运行效率大大提高。 线程的优缺点 优点： 程序并发性 多线程适用于大多数应用程序
嵌入式学习——2——线程（pthread）
最新发布
qq_37193153的博客
05-10 632
线程是进程的最小组成单位：一个进程里面，至少有一个线程的存在，称为主线程，main函数运行的就是所谓的主线程。
【嵌入式Linux】线程与进程
sl_97的博客
04-10 2558
线程是独立调度和分派的基本单位。线程可以为操作系统内核调度的内核线程。进程是一个具有独立功能的程序关于某个数据集合的一次运行活动。它可以申请和拥有系统资源，是一个动态的概念，是一个活动的实体。
嵌入式Linux基础——线程
Atticus的博客
06-25 439
什么是线程 在一个程序中的多个执行路线就叫做线程（thread）。更准确的定义是：线程是一个进程内部的一个控制序列。虽然Linux和许多其他的操作系统一样，都擅长同时运行多个进程，但迄今为止我们看到的所有程序在执行时都是作为一个单独的进程。事实上，所有的进程都至少有一个执行线程。 弄清楚fork系统调用和创建新线程之间的区别非常重要。当进程执行fork调用时，将创建出该进程的一份新副本。这个新进程拥有自己的变量和自己的PID，它的时间调度也是独立的，它的执行（通常）几乎完全独立于父进程。当在进程中创建一个新
嵌入式Linux应用程序开发-（5）嵌入式QT多线程的简单实现（方法一）
EmbedIoT Studio
04-16 3501
本文的内容是拜读完以下文章后的总结，喝水不忘挖井人，感谢前辈的肩膀，让我们这些晚辈少走弯路，走得更远。如果已经理解了原作者的文章，则可完全忽略本文，感谢支持和关注。https://blog.csdn.net/czyt1988/article/details/64441443 在嵌入式Linux应用程序的开发过程中，多线程永远是一个不可逃避的话题。多线程的出现，可以...
嵌入式开发28天（线程）
Reasonss的博客
08-15 1443
线程 线程和进程的关系。 线程--“轻量级的进程”，进程本身就是一个单线程。 线程是进程中的实体，一个进程可以拥有多个线程。 线程与进程的其它线程共享该 进程所拥有的全部资源 。 多线程可以实现多任务，使用的是并发机制。 线程和进程使用同一块内存，所有非局部变量的都可以共享 （fd,全局，堆）。 进程结束，线程就不存在。 pthread_create（）
嵌入式Linux下的多线程程序设计——解析生产者-消费者问题
"嵌入式课程设计主要关注的是在Linux环境下如何进行多线程程序设计，特别是通过解决生产者—消费者问题来理解线程的同步和资源管理。课程旨在使学生掌握操作系统基础知识，如进程、线程和系统调用，并熟悉Linux下的...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值