Linux C/C++之线程基础

最新推荐文章于 2024-04-28 13:16:41 发布
最新推荐文章于 2024-04-28 13:16:41 发布
阅读量2.4k 收藏 10
点赞数 13
分类专栏： Linux 文章标签： linux C语言 c语言 Linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ShiXiAoLaNga/article/details/124286572
版权

目录

1. 什么是线程

1.1 进程与线程

1.2 线程

1.3 线程的发展史

2. 如何创建,使用线程

2.1 pthread_create函数创建线程

2.2 pthread_create函数的使用

2.3 主线程结束, 分支线程也会随之结束

2.4 同一进程内多个线程共用进程资源

2.5 线程使用进程开辟的动态内存,主线程提前释放内存会造成的问题

2.6 使用地址传递传递数据到线程运行函数

2.7 使用值传递传递数据到线程运行函数

2.8 结构体数据类型的参数传递

3. 线程的结束

3.1 自然结束

3.2 主线程结束, 分支线程随之结束 

3.3 线程自己结束自己

3.4 其它线程结束某个线程

4. 线程的同步

4.1 临界区域与临界数据

4.2 多个线程同时操作临界数据导致的问题

4.3 使用线程同步解决临界数据脏的方式

4.3.1 原子锁(atomic)

4.3.2 自旋锁(spin)

4.3.3 信号量(sem)

4.3.4 读写锁(rwlock)

4.3.5 互斥锁(mutex)

4.3.6 临界变量(cond)

1. 什么是线程

1.1 进程与线程

进程是操作系统资源调度的基本单位

线程是操作系统调度的基本单位

1.2 线程

 线程，被称为轻量级进程(Lightweight Process,LWP),是程序执行流的最小单元

1.3 线程的发展史

2.2版本的内核中, 没有线程, 进程的个数也有限, 4090个, 线程是轻量级的进程, 2.4版本的内核中, 有了线程的概念, 线程的个数可以无限, 协程是更轻量级的线程

2. 如何创建,使用线程

2.1 pthread_create函数创建线程

 

创建并执行线程,执行代码为线程函数,并且和当前主线程并行

2.2 pthread_create函数的使用

//使用pthread_create 创建一个线程
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>

void* pFunc(void* arg){
	int m = 1;
	while(1){
		printf("线程 --- m: %d\n",m++);
		sleep(1);
	}
}
int main(){
	int n = 1;
	//创建一个线程
	pthread_t pid;
	pthread_create(&pid,NULL,pFunc,NULL);
	while(1){
		printf("主函数 --- n: %d\n",n++);
		sleep(1);
	}
	return 0;
}

 

2.3 主线程结束, 分支线程也会随之结束

//当主线程结束,分支线程也会随即结束
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>

void* pFunc(void* arg){
	int m = 1;
	while(1){
		printf("线程 --- m: %d\n",m++);
		sleep(1);
	}
}
int main(){
	int n = 1;
	//创建一个线程
	pthread_t pid;
	pthread_create(&pid,NULL,pFunc,NULL);
	for(int i = 0; i < 5; i++){
		printf("主函数 --- n: %d\n",n++);
		sleep(1);
	}
	return 0;
}

 

2.4 同一进程内多个线程共用进程资源

//同一进程内的线程共用进程的资源
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>

int num = 0;
void* pFunc1(void* arg){
	while(1){
		printf("线程1 --- num: %d\n",num++);
		sleep(1);
	}
}

void* pFunc2(void* arg){	//先于线程一执行
	while(1){
		printf("线程2 --- num: %d\n",num++);
		sleep(1);
	}
}

int main(){
	//创建一个线程
	pthread_t pid1,pid2;
	pthread_create(&pid1,NULL,pFunc1,NULL);
	pthread_create(&pid2,NULL,pFunc2,NULL);
	while(1){
		printf("主函数 --- num: %d\n",num++);
		sleep(1);
	}
	return 0;
}

2.5 线程使用进程开辟的动态内存,主线程提前释放内存会造成的问题

//当使用动态内存申请时,主线程提前将内存释放会造成的问题
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>

