Linux 线程

已于 2022-11-10 12:45:01 修改
阅读量197 收藏
点赞数 1
分类专栏： Linux 进程线程 文章标签： linux
于 2022-11-08 19:53:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jun8086/article/details/127749763
版权

Linux 线程

一、基础概念

1.线程：一个程序执行的多个执行路线称为线程。轻量级别的进程，程序执行的最小单元；
2.特点：多个线程共享一个进程的地址空间；

二、线程创建使用相关函数

1.int pthread_create(pthread_t * thread,const pthread_attr_t *attr,void *(*start_routine)(void *),void *arg);

//返回值：成功返回0 ，失败返回错误码，不一定置errno;
//参数：
//thread  获得线程ID
//attr    线程的属性（分离属性和结合属性），通常为NULL表示使用默认属性（结合属性）
//start_routine  线程的执行函数，采用回调方式执行线程函数
//arg   给线程函数传递的参数

//练习：主线程与子线程多数据交换，以及主线程改变子线程的数据

#include<stdio.h>
#include<pthread.h>
#include<unistd.h>
struct data1
{
	int int_data;
	short short_data;
	char char_data;
};

int global=0;

void *func1(void *arg1)
{
	struct data1 getData=*(struct data1 *)arg1;
	while(1)
	{
		sleep(1);
		printf("int_data:%d  short_data :%d  char_data :%d\n",getData.int_data,getData.short_data,getData.char_data);
		global++;
	}
}
void *func2(void *arg2)
{
	int *gDtata=(int *)arg2;
	while(1)
	{
		sleep(1);
		printf("global:%d   data:%d\n",global,*gDtata);
		(*gDtata)++;
	}
}
int main(int argc, const char *argv[])
{
	pthread_t tid,tid1;
	int ret;
	int data=10;
	struct data1 past_data={20,40,60};
	ret=pthread_create(&tid,NULL,func1,&past_data);
	if(ret!=0)
	{
		perror("Fail to pthread_create");
		return -1;
	}
	ret=pthread_create(&tid1,NULL,func2,&data);
	if(ret!=0)
	{
		perror("Fail to pthread_create");
		return -1;
	}
	while(1)
	{
		printf("main running:%d\n",data);
		sleep(1);
	}
	return 0;
}

2.线程终止
void pthread_exit(void *retval);//
//结束当前线程的执行
//参数：
/retval //给等待的线程带一个地址值，如果无则填NULL;
(1)如果在主线程中调用了return 或者exit()函数，则进程结束，所有线程均结束；
(2)如果主线程调用了pthread_exit()函数，则仅仅是主线程消亡，主线程等所有子线程结束时才会结束。
//示例：主线程程中return 前调用pthread_exit()函数，等子线程结束，主进程才结束

#include<stdio.h>
#include<pthread.h>
void *func(void *arg)
{
	int data=*(int *)arg;
	while(1)
	{
		sleep(1);
		if(data==4)
		{
			break;
		}
		printf("thread 1  value:%d\n",data++);
	}
	pthread_exit(NULL);
}
int main(int argc, const char *argv[])
{
	int ret;
	int value=0;
	pthread_t tid;
	ret =pthread_create(&tid,NULL,func,&value);
	if(ret!=0)
	{
		perror("Fail to pthread_create");
		return -1;
	}
	pthread_exit(NULL);
	return 0;
}

3.等待线程退出函数
（1）int pthread_join(pthread_t thread,void ** pval);//阻塞的方式等待线程结束
//通过pthread_exit(&value);传回线程内部指针，可以带回返回值给二级指针pval,但是，如果传回的是普通变量的值，则在该线程结束后局部变量被回收，值就没有了，可以把传回值value 设置成static 静态变量。
//示例：

#include<stdio.h>
#include<pthread.h>
#include<unistd.h>
#include<errno.h>
#include<string.h>
void *func(void *arg)
{

	int data=*(int *)arg;
	static int value=30;

	while(1)
	{
		sleep(1);
		if(data==4)
		{
			break;
		}
		printf("thread 1  value:%d\n",data++);
	}
	printf("thread 1 value:%p\n",&value);

	pthread_exit(&value);
}

