Linux系统编程——线程

已于 2023-05-17 10:48:43 修改
阅读量205 收藏 2
点赞数
分类专栏： Linux学习笔记 文章标签： linux c语言
于 2023-05-04 22:17:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52150001/article/details/130496465
版权

Linux系统编程–线程

1.线程概述（与进程的区别及线程的优势）

2.线程创建等待退出

3.线程共享内存空间的代码验证

4.线程同步之互斥量加锁解锁

5.互斥锁限制共享资源的访问

6.什么情况造成死锁

7.线程条件控制实现线程的同步

1.线程概述（与进程的区别及线程的优势）

Linux多线程编程初探 - 峰子_仰望阳光 - 博客园 (cnblogs.com)

线程也有竞争的关系。

2.线程创建等待退出

demo1.c

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

//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
void *funs(void *arg)
{
        printf("t1:%ld\npthread is creat\n",(unsigned long)pthread_self());
        printf("parm is %d\n",*((int *)arg));

}
//int pthread_exit(void *rval_ptr);
//int pthread_join(pthread_t thread, void **rval_ptr);
// 返回：若成功返回0，否则返回错误编号
int main()
{

        int ret;
        pthread_t t1;
        int *pret = NULL;
        int parm = 100;
        ret  = pthread_create(&t1,NULL,funs,(void *)&parm); //创建线程
        if(ret == 0){
                printf("creat t1 is success\n");
		
        }
        return 0;
}

运行结果：在这里插入图片描述
编译时需要链上 -lpthread

运行结果与所想不一样（printf(“parm is %d\n”,*((int *)arg));）还没打印就已经结束了，是因为主程序中没有等待返回就已经结束了

demo2.c （返回 int类型）

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

//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
void *funs(void *arg)
{
        static int ret =10;  //如果不用static 函数调用结束后就没掉了，会随机返回 
        printf("t1:%ld\npthread is creat\n",(unsigned long)pthread_self());
        printf("parm is %d\n",*((int *)arg));
        pthread_exit((void *)&ret);  //退出线程

}
//int pthread_exit(void *rval_ptr);
//int pthread_join(pthread_t thread, void **rval_ptr);
// 返回：若成功返回0，否则返回错误编号
int main()
{

        int ret;
        pthread_t t1;
        int *pret = NULL;
        int parm = 100;
        ret  = pthread_create(&t1,NULL,funs,(void *)&parm);
        if(ret == 0){
                printf("creat t1 is success\n");

        }
        printf("main:%ld\n",(unsigned long)pthread_self());
        pthread_join(t1,(void **)&pret); //等待线程退出·
    //pthread_join(t1,NULL);//如果对线程的返回值不感兴趣，可以把rval_ptr置为NULL。在这种情况下，调用pthread_join函数将等待指定的线程终止，但并								//不获得线程的终止状态。
        printf("main:t1 qiut:%d\n",*pret); 
        return 0;
}

运行结果：在这里插入图片描述

demo3.c （返回 char 类型）

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

//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
void *funs(void *arg)
{
        static char *ret = "funs ret quit!";
        printf("t1:%ld\npthread is creat\n",(unsigned long)pthread_self());
        printf("parm is %d\n",*((int *)arg));
        pthread_exit((void *)ret);

}
//int pthread_exit(void *rval_ptr);
//int pthread_join(pthread_t thread, void **rval_ptr);
// 返回：若成功返回0，否则返回错误编号
int main()
{

        int ret;
        pthread_t t1;
        char *pret = NULL;
        int parm = 100;
        ret  = pthread_create(&t1,NULL,funs,(void *)&parm);
        if(ret == 0){
                printf("creat t1 is success\n");

        }
        printf("main:%ld\n",(unsigned long)pthread_self());
        pthread_join(t1,(void **)&pret);
        printf("main: t1 quit:%s\n",pret);
        return 0;
}

运行结果：在这里插入图片描述

3.线程共享内存空间的运行结果代码验证

demo4.c