void* pFunc(void* arg){
	while(1){
		printf("线程 --- arg: %d\n",*(int*)arg);
		sleep(1);
	}
}
int main(){
	int* n = (int*)malloc(4);
	*n = 666;
	//创建一个线程
	pthread_t pid;
	pthread_create(&pid,NULL,pFunc,n);
	for(int i = 0; i < 5; i++){
		if(i == 2){
			free(n);
			n = NULL;
		}
		printf("主函数 --- n: %d\n",(*n)++);
		sleep(1);
	}
	return 0;
}

2.6 使用地址传递传递数据到线程运行函数

//使用变量的地址传参 &
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>

void* pFunc(void* arg){
	while(1){
		printf("线程 --- arg: %d\n",(*(int*)arg)++);
		sleep(1);
	}
}
int main(){
	int n = 666;
	//创建一个线程
	pthread_t pid;
	pthread_create(&pid,NULL,pFunc,&n);
	while(1){
		printf("主函数 --- n: %d\n",n++);
		sleep(1);
	}
	return 0;
}

2.7 使用值传递传递数据到线程运行函数

//使用(void*)变量直接传参
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>

void* pFunc(void* arg){
	while(1){
		printf("线程 --- arg: %d\n",(int)arg++);
		sleep(1);
	}
}
int main(){
	int n = 666;
	//创建一个线程
	pthread_t pid;
	pthread_create(&pid,NULL,pFunc,(void*)n);
	while(1){
		printf("主函数 --- n: %d\n",n++);
		sleep(1);
	}
	return 0;
}

2.8 结构体数据类型的参数传递

//结构体类型的参数传递
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>

struct Student{
	char name[20];
	int age;
	double score;
};

void* pFunc(void* arg){
	struct Student* stu = (struct Student*)arg;
	while(1){
		printf("线程===\n");
		printf("name:%s,age:%d,score:%g\n",
			stu->name,stu->age,stu->score);
		sleep(1);
	}
}

int main(){

	struct Student stu = {"张三",18,66.66};
	pthread_t pid;
	pthread_create(&pid,NULL,pFunc,&stu);
	for(int i = 0; i < 5; i++){
		printf("主函数---\n");
		sleep(1);
	}

	return 0;
}

3. 线程的结束

3.1 自然结束

线程运行完自己应该执行的代码块后自然结束

3.2 主线程结束, 分支线程随之结束 

注: 主线程最好等待分支线程结束再结束

pthread_join函数使用

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

void* func(void* arg){
	while(1){
		sleep(2);
		printf("线程-----\n");	
	}
}

int main(){
	pthread_t pid;

	pthread_create(&pid,NULL,func,NULL);

	printf("主线程-----\n");

	return 0;
}

没有pthread_join函数的情况 , 主线程不会等待分支线程结束后再结束

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

void* func(void* arg){
	while(1){
		sleep(2);
		printf("线程-----\n");	
	}
}

int main(){
	pthread_t pid;

	pthread_create(&pid,NULL,func,NULL);

	printf("主线程-----\n");

	pthread_join(pid,NULL);

	return 0;
}

 有pthread_join的情况,主线程会等待分支线程结束后,自己再结束

3.3 线程自己结束自己

进程的结束使用 exit   或    _exit

线程的结束使用 pthread_exit

//线程自己结束自己pthread_exit
//void pthread_exit(void *retval); retval线程结束的返回值
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>

void* func(void* arg){
	int num = 666;
	for(int i = 0;i < 10; i++){
		if(i == 5){
			//pthread_exit((void*)num);
			pthread_exit((void*)"线程退出!");
		}
		printf("线程 >> %d\n",(*(int*)arg)++);
		sleep(1);
	}
	
}

int main(){
	int n = 1;
	void* pthread_res; //接收线程结束的返回值
	pthread_t pid;

	pthread_create(&pid,NULL,func,&n);

	pthread_join(pid,&pthread_res); //等待线程结束并接收返回值

	//printf("pthread_return: %d\n",(int)pthread_res);
	printf("pthread_return: %s\n",(char*)pthread_res);
	printf(" >> %d\n",n);

	return 0;
}

3.4 其它线程结束某个线程

pthread_cancel函数: 仅向线程发送一个结束请求, 至于是否结束看pthread_setcancelstate()函数参数一是忽略(PTHREAD_CANCEL_DISABLE)还是响应(PTHREAD_CANCEL_ENABLE)   

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

int n = 1;
pthread_t pid1;