int main(int argc, const char *argv[])
{
	int ret;
	int value=0;

	int *pval=NULL;

	pthread_t tid;

	ret =pthread_create(&tid,NULL,func,&value);
	if(ret!=0)
	{
		perror("Fail to pthread_create");
		return -1;
	}
	
	ret=pthread_join(tid,(void **)&pval);
	if(ret!=0)
	{
		fprintf(stderr,"Fail to pthread_join %s\n",strerror(errno));
		return -1;
	}
	printf("pval=%p value:%d\n",pval,*pval);
	pthread_exit(NULL);
	return 0;
}

4.创建分离式线程
int pthread_detach(pthread_t thread);//非阻塞
//功能：将线程标记为分离式线程
//参数：
//thread 线程的tid号
//返回值：成功返回0，失败返回错误码
（1)分离式线程的特点：线程结束时，系统会自动回收资源，不需要pthread_join()函数来阻塞回收；
//示例：

//创建线程后，在主线程添加
pthread_detach(tid);//把需要改成分离式线程的线程号填进去，这里看不到效果，子线程结束后，系统自动回收资源。

5.取消一个线程
int pthread_cancel(pthread_t thread);//取消一个线程的执行（取消别人）
//参数：
//thread 线程的tid号
//返回值：成功返回0，失败返回错误码
//示例：创建子线程，主线程休眠4秒取消子线程，并回收子线程资源。

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

void *func(void *arg)
{
	
	while(1)
	{
		sleep(1);
		printf("thread 1 running\n");
	}
pthread_exit(NULL);//
}
int main(int argc,const char *argv[])
{
	pthread_t tid;
	int ret;
	ret=pthread_create(&tid,NULL,func,NULL);
	if(ret!=0)
	{
		perror("Fail to pthread_create");
		return -1;
	}
	sleep(4);
	ret=pthread_cancel(tid);//取消子线程，成功返回0，失败返回错误码
	if(ret!=0)
	{
		perror("Fail to pthread_cance");
		return -1;
	}	
	pthread_exit(NULL);
}

//示例：打开一个文件，创建两个子进程，一个子进程写，一个子进程读并且打印，当读到"quit"时，退出子进程。

#include<stdio.h>
#include<pthread.h>
#include<unistd.h>
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
int gTid;//其实可以通过传参把读线程的线程号传入写线程
void *func1(void *arg1)//read
{
	char buf[1024]={0};
	int fd=*(int *)arg1;
	while(1)
	{
		memset(buf,0,sizeof(buf));
		ssize_t ret=read(fd,buf,sizeof(buf));
		if(ret<0)
		{
			perror("Fail to read");
			return NULL;
		}
		else if(ret==0)
		{
			continue;
		}
		else
		{
			printf("p:%s\n",buf);
		}
	}
	pthread_exit(NULL);
}
void *func2(void *arg2)//write
{
	char buf[1024]={0};
	int fd=*(int *)arg2;
	while(1)
	{
		memset(buf,0,sizeof(buf));
		fgets(buf,sizeof(buf),stdin);

		buf[strlen(buf)-1]='\0';

		if(strncmp(buf,"quit",4)==0)
		{
			pthread_cancel(gTid);
			break;
		}
		write(fd,buf,strlen(buf));
		lseek(fd,-strlen(buf),SEEK_CUR);		
	}
	pthread_exit(NULL);
}
int main(int argc, const char *argv[])
{
	pthread_t tid1,tid2;
	int ret;
	int fd;
	if(argc!=2)
	{
		fprintf(stderr,"usage: %s log.txt",argv[0]);
		return -1;
	}
	fd=open(argv[1],O_RDWR|O_CREAT|O_TRUNC,0666);
	if(fd<0)
	{
		perror("Fail to open");
		return -1;
	}
	ret=pthread_create(&tid1,NULL,func1,&fd);//read
	if(ret!=0)
	{
		perror("Fail to pthread_create");
		return -1;
	}
	gTid=tid1;

	ret=pthread_create(&tid2,NULL,func2,&fd);
	if(ret!=0)
	{
		perror("Fail to pthread_create");
		return -1;
	}
	pthread_exit(NULL);
	return 0;
}

6.线程间同步，使用信号量
//功能：对于两个线程，创建两个（全局变量）信号量A,B（sem_t A,B),先对A,B赋初值，A 为1(sem_init(&A,0,1)，B为0(sem_init(&B,0,0),在第一个线程中使用sem_wait(&A),当A为0时阻塞，当使用sem_post(&A)时，释放A,此时sem_wait(&A)可以顺利执行。
（1）建立全局变量的信号量:sem_t sem_A;
（2）初始化信号量:

int sem_init(sem_t *sem,int pshared,unsigned int value);
//返回值:成功返回0，失败返回-1
//参数：
//sem   第一步创建的 信号量；
//pshared   0:线程间使用
//value     信号量的初始值

（3）P操作

int sem_wait(sem_t *sem);
//功能：申请资源，如果资源为0则阻塞调用者
//返回值：成功返回0，失败返回-1
//参数：
//sem   :信号量的地址

（3）V操作

int sem_post(sem_t *sem);
//功能：释放资源，如果有线程等待则唤醒等待的线程
//返回值：成功返回0，失败返回-1
//参数：
//sem   :信号量的地址

//示例：

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

sem_t sem_read,sem_write;
struct data_t
{
	char name[20];
	int id;
	int score;
};
struct data_t stu;

void *func1(void *arg1)//write
{
	char buf[1024]={0};
	while(1)
	{
		sem_wait(&sem_write);
		memset(&stu,0,sizeof(struct data_t));
		memset(buf,0,sizeof(buf));
		printf("name:");
		fgets(buf,sizeof(buf),stdin);
		fflush(stdin);
		buf[strlen(buf)-1]='\0';
		strcpy(stu.name,buf);
		
		if((stu.name,"quit",4)==0)
		{
			break;
		}
		printf("ID:");
		scanf("%d",&stu.id);
		getchar();
		printf("score:");
		scanf("%d",&stu.score);
		getchar();//取走换行符
		sem_post(&sem_read);
	}
	pthread_exit(NULL);
}
void *func2(void *arg2)
{
	while(1)
	{
		sem_wait(&sem_read);
		printf("name:%s   id:%d  score:%d\n",stu.name,stu.id,stu.score);
		sem_post(&sem_write);//释放信号量
	}
}

int main(int argc, const char *argv[])
{
	pthread_t tid1,tid2;
	int ret;
	sem_init(&sem_read,0,0);//初始化信号量
	sem_init(&sem_write,0,1);
	ret=pthread_create(&tid1,NULL,func1,NULL);
	if(ret!=0)
	{
		perror("Fail to create_thread");
		return -1;
	}
	ret=pthread_create(&tid2,NULL,func2,NULL);
	if(ret!=0)
	{
		perror("Fail to create_thread");
		return -1;
	}
	pthread_exit(NULL);
	return 0;
}

7.线程间互斥 --互斥锁
//功能：一个线程访问资源的时候，不允许其他线程访问；
宏创建互斥锁

pthread_mutex_t mutex=

（1）定义互斥锁

 pthread_mutex_t mlock;//定义了一个叫mlock的互斥锁

（2）初始化互斥锁

int pthread_mutex_init(pthread_mutex_t *mutex,const pthread_mutexattr_t *attr);
//返回值：成功返回0，失败返回-1
//参数：
//mutex  互斥锁地址
//attr   默认值NULL;

（3）获得互斥锁

int pthread_mutex_lock(pthread_mutex_t *mutex);
//功能：获得互斥锁则立即返回，否则阻塞直到获得互斥锁
//返回值：成功返回0，失败返回-1
//参数： mutex  互斥锁地址

（4）获得互斥锁

int pthread_mutex_unlock(pthread_mutex_t *mutex);
//功能：释放互斥锁
//返回值：成功返回0，失败返回-1
//参数： mutex  互斥锁地址

（5）销毁互斥锁

int pthread_mutex_destroy(pthread_mutex_t *mutex);
//功能：销毁互斥锁
//返回值：成功返回0，失败返回-1
//参数： mutex  互斥锁地址

//示例：

#include<stdio.h>
#include<unistd.h>
#include<string.h>
#include<pthread.h>
#include<stdlib.h>
int pro=0;
pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIZER;//定义互斥锁同时初始化
pthread_cond_t cond=PTHREAD_COND_INITIALIZER;//定义条件变量同时初始化