#include <pthread.h>
#include <stdio.h>
int data = 0;
//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
void *funs(void *arg)
{
	printf("t1:%ld\npthread is creat\n",(unsigned long)pthread_self());
	printf("parm is %d\n",*((int *)arg));
	while(1){
		printf("t1_data:%d\n",data++);
		sleep(1);
        /*
		if(data == 4){				//t1不一定能获得4， 线程间相互竞争，有几率得到4
			pthread_exit(NULL); 	//if data == 4 ;退出t1线程
		}
		*/
	}
}
void *funs2(void *arg)
{
	printf("t2:%ld\npthread is creat\n",(unsigned long)pthread_self());
	printf("parm is %d\n",*((int *)arg));
	while(1){
		printf("t2_data:%d\n",data++);
		sleep(1);
	}
	
}
//int pthread_exit(void *rval_ptr);
//int pthread_join(pthread_t thread, void **rval_ptr);
// 返回：若成功返回0，否则返回错误编号
int main()
{

	int ret;
	pthread_t t1;
	pthread_t t2;
	int *pret = NULL;
	int parm = 100;
	ret  = pthread_create(&t1,NULL,funs,(void *)&parm);
	if(ret == 0){
		printf("creat t1 is success\n");
		
	}
	ret  = pthread_create(&t2,NULL,funs2,(void *)&parm);
	if(ret == 0){
		printf("creat t2 is success\n");
	}
	while(1){
		printf("main_data:%d\n",data++);
		sleep(1);
	}
	pthread_join(t1,NULL);
	pthread_join(t2,NULL);
	return 0;
}

运行结果：在这里插入图片描述

4.线程同步之互斥量加锁解锁

demo5.c

#include <pthread.h>
#include <stdio.h>
int data = 0;
//int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
pthread_mutex_t mutex;//创建锁
//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
void *funs(void *arg)
{
	//int pthread_mutex_lock(*pthread_mutex_t mutex);
	pthread_mutex_lock(&mutex);//上锁
	printf("t1:%ld\npthread is creat\n",(unsigned long)pthread_self());
	printf("parm is %d\n",*((int *)arg));
	//int pthread_mutex_unlock(*pthread_mutext_mutex);
	pthread_mutex_unlock(&mutex);//解锁
}
void *funs2(void *arg)
{
	pthread_mutex_lock(&mutex);//上锁
	printf("t2:%ld\npthread is creat\n",(unsigned long)pthread_self());
	printf("parm is %d\n",*((int *)arg));
	pthread_mutex_unlock(&mutex);//解锁
	
}
//int pthread_exit(void *rval_ptr);
//int pthread_join(pthread_t thread, void **rval_ptr);
// 返回：若成功返回0，否则返回错误编号
int main()
{

	int ret;
	pthread_t t1;
	pthread_t t2;
	int *pret = NULL;
	int parm = 100;
    pthread_mutex_init(&mutex, NULL); //锁动态初始化
	ret  = pthread_create(&t1,NULL,funs,(void *)&parm);
	if(ret == 0){
		printf("creat t1 is success\n");
	}
	ret  = pthread_create(&t2,NULL,funs2,(void *)&parm);
	if(ret == 0){
		printf("creat t2 is success\n");
	}
	pthread_join(t1,NULL);
	pthread_join(t2,NULL);
	//int pthread_mutex_destroy(*pthread_mutex_t mutex);
	pthread_mutex_destroy(&mutex);//销毁锁
	return 0;
}

运行结果：在这里插入图片描述

5.互斥锁限制共享资源的访问

demo6.c