void* func1(void* arg){
	while(1){
		printf("线程1 >> %d\n",n++);
		//PTHREAD_CANCEL_ENABLE（缺省：响应）
		//PTHREAD_CANCEL_DISABLE（忽略）
		pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,NULL);
		pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED,NULL);
		//PTHREAD_CANCEL_DEFERRED（下个取消点）
		//PTHREAD_CANCEL_ASYNCHRONOUS（异步(随时)取消）

		sleep(1);
	}
}

int main(){

	pthread_create(&pid1,NULL,func1,NULL);
	while(1){
		if(n == 5){
			pthread_cancel(pid1);
			break;
		}
	}

	pthread_join(pid1,NULL);

	printf(">> %d\n",n);

	return 0;
}

 PTHREAD_CANCEL_ENABLE: 

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

int n = 1;
pthread_t pid1;

void* func1(void* arg){
	while(1){
		printf("线程1 >> %d\n",n++);
		//PTHREAD_CANCEL_ENABLE（缺省：响应）
		//PTHREAD_CANCEL_DISABLE（忽略）
		pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);
		pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED,NULL);
		//PTHREAD_CANCEL_DEFERRED（下个取消点）
		//PTHREAD_CANCEL_ASYNCHRONOUS（异步(随时)取消）
		//pthread_testcancel();  //加一个取消点

		printf("sleep1\n");
		sleep(1);

		printf("sleep2\n");
		sleep(1);

		printf("sleep3\n");
		sleep(1);
	}
}

int main(){

	pthread_create(&pid1,NULL,func1,NULL);
	while(1){
		if(n == 5){
			pthread_cancel(pid1);
			break;
		}
	}

	pthread_join(pid1,NULL);

	printf(">> %d\n",n);

	return 0;
}

 

4. 线程的同步

4.1 临界区域与临界数据

多个线程可以同时 访问 的 区域 称之为 临界区域

多个线程可以同时 操作 的 数据 称之为 临界数据

4.2 多个线程同时操作临界数据导致的问题

//多个线程同时操作临界数据,导致临界数据脏的问题
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>

int n = 0;
void* func1(void* arg){
	for(int i = 0; i < 25000000; i++)
		n++;
}

void* func2(void* arg){
	for(int i = 0; i < 25000000; i++)
		n++;
}

int main(){
	pthread_t p1,p2,p3,p4;

	pthread_create(&p1,NULL,func1,NULL);
	pthread_create(&p2,NULL,func2,NULL);
	pthread_create(&p3,NULL,func1,NULL);
	pthread_create(&p4,NULL,func2,NULL);

	pthread_join(p1,NULL); 	//等待线程结束
	pthread_join(p2,NULL); 	//等待线程结束
	pthread_join(p3,NULL); 	//等待线程结束
	pthread_join(p4,NULL); 	//等待线程结束

	printf("n: %d\n",n);	// <= 100000000

	return 0;
}

4.3 使用线程同步解决临界数据脏的方式

内核态用户态
原子锁(atomic)读写锁(rwlock)
自旋锁(spin)互斥锁(mutex)
信号量(sem)临界变量(cond)

4.3.1 原子锁(atomic)

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

#define atomic_inc(x)  __sync_fetch_and_add(x,1)

void* func1(void* arg){
	for(int i = 0; i < 50000000; i++)
		atomic_inc((int*)arg);
}

void* func2(void* arg){
	for(int i = 0; i < 50000000; i++)
		atomic_inc((int*)arg);
}

int main(){
	pthread_t p1,p2;
	int n = 0;
	
	pthread_create(&p1,NULL,func1,&n);
	pthread_create(&p2,NULL,func2,&n);

	pthread_join(p1,NULL); 	//等待线程结束
	pthread_join(p2,NULL); 	//等待线程结束

	printf("n: %d\n",n);	

	return 0;
}

4.3.2 自旋锁(spin)

自旋锁的建立消耗的资源少, 但是当线程阻塞时, 它会一直循环不断地检查锁是否可用, 因此当线程处于阻塞状态下, 消耗的资源相对较多

  1. 初始化自旋锁         pthread_spin_init        
  2. 获取(上)锁              pthread_spin_lock
  3. 释放(解)锁              pthread_spin_unlock
  4. 销毁锁                    pthread_spin_destroy
//自旋锁(spin)的使用
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>

int n = 0;
//0. 定义自旋锁
pthread_spinlock_t spin;