void *func1(void *arg)
{
	int data;
	while(1)
	{
		
		pthread_mutex_lock(&mutex);//抢占互斥锁
		while(pro!=0)
		{
			pthread_cond_wait(&cond,&mutex);//	

		}

		data=rand()%100;
		pro=data;
		printf("producer:%d\n",pro);
		pthread_mutex_unlock(&mutex);//释放互斥锁
		pthread_cond_signal(&cond);
	
	}

	pthread_exit(NULL);

}

void *func2(void *arg)
{
	while(1)
	{
		pthread_mutex_lock(&mutex);//抢占互斥锁
	
		while(pro==0)
		{	
			pthread_cond_wait(&cond,&mutex);//	
		}
		printf("pro=%d\n",pro);
		pro=0;
		pthread_mutex_unlock(&mutex);//释放互斥锁
		pthread_cond_signal(&cond);


	}
	pthread_exit(NULL);
}


int main(int argc, const char *argv[])
{
	pthread_t tid1,tid2;

	int ret;

	ret=pthread_create(&tid1,NULL,func1,NULL);
	if(ret!=0)
	{
		perror("Fail to pthread_create");
		return -1;
	}

	ret=pthread_create(&tid2,NULL,func2,NULL);
	if(ret!=0)
	{
		perror("Fail to pthread_create");
		return -1;
	}


	pthread_join(tid1,NULL);
	pthread_join(tid2,NULL);
	
	pthread_exit(NULL);
	pthread_mutex_destroy(&mutex);
	return 0;
}

8.条件变量
（1）定义：条件变量是利用线程间共享的全局变量进行同步通信的一种机制。多个线程等待某一个条件满足，在条件达到时由一个线程去通知其他等待的线程。
（2）条件变量相关函数。

pthread_cont_t cond;//定义条件变量
pthread_cont_init(&cond,NULL);//动态初始化条件变量

//等待条件变量，条件不满足，则阻塞当前进程，
int pthread_cond_wait(pthread_cond_t *cond,pthread_mutex_t *mutex);

//唤醒条件变量
int pthread_cond_broadcast(pthread_cond_t *cond);//唤醒所有等待的线程
int pthread_cond_signal(pthread_cond_t *cond);//唤醒至少一个等待线程

//销毁条件变量
pthread_cond_destroy(pthread_cond_t *cond);

//示例：见互斥锁。