#include <pthread.h>
#include <stdio.h>
int data = 0;
//int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
pthread_mutex_t mutex;
//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
void *funs(void *arg)
{
	//int pthread_mutex_lock(*pthread_mutex_t mutex);
	pthread_mutex_lock(&mutex);
	printf("t1:%ld\npthread is creat\n",(unsigned long)pthread_self());
	printf("parm is %d\n",*((int *)arg));
	//int pthread_mutex_unlock(*pthread_mutext_mutex);
	while(1){
		printf("t1:%d\n",data++);
		sleep(1);
		if(data == 4){

			pthread_mutex_unlock(&mutex);
			printf("t1 quit====================\n");
			pthread_exit(NULL);
		}
	}
}
/*让t1运行到4结束退出线程,刚开始不确定会是哪个线程先运行，到t2,上锁++后解锁，到t1上锁，等data=4时，解锁退出*/
void *funs2(void *arg)
{
	printf("t2:%ld\npthread is creat\n",(unsigned long)pthread_self());
	printf("parm is %d\n",*((int *)arg));
	while(1){
		printf("t2:%d\n",data);
		pthread_mutex_lock(&mutex);
		data++;
		pthread_mutex_unlock(&mutex);
		sleep(1);
	}
}
//int pthread_exit(void *rval_ptr);
//int pthread_join(pthread_t thread, void **rval_ptr);
// 返回：若成功返回0，否则返回错误编号
int main()
{

	int ret;
	pthread_t t1;
	pthread_t t2;
	int *pret = NULL;
	int parm = 100;
    pthread_mutex_init(&mutex, NULL); //锁动态初始化
	ret  = pthread_create(&t1,NULL,funs,(void *)&parm);
	if(ret == 0){
		printf("creat t1 is success\n");
		
	}
	ret  = pthread_create(&t2,NULL,funs2,(void *)&parm);
	if(ret == 0){
		printf("creat t2 is success\n");
	}
	pthread_join(t1,NULL);
	pthread_join(t2,NULL);
	//int pthread_mutex_destroy(*pthread_mutex_t mutex);
	pthread_mutex_destroy(&mutex);
	return 0;
}

运行结果：在这里插入图片描述

6.什么情况造成死锁

demo7.c

#include <pthread.h>
#include <stdio.h>
int data = 0;
//int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
pthread_mutex_t mutex;
pthread_mutex_t mutex2;
//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
void *funs(void *arg)
{
	//int pthread_mutex_lock(*pthread_mutex_t mutex);
	pthread_mutex_lock(&mutex);
	sleep(1);
	pthread_mutex_lock(&mutex2);
	printf("t1:%ld\npthread is creat\n",(unsigned long)pthread_self());
	printf("parm is %d\n",*((int *)arg));
	//int pthread_mutex_unlock(*pthread_mutext_mutex);
	pthread_mutex_unlock(&mutex);
}
void *funs2(void *arg)
{
	pthread_mutex_lock(&mutex);
	sleep(1);
	pthread_mutex_lock(&mutex2);
	printf("t2:%ld\npthread is creat\n",(unsigned long)pthread_self());
	printf("parm is %d\n",*((int *)arg));
	pthread_mutex_unlock(&mutex);
	
}
//int pthread_exit(void *rval_ptr);
//int pthread_join(pthread_t thread, void **rval_ptr);
// 返回：若成功返回0，否则返回错误编号
int main()
{

	int ret;
	pthread_t t1;
	pthread_t t2;
	int *pret = NULL;
	int parm = 100;
    pthread_mutex_init(&mutex, NULL); //锁动态初始化
    pthread_mutex_init(&mutex2, NULL); //锁动态初始化
	ret  = pthread_create(&t1,NULL,funs,(void *)&parm);
	if(ret == 0){
		printf("creat t1 is success\n");
		
	}
	ret  = pthread_create(&t2,NULL,funs2,(void *)&parm);
	if(ret == 0){
		printf("creat t2 is success\n");
	}
	pthread_join(t1,NULL);
	pthread_join(t2,NULL);
	//int pthread_mutex_destroy(*pthread_mutex_t mutex);
	pthread_mutex_destroy(&mutex);
	return 0;
}

要有两把锁，才能有死锁，当funs锁mutex时，funs2锁mutex2了，funs再想锁mutex2时就拿不到，会一直卡住，同理funs2也是。

使用多把锁时，一定要注意避免死锁

7.线程条件控制实现线程的同步

demo8.c