void* func1(void* arg){
	for(int i = 0; i < 50000000; i++){
		//2. 上锁
		pthread_spin_lock(&spin);
		//操作
		n++;
		//3. 解锁
		pthread_spin_unlock(&spin);
	}
}

void* func2(void* arg){
	for(int i = 0; i < 50000000; i++){
		//2. 上锁
		pthread_spin_lock(&spin);
		//操作
		n++;
		//3. 解锁
		pthread_spin_unlock(&spin);
	}
}

int main(){
	pthread_t p1,p2;

	//1. 初始化自旋锁
	pthread_spin_init(&spin,PTHREAD_PROCESS_PRIVATE);

	pthread_create(&p1,NULL,func1,NULL);
	pthread_create(&p2,NULL,func2,NULL);

	pthread_join(p1,NULL); 	//等待线程结束
	pthread_join(p2,NULL); 	//等待线程结束

	printf("n: %d\n",n);	

	//4. 销毁自旋锁
	pthread_spin_destroy(&spin);

	return 0;
}

4.3.3 信号量(sem)

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

int n = 0;
//0. 定义信号量
sem_t sem;

void* func1(void* arg){
	//信号量值减一
	if(0 == sem_wait(&sem)){
		for(int i = 0; i < 50000000; i++){
			n++;
			//信号量值加一
			sem_post(&sem);
		}
	}	
}

int main(){
	pthread_t p1,p2;

	//1. 初始化信号量
	//参数二 0 当前进程使用   1  多个进程间共享
	sem_init(&sem, 0, 2);

	pthread_create(&p1,NULL,func1,NULL);
	pthread_create(&p2,NULL,func1,NULL);

	pthread_join(p1,NULL); 	//等待线程结束
	pthread_join(p2,NULL); 	//等待线程结束

	printf("n: %d\n",n);

	//销毁信号量
	sem_destroy(&sem);	

	return 0;
}

4.3.4 读写锁(rwlock)

  1. 初始化读写锁        pthread_rwlock_init
  2. 获取锁                   pthread_rwlock_wrlock(写锁)       pthread_rwlock_rdlock(读锁)
  3. 释放锁                   pthread_rwlock_unlock
  4. 销毁锁                   pthread_rwlock_destroy
//读写锁(rwlock)的使用	读读相容
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>

int n = 0;
//0. 定义读写锁变量
pthread_rwlock_t rwlock;

void* func1(void* arg){
	for(int i = 0; i < 50000000; i++){
		//2. 上锁(读锁)
		pthread_rwlock_rdlock(&rwlock);
		//pthread_rwlock_wrlock(&rwlock);
		//操作
		n++;
		//3. 解锁
		pthread_rwlock_unlock(&rwlock);
	}
}

void* func2(void* arg){
	for(int i = 0; i < 50000000; i++){
		//2. 上锁(读锁)
		pthread_rwlock_rdlock(&rwlock);
		//pthread_rwlock_wrlock(&rwlock);
		//操作
		n++;
		//3. 解锁
		pthread_rwlock_unlock(&rwlock);
	}
}

int main(){
	pthread_t p1,p2;

	//1. 初始化读写锁
	pthread_rwlock_init(&rwlock,NULL);

	pthread_create(&p1,NULL,func1,NULL);
	pthread_create(&p2,NULL,func2,NULL);

	pthread_join(p1,NULL); 	//等待线程结束
	pthread_join(p2,NULL); 	//等待线程结束

	printf("n: %d\n",n);	

	//4. 销毁读写锁
	pthread_rwlock_destroy(&rwlock); 

	return 0;
}

 读读相容 

 

void* func1(void* arg){
	for(int i = 0; i < 50000000; i++){
		//2. 上锁(读锁)
		pthread_rwlock_rdlock(&rwlock);
		//操作
		n++;
		//3. 解锁
		pthread_rwlock_unlock(&rwlock);
	}
}

void* func2(void* arg){
	for(int i = 0; i < 50000000; i++){
		//2. 上锁(写锁)
		pthread_rwlock_wrlock(&rwlock);
		//操作
		n++;
		//3. 解锁
		pthread_rwlock_unlock(&rwlock);
	}
}

 读写相斥