jun8086
关注
专栏目录
【Linux】线程
DanteKing的博客
03-30 4811
Linux线程的基础知识
linux 线程
you_fathe的博客
02-11 1460
linux 线程概念、posix thread，同步与互斥的实现
linux线程
qq_62309585的博客
09-24 630
内核经常需要在后台执行一些操作。这种任务可以通过内核线程(kernel thread)完成——独立运行在内核空间的标准进程。内核线程和普通的进程间的区别在于内核线程没有独立的地址空间（实际上指向地址空间的mm 指针被设置为NULL)。它们只在内核空间运行，从来不切换到用户空间去。内核进程和普通进程一样，可以被调度，也可以被抢占。Linux确实会把一些任务交给内核线程去做，像flush和 ksofirqd这些任务就是明显的例子。在装有Linux系统的机子上运行ps -ef命令，你可以看到内核线程，有很多!
Linux线程
木辛木又
05-25 442
线程 线程：也称轻量级进程，是程序执行流的最小单元。而多线程就是指，在一个进程中有多个执行流，在同时执行。进程是承担调度的基本单位，一个进程可拥有多个线程，它的执行力度比进程更加细致，线程资源共享。 注意：在Linux中并不存在真正的线程，Linux测线程是使用进程模拟的。我们在Linux系统中，线程的创建实在内核外进行的，有POSIX提供的线程库实现。因此链接这些线程函数库时要使用编译器命令的“...
11.Linux线程同步
01-06
文章目录一、线程同步的概念二、互斥锁1、初始化锁2、阻塞加锁3、非阻塞加锁4、解锁5、销毁锁（此时锁必需unlock状态，否则返回EBUSY）三、示例程序四、版权声明 一、线程同步的概念 线程同步？怎么同步？一起运行？...
Linux线程编程之生产者消费者问题
12-14
Linux线程编程中的生产者消费者问题是多线程编程中一个经典的同步问题，它涉及到线程间的协作和资源的共享。生产者线程负责生成数据并放入队列，而消费者线程则从队列中取出数据进行处理。在这个过程中，如何保证...
浅谈linux线程切换问题
09-15
本文将详细探讨Linux线程切换的相关知识点。 首先，理解处理器的运行状态至关重要。处理器总是在内核态和用户态之间切换。在内核态下，处理器可以执行特权指令，既可以运行于进程上下文，代表某个进程执行，也可以...
Linux 线程浅析
04-19
Linux 线程浅析
Linux-线程
mmz123_的博客
03-14 1141
文章目录操作创建线程 创建进程，我们从0到有创建了很多东西，申请了很多资源。 进程：承担分配系统资源的基本实体。 线程：调度的基本单位，线程是进程里面的执行流（线程在进程的地址空间内运行）。 进程：线程 = 1：n Linux中，没有真正意义上的线程，线程是用进程模拟的（轻量级进程）。 只有第一个进程执行时创建了地址空间等资源，其它进程都只是分享了同一个资源。显然分配资源比申请资源快。 在一个程序里的一个执行路线就叫做线程（thread）。更准确的定义是：线程是“一个进程内部的控制序列”” 一切进程
linux——线程
qq_47944751的博客
10-22 295
线程
Linux基础之线程
weixin_55374007的博客
08-23 629
1.通过进程比较引出线程1）典型的UNIX/Linux进程可以看成只有一个控制线程：一个进程在同一时刻只做一件事情。有了多个控制线程后，在程序设计时可以把进程设计成在同一时刻做不止一件事，每个线程各自处理独立的任务。2）进程是程序执行时的一个实例，是担当分配系统资源（CPU时间、内存等）的基本单位。在面向线程设计的系统中，进程本身不是基本运行单位，而是线程的容器。程序本身只是指令、数据及其组织形式的描述，进程才是程序（那些指令和数据）的真正运行实例。3）线程是操作系统能够进行运算调度的最小单位。
Linux线程详解（概念、原理、实现方法、优缺点）
热门推荐
weixin_44602505的博客
12-08 1万+
文章目录一、Linux线程基本概念二、Linux内核线程实现原理三、创建线程四、线程的优缺点 一、Linux线程基本概念 linux中，线程又叫做轻量级进程（light-weight process LWP），也有PCB，创建线程使用的底层函数和进程底层一样，都是clone，但没有独立的地址空间；而进程有独立地址空间，拥有PCB。 Linux下：线程是最小的执行单位，调度的基本单位。进程是最小分配资源单位，可看成是只有一个线程的进程。 线程是一个进程内部的控制序列。控制序列可以理解为一个执行流。进程内部是指
Linux ：线程介绍
TheWindRisesll的博客
01-11 427
进程是承担分配系统资源的基本实体 线程是CPU调度的基本单位 线程的概念 进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动，进程是系统进行资源分配和调度的一个独立单位 在⼀个程序⾥的⼀个执⾏路线就叫做线程（thread） 更准确的定义是：线程是“⼀个进程内部的控制序列” ⼀切进程⾄少都有⼀个执⾏线程 线程是在进程内部运行，本质是在进程地址空间内运行 进程和线程 进程是资源竞争的基...
【Linux】线程详解
最新发布
m0_72940975的博客
07-15 1929
在一个程序里的一个执行路线就叫做线程。更准确的定义是：线程是“一个进程内部的控制序列”一切进程都至少有一个执行线程线程在进程内部运行，本质是在进程地址空间内运行在Linux系统中，在CPU眼中，看到的PCB都要比传统的进程更轻量化透过进程虚拟地址空间，可以看到进程的大部分资源，将进程资源合理分配给每个执行流，就形成了线程执行流进程的创建伴随着进程控制块，进程地址空间以及页表的创建，虚拟地址和物理地址就是通过页表建立映射的。
Linux线程详解
lcl_032015的博客
02-21 364
Linux线程详解 并行和并发的区别 并发(concurrency)：在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行。其中两种并发关系分别是同步和互斥。（并发是指同一时刻只能有一条指令执行，但多个进程指令被快速轮换执行，使得在宏观上有多个进程被同时执行的效果–宏观上并行，针对单核处理器） 2.并行(parallelism)：在单处理器中多道程序设计系统中，进程被交替执行，表现出一种并发的外部特种；在多处理器系统中，进程不仅可以交替执行，而且可以
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

jun8086

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

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

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

打赏作者

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

抵扣说明：

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

余额充值