#include <pthread.h>
#include <stdio.h>
int data = 0;
//int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
pthread_mutex_t mutex;
pthread_cond_t cond;
//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
void *funs(void *arg)
{
	printf("t1:%ld\npthread is creat\n",(unsigned long)pthread_self());
	printf("parm is %d\n",*((int *)arg));
	while(1){
		//int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);
		pthread_cond_wait(&cond,&mutex);	//等待触发条件
		printf("t1:%d\n",data);
		printf("t1 qiut================\n");
		data = 0;
		sleep(1);
	}
}
void *funs2(void *arg)
{
	printf("t2:%ld\npthread is creat\n",(unsigned long)pthread_self());
	printf("parm is %d\n",*((int *)arg));
	while(1){
		printf("t2:%d\n",data);
		pthread_mutex_lock(&mutex);
		data++;	
		pthread_mutex_unlock(&mutex);
		if(data == 4){
//int pthread_cond_signal(*pthread_cond_t cond);
			pthread_cond_signal(&cond); //触发条件
		}
		sleep(1);
	}
}
//int pthread_exit(void *rval_ptr);
//int pthread_join(pthread_t thread, void **rval_ptr);
// 返回：若成功返回0，否则返回错误编号
int main()
{

	int ret;
	pthread_t t1;
	pthread_t t2;
	int *pret = NULL;
	int parm = 100;
     pthread_mutex_init(&mutex, NULL); //锁动态初始化
	//int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);
	pthread_cond_init(&cond,NULL); //条件动态初始化
	ret  = pthread_create(&t1,NULL,funs,(void *)&parm);
	if(ret == 0){
	//	printf("creat t1 is success\n");
		
	}
	ret  = pthread_create(&t2,NULL,funs2,(void *)&parm);
	if(ret == 0){
	//	printf("creat t2 is success\n");
	}
	pthread_join(t1,NULL);
	pthread_join(t2,NULL);

	//int pthread_mutex_destroy(*pthread_mutex_t mutex);
	pthread_mutex_destroy(&mutex);
//int pthread_cond_destroy(*pthread_cond_t cond);
	pthread_cond_destroy(&cond); //销毁条件
	return 0;
}

运行结果：在这里插入图片描述

此程序中会一直运行，因为data=0；一直都会在赋值。

#include <pthread.h>
#include <stdio.h>
int data = 0;
//int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
pthread_mutex_t mutex;
pthread_cond_t cond;
//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
void *funs(void *arg)
{
    static int cnt = 3;
	printf("t1:%ld\npthread is creat\n",(unsigned long)pthread_self());
	printf("parm is %d\n",*((int *)arg));
	while(1){
		//int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);
		pthread_cond_wait(&cond,&mutex);	//等待触发条件
		printf("t1:%d\n",data);
		printf("t1 qiut================\n");
		data = 0;
		sleep(1);
        cnt--;
        if(cnt == 0){		//当cnt=0时；整个程序退出
            exit(-1);
        }
	}
}
void *funs2(void *arg)
{
	printf("t2:%ld\npthread is creat\n",(unsigned long)pthread_self());
	printf("parm is %d\n",*((int *)arg));
	while(1){
		printf("t2:%d\n",data);
		pthread_mutex_lock(&mutex);
		data++;	
		pthread_mutex_unlock(&mutex);
		if(data == 4){
//int pthread_cond_signal(*pthread_cond_t cond);
			pthread_cond_signal(&cond); //触发条件
		}
		sleep(1);
	}
}
//int pthread_exit(void *rval_ptr);
//int pthread_join(pthread_t thread, void **rval_ptr);
// 返回：若成功返回0，否则返回错误编号
int main()
{

	int ret;
	pthread_t t1;
	pthread_t t2;
	int *pret = NULL;
	int parm = 100;
     pthread_mutex_init(&mutex, NULL); //锁动态初始化
	//int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);
	pthread_cond_init(&cond,NULL); //条件动态初始化
	ret  = pthread_create(&t1,NULL,funs,(void *)&parm);
	if(ret == 0){
	//	printf("creat t1 is success\n");
		
	}
	ret  = pthread_create(&t2,NULL,funs2,(void *)&parm);
	if(ret == 0){
	//	printf("creat t2 is success\n");
	}
	pthread_join(t1,NULL);
	pthread_join(t2,NULL);

	//int pthread_mutex_destroy(*pthread_mutex_t mutex);
	pthread_mutex_destroy(&mutex);
//int pthread_cond_destroy(*pthread_cond_t cond);
	pthread_cond_destroy(&cond); //销毁条件
	return 0;
}