void* func1(void* arg){
	for(int i = 0; i < 50000000; i++){
		//2. 上锁(写锁)
		pthread_rwlock_wrlock(&rwlock);
		//操作
		n++;
		//3. 解锁
		pthread_rwlock_unlock(&rwlock);
	}
}

void* func2(void* arg){
	for(int i = 0; i < 50000000; i++){
		//2. 上锁(写锁)
		pthread_rwlock_wrlock(&rwlock);
		//操作
		n++;
		//3. 解锁
		pthread_rwlock_unlock(&rwlock);
	}
}

写写相斥        

4.3.5 互斥锁(mutex)

互斥锁适合频繁操作的情况

若等待时间较长, 突然要解决事务(注意临界数据安全的问题)

互斥锁的建立消耗的资源多, 但是当线程阻塞时, 不会循环不断地检查锁是否可用, 因此当线程处于阻塞状态下不消耗资源

因此自旋锁适用于阻塞时间很短的情况, 互斥锁适用于阻塞时间很长的情况

  1. 初始化互斥锁         pthread_mutex_init        
  2. 获取(上)锁              pthread_mutex_lock
  3. 释放(解)锁              pthread_mutex_unlock
  4. 销毁锁                    pthread_mutex_destroy
//互斥锁(mutex)的使用
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>

int n = 0;
//0. 定义互斥变量
pthread_mutex_t mutex;

void* func1(void* arg){
	for(int i = 0; i < 50000000; i++){
		//2. 上锁
		pthread_mutex_lock(&mutex);
		//操作
		n++;
		//3. 解锁
		pthread_mutex_unlock(&mutex);
	}
}

void* func2(void* arg){
	for(int i = 0; i < 50000000; i++){
		//2. 上锁
		pthread_mutex_lock(&mutex);
		//操作
		n++;
		//3. 解锁
		pthread_mutex_unlock(&mutex);
	}
}

int main(){
	pthread_t p1,p2;

	//1. 初始化互斥量
	pthread_mutex_init(&mutex,NULL);

	pthread_create(&p1,NULL,func1,NULL);
	pthread_create(&p2,NULL,func2,NULL);

	pthread_join(p1,NULL); 	//等待线程结束
	pthread_join(p2,NULL); 	//等待线程结束

	printf("n: %d\n",n);
	//4. 销毁互斥锁
	pthread_mutex_destroy(&mutex);

	return 0;
}

 

4.3.6 临界变量(cond)

 临界变量是互斥锁的升级(因此临界变量一般搭配互斥锁使用)

  1. 初始化互斥锁,临界变量         pthread_mutex_init        pthread_cond_init        
  2. 获取(上)锁, 临界变量等待      pthread_mutex_lock      pthread_cond_wait
  3. 释放(解)锁                              pthread_mutex_unlock
  4. 发信号给临界变量                  pthread_cond_signal        pthread_cond_broadcast
  5. 销毁锁,销毁临界变量             pthread_mutex_destroy   pthread_cond_destroy
//临界(条件)变量(cond)的使用
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>

int n = 0;
//0. 定义互斥变量
pthread_mutex_t mutex;
//0. 定义临界变量
pthread_cond_t cond;

void* func1(void* arg){
	for(int i = 0; i <= 5; i++){
		//2. 上锁,临界变量等待
		pthread_mutex_lock(&mutex);
		pthread_cond_wait(&cond,&mutex);
		//操作
		printf("线程1 ------ %d\n",n++);
		//3. 解锁
		pthread_mutex_unlock(&mutex);
	}
}

void* func2(void* arg){
	for(int i = 0; i <= 5; i++){
		//2. 上锁,临界变量等待
		pthread_mutex_lock(&mutex);
		pthread_cond_wait(&cond,&mutex);
		//操作
		printf("线程2 ====== %d\n",n++);
		//3. 解锁
		pthread_mutex_unlock(&mutex);
	}
}

int main(){
	pthread_t p1,p2,p3,p4;

	//1. 初始化互斥锁和临界变量
	pthread_mutex_init(&mutex,NULL);
	pthread_cond_init(&cond,NULL);

	pthread_create(&p1,NULL,func1,NULL);
	pthread_create(&p2,NULL,func2,NULL);

	//4. 发信号给临界变量
	for(int i = 0; i < 13; i++){
		//解除全部线程的阻塞状态(一次)
		//pthread_cond_broadcast(&cond);
		//解除至少一个线程的阻塞状态(一次)
		pthread_cond_signal(&cond);
		//pthread_cond_signal(&cond);
		sleep(1);
	}
	
	pthread_join(p1,NULL); 	//等待线程结束
	pthread_join(p2,NULL); 	//等待线程结束

	printf("n: %d\n",n);	

	//5. 销毁互斥锁和临界变量
	pthread_mutex_destroy(&mutex);
	pthread_cond_destroy(&cond);

	return 0;
}

石小浪♪
关注
  • 13
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
linux C++ 实现线程池（避免线程创建的耗时）
05-22
linux下c++写的线程池，可以了解pthread_cond_timewait和pthread_detach的用法，自定义最大使用的线程数量，线程退出线程池的超时时间，任务优先级处理。
Linux 原子操作
weixin_30443731的博客
11-16 396
所谓原子操作，就是该操作绝不会在执行完毕前被任何其他任务或事件打断，也就说，它的最小的执行单位，不可能有比它更小的执行单位，因此这里的原子实际是使用了物理学里的物质微粒的概念。 　　原子操作需要硬件的支持，因此是架构相关的，其API和原子类型的定义都定义在内核源码树的include/asm/atomic.h文件中，它们都使用汇编语言实现，因为C语言并不能实现这样的操作。 　　原子操作...
Linux驱动开发：并发与竞态
W__winter的博客
05-14 760
/配合 atomic_dec_and_test 使用//定义并初始化原子变量//配合 atomic_inc_and_test 使用//定义并初始化原子变量。
linux内核原子操作
yongjong的专栏
09-02 482
创建两个内核线程thread_inc和thread_dec，分别调用atomic_inc和atomic_dec函数，atomic_inc每隔1秒调用一次，atomic_dec每隔2秒调用一次，调用完成之后使用atomic_read接口打印atomic值。描述：测试下linux内核驱动常用的几个atomic操作函数。OS版本：openEuler 22.03 LTS。
linux C++ 多线程编程
xyyangkun的专栏
11-23 1303
http://blog.chinaunix.net/uid-14880649-id-2954431.html 1.Solaris .vs. Linux Posix 库   Solaris 库（lib 线程） Linux POSIX 库（libp 线程） 操作 sema_destroy() sem_destroy() 销毁信号状态。
线程控制
diaofoulu2041的博客
09-13 184
目录 1. 线程与进程 线程的概念 深入理解进程和线程 2. 多线程 什么是多线程 多线程模型的好处 3. 线程标识 4. 线程创建 函数原型 参数说明 ...
Linux C/C++线程
Abieai的博客
04-25 1070
文章目录一、线程是什么？二、线程创建三、线程终止四、线程分离五、线程连接六、线程属性总结 一、线程是什么？ （英语：thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。在Unix System V及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程（kernel thread），而把用户线程（user thread
C++线程 linux
a1299960335的博客
05-01 483
C++线程一、线程的概念1. 什么是线程2. 线程的概念二、线程的优缺点1. 线程的优点2. 线程的缺点(1) 性能损失(2) 健壮性降低(3) 缺乏访问控制(4) 编程难度高3. 线程异常三、线程用途四、linux 线程编写 一、线程的概念 1. 什么是线程 在谈线程之前，我们先看看进程。 创建一个进程，我们从0到有创建了很多东西，申请了很多资源。 我们在创建进程时，如果让其他的pcb指向同一个地址空间。我们能不能将代码分成若干个块，让每个pcb执行代码的某一部分。 以前我们是一个进程执行，现在我们用
Linux网络吞吐量多线程基准测试工具。-C/C++开发
05-26
NTTTCP-for-Linux概述一个多线程Linux网络吞吐量基准测试工具。 具有多个线程来发送/接收数据（“ -P”，“-n”和“ -l”）。 默认情况下，Receiver（'-r'）使用16个线程进行NTTTCP-for-Linux摘要一个多线程Linux...
Linux C/C++发起http请求示例
03-14
Linux C/C++发起http请求， 多线程示例
C/C++ linux下具备功能的线程池，拿来就可以用
08-29
一个写好的线程池类，拿去就可以使用！
Linux C/C++线程基类源代码
02-21
封装了Linux下C++开发使用线程的基类，可以直接继承调用。
linux c/c++ gdb调试手册
05-23
linux c/c++ gdb调试手册
Linux多线程服务端编程：使用muduo C++网络库.rar_Linux/Unix编程_C/C++_
08-09
Linux多线程服务端编程指南，其中内容为使用muduo C++网络库。
13 Linux实操篇-网络配置
qq_74289024的博客
04-23 1046
子网ip 与网关。
Linux多进程(五) 进程池 C++实现
Lyajpunov的博客
04-26 801
进程池是一种并发编程模式，用于管理和重用多个处理任务的进程。它通常用于需要频繁创建和销毁进程的情况，以避免因此产生的开销。减少进程创建销毁的开销：避免频繁创建和销毁进程所带来的系统资源开销。提高系统响应速度：由于进程已经初始化并且一直保持在内存中，可以立即分配执行任务，减少了任务等待时间。控制资源使用：通过限制进程池中的进程数量，可以控制系统资源的使用情况，避免资源过度消耗。
Linux——web服务配置
Xinan_____的博客
04-23 1132
GET：请求获取指定资源的表示形式。使用GET方法，客户端请求服务器发送某个资源。POST：向指定资源提交数据，用于处理表单提交、文件上传等操作。PUT：向指定资源位置上传其最新内容，用于更新资源。DELETE：请求服务器删除指定资源。HEAD：请求获取与实体相对应的头部信息，用于获取资源的元数据。OPTIONS：请求查询服务器支持的HTTP方法。TRACE：请求服务器回显收到的请求消息，用于测试或诊断。200 OK：请求成功。：永久重定向，请求的资源已经被分配了新的。
Linux：浏览器访问网站的基本流程（优先级从先到后）
最新发布
fox_kang的博客
04-28 610
浏览器访问网站的基本流程（优先级从先到后） 首先查找浏览器是否存在该网站的访问缓存 其次查找本机的域名解析服务器 windows：C:\Windows\System32\drivers\etc\hosts Linux：/etc/hosts 使用外部的域名解析服务器解析（例如：114.114.114.114） 第一步：浏览器使用域名访问www.bilibili.com.网站 第二步：首先去访问根域名解析服务器查询，根服务器返回.com域名解析服务器地址==（这里的根域名解析服务器不会直接给出域名对应的
Linux 抽象命名空间（Abstract Namespace）简介
日拱一卒，玉汝于成
04-25 590
与传统的 UDS 不同，抽象命名空间并不在文件系统中创建实际文件，而是仅存在于内核内存中，其名称以 localabstract: 作为前缀。在这个例子中，我们创建了一个名为 my_abstract_namespace 的抽象命名空间，并将其绑定到了刚创建的 Unix 套接字上。要在 Linux 系统中生成一个抽象命名空间，通常需要使用编程语言的套接字 API 来创建一个 Unix 域套接字，并将其绑定到一个以 localabstract: 开头的特殊路径。
linux c/c++ 后台开发实践 pdf
10-21
《Linux C/C++ 后台开发实践》是一本介绍在Linux环境下使用C/C++进行后台开发的实践指南。 该书主要分为以下几个部分： 第一部分是介绍Linux基础知识，包括Linux操作系统的原理、常用命令等。这部分的目的是为读者打下Linux基础，为后面的主题提供必要的背景知识。 第二部分是介绍C/C++语言的基础知识，包括语法、指针、内存管理等。这部分的目的是让读者熟悉C/C++语言的基本特性，为后续的后台开发做好准备。 第三部分是介绍Linux下的网络编程，包括Socket编程、网络通信协议等。这部分的目的是让读者了解网络编程的基本原理并能够使用C/C++进行网络通信。 第四部分是介绍多线程编程和进程间通信，包括线程的创建与同步、进程间的通信机制等。这部分的目的是让读者了解多线程编程和进程间通信的原理，并能够使用C/C++进行相关的开发。 第五部分是介绍常用的后台开发框架和技术，包括数据库访问、消息队列、Web服务等。这部分的目的是让读者了解后台开发中常用的框架和技术，并能够使用C/C++进行相关的开发。 通过阅读《Linux C/C++ 后台开发实践》，读者可以系统地了解并掌握在Linux环境下使用C/C++进行后台开发的基本技能。这本书的内容丰富、深入浅出，适合有一定编程基础的读者阅读，并可以作为后台开发工程师的参考书籍。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

石小浪♪

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值