用程序测试：

int main(int argc,char **argv)
//int main()
{
        int i=0;
        int time;
        time = atoi(argv[1]);
//      time = 5;
        for(i = 0; i < time ;i++){
                system("./demo8");
        }
}

在这里插入图片描述

./a.out 10 >>test.txt &运行10次，将结果放在test.txt中，& 后台运行

运行结果：在这里插入图片描述
cond 和 mutex初始化

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;//静态初始化
pthread_mutex_init(&mutex, NULL); //动态初始化
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;//静态初始化
pthread_cond_init(&cond, NULL); //动态初始化
猪jio杆炖不耙丶
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
（七）Linux系统编程之线程（中）
CarmenIsOK的博客
05-29 308
一、哲学家就餐模型
Linux 多线程（附带线程池代码加注释）
原来45的博客
12-18 760
线程，进程，互斥，同步，生产者消费者模型，锁，信号量，可重入与线程安全，POSIX线程库，线程池代码加注释等
线程（Linux系统实现）
最新发布
好好学习，天天向上
06-03 1156
本文讲述了什么是线程，以及在Linux系统下线程的相关操作
Linux多线程编程---线程间同步（互斥锁、条件变量、信号量和读写锁）
热门推荐
君子性非异
10-10 2万+
本篇博文转自http://zhangxiaoya.github.io/2015/05/15/multi-thread-of-c-program-language-on-linux/ Linux下提供了多种方式来处理线程同步，最常用的是互斥锁、条件变量、信号量和读写锁。  下面是思维导图： 简介 进程— 资源分配的最小单位 线程— 程序执行的最小单位 进程是一个程序的一个实例，拥有自...
线程（Linux应用编程篇）
栋哥修炼日记
04-17 635
与线程相关的就是并发 一、线程初识 线程是参与系统调度的最小单位。它被包含在进程之中，是进程中的实际运行单位。一个线程指的是进程中一个单一顺序的控制流（或者说是执行路线、执行流），一个进程中可以创建多个线程，多个线程实现并发运行，每个线程执行不同的任务。 当一个程序启动时，就有一个进程被操作系统（OS）创建，与此同时一个线程也立刻运行，该线程通常叫做程序的主线程（Main Thread），因为它是程序一开始时就运行的线程。应用程序都是以 main()做为入口开始运行的，所以main()函数就是主线程
Linux系统编程——线程私有数据-附件资源
03-02
Linux系统编程——线程私有数据-附件资源
Linux系统编程——基础命令总结
01-09
一、Linux常用命令 1、常用工具 2、目录和文件命令 3、安装和卸载软件命令 4、压缩包管理 5、文件属性、用户用户组及查找与检索命令 6、网络管理命令 7、其他命令 二、Linux vi/vim常用命令 三、Linux下软件源更新...
Linux下C语言编程——线程
07-24
Linux 下 C 语言编程——线程 Linux 下的线程是一个复杂的问题，但是在这里，我们将简单的介绍线程的创建和基本的使用。线程的高级使用，如线程的属性、线程的互斥、线程的同步等问题，可以参考后面给出的资料。 ...
基于Linux的网络编程——网络聊天程序
09-02
网络聊天程序是目前应用极为广泛的一种网络软件，对于方便人们的交流沟通非常有效，同时，作为一种典型的网络应用，编写网络聊天程序是学习基于Linux的网络编程的有效方法。 结合任务需求设计该程序，程序采用多...
Linux下的多线程编程
qq_38220914的博客
11-07 942
1 引言 　　线程（thread）技术早在60年代就被提出，但真正应用多线程到操作系统中去，是在80年代中期，solaris是这方面的佼佼者。传统的Unix也支持线程的概念，但是在一个进程（process）中只允许有一个线程，这样多线程就意味着多进程。现在，多线程技术已经被许多操作系统所支持，包括Windows/NT，当然，也包括Linux。 　　为什么有了进程的概念后，还要再引入线程呢？使用多线程到底有哪些好处？什么的系统应该选用多线程？我们首先必须回答这些问题。 　　使用多线程的理由之一是和进程相比，它
Linux——线程的创建
qq_44824574的博客
12-04 1万+
线程的概念与实现方式 线程是进程内部的一条执行序列或执行路径，一个进程可以包含多条线程。 执行序列就是一组有序指令得到集合——函数。 线程是进程内部的一条执行序列，一个进程至少有一条线程，称之为主线程（main方法代表的执行序列），可以通过线程库创建其他线程（给线程制定一个它要执行的函数），将创建的线程称之为函数线程。 线程的实现方式 内核级线程（线程的实现（创建、调度、销毁）由操作系统的内核来完成） 用户级线程（操作系统内核并不支持多线程，线程的实现都是在用户态） 混合级线程（结合以上两种方式实现）
Linux上线程的实现
赶路人儿
02-02 530
0、Linux线程历史 在操作系统设计上，从进程演化出线程，最主要的目的就是更好的支持SMP以及减小（进程/线程）上下文切换开销。针对线程的这两大意义，分别开发出了内核级线程和用户级线程两种线程模型，分类的标准主要是线程的调度者在核内还是在核外。前者更利于并发使用多处理器的资源，而后者则更多考虑的是上下文切换开销。在目前的商用系统中，通常都将两者结合起来使用，既提供核心线程以满足smp系统的需要，也支持用线程库的方式在用户态实现另一套线程机制，此时一个核心线程同时成为多个用户态线程的调度者。正如很多技术一
在linux下编译多线程需要如下设置
JiangzhouHe的博客
10-26 5018
编译时这样输入命令： gcc xxx.c -o xxx.out -lpthread
Linux下的多线程编程一（系统编程）
snow_5288的博客
06-11 8167
一，线程的基本概念 1，线程的定义： 线程也被称为轻量进程（LWP）计算机科学术语，指运行中的程序的调度单位。线程是进程中的实体，一个进程可以拥有多个线程，一个线程必须有一个父进程。线程不拥有系统资源，只有运行必须的一些数据结构；它与父进程的其它线程共享该进程所拥有的全部资源。线程可以创建和撤消线程，从而实现程序的并发执行。一般，线程具有就绪、阻塞和运行三种基本状态。 在多中央处理器的系统里，不
linux 线程编译,linux下线程和线程栈和gcc编译
weixin_36357900的博客
05-01 645
linux下使用gcc编译C的文件，gcc -o test test.clinux下查看最大线程数：cat /proc/sys/kernel/threads-max我的是：30374 (虚拟机的)ulimit -s the maximum stack size 堆栈大小的上限10240linux下对于系统中单个进程的最大线程数有其最大的限制： pthread_threads_max此限制在配置...
Linux多线程编程(一)---多线程基本编程
王文松的博客
07-20 2万+
线程是指运行中的程序的调度单位。一个线程指的是进程中一个单一顺序的控制流，也被称为轻量级线程。它是系统独立调度和分配的基本单位。同一进程中的多个线程将共享该系统中的全部系统资源，比如文件描述符和信号处理等。一个进程可以有很多线程，每个线程并行执行不同的任务。
Linux下多线程编译
qq_42946963的博客
08-08 6130
c++ 环境下 g++ main.cpp -o xm -ldl -lpthread
Linux多线程编程实例解析
知秋一叶
12-14 2万+
Linux系统下的多线程遵循POSIX线程接口，称为 pthread。编写Linux下的多线程程序，需要使用头文件pthread.h，连接时需要使用库libpthread.a。顺便说一下，Linux 下pthread的实现是通过系统调用clone（）来实现的。clone（）是 Linux所特有的系统调用，它的使用方式类似fork，关于clone（）的详细情况，有兴趣的读者可以去查看有关文档说明。下
linux 多线程 最简单 例子 代码
Done Lin的专栏
12-21 927
<br />#include "pthread.h"<br />#include "stdio.h"<br />#include "stdlib.h"<br />void* thread_func1(void *arg)<br />{<br /> int *val = arg;<br /> printf("Hi, I'm a thread/n");<br /> if(NULL!=arg)<br /> {<br />  while(1)<br />  {<br />  printf("Argument Set

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值