Linux编程—系统编程（线程）

最新推荐文章于 2023-10-03 09:53:21 发布
最新推荐文章于 2023-10-03 09:53:21 发布
阅读量117 收藏
点赞数
分类专栏： Linux编程
原文链接：https://www.cnblogs.com/xiehongfeng100/p/4620852.html
版权

线程推荐博文

线程

进程与线程的区别
进程——资源分配的最小单位，线程——程序执行的最小单位
——典型的UNIX/Linux进程可以看成只有一个控制线程：一个进程在同一时刻只能做一件事。当一个进程中有多个控制线程后，一个进程就可以同时处理多任务，每个线程独自处理独立的任务。

——进程是程序执行时的一个实例，是担当分配系统资源（CPU时间、内存）的基本单位。在面向线程设计的系统中，进程本身不是基本运行单位，而是线程的容器。程序本身只是指令、数据及其组织形式的描述，进程才是程序（指令和数据）的真正运行实例。

——线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程可以并发多个线程，每条线程并行执行不同的任务。线程包含了表示进程内执行环境的必须信息，其中包括进程中表示线程的线程ID、一组寄存器值、栈、调度优先级和策略、信号屏蔽字、errno常量以及线程私有数据。进程的所有信息对该进程的所有线程都是共享的，包括可执行的程序文本、程序的全局内存和堆内存、栈以及文件描述符。在UNIX和类UNIX操作系统中线程也被称为轻量级进程（lightweight processes）,但轻量级进程更多指的是内核线程（kernel thread），而把用户线程（user thread）称为线程。

——进程有独立的地址空间，一个进程崩溃后，在保护模式下不会对其他进程产生影响，而线程只是一个进程中的不同执行路径。线程有自己的堆栈和局部变量，但线程没有单独的地址空间，一个线程死掉就等于整个进程死掉，所以多进程的程序比多线程的程序健壮，但在进程切换时，耗费资源较大，效率要差一些。但对于一些要求同时进行并且又要共享某些变量的并发操作，只能用线程，不能用进程。

线程的优缺点

进程有独立的地址空间，同一进程内的线程共享进程的地址空间。

——1.与进程相比，多线程是一种非常“节俭”的多任务操作方式，在Linux系统下，启动一个新的进程必须分配给它独立的地址空间，建立众多的数据表来维护它的代码段、堆栈段和数据段，这是一种“昂贵的”多任务工作方式。运行一个进程中的多个线程，它们彼此之间使用相同的地址空间，共享大部分数据，启动一个线程所花费的空间远远小于启动一个进程所花费的空间，而且线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。

——2.线程具有方便的通信机制。不同的进程具有独立的地址空间，要进行数据的传递只能通过通信的方式进行，这种方式费时且不方便。由于线程在同一进程，多线程之间共享数据空间，所以一个线程的数据可以直接为其他线程所用，这不仅快捷而且方便。但数据的共享也会带来一些其他的问题，有的变量不能同时被两个进程所修改，有的子进程中声明为static的数据更有可能给多线程程序带来灾难性的打击。

——3.多线程程序作为一种多任务、并发的工作方式，可以提高应用程序响应。这对图形界面的程序尤其有意义，当一个操作耗时很长时，整个操作系统都会等待这个操作，此时程序不会响应键盘、鼠标、菜单的操作，而使用多线程技术，将耗时长的操作置于一个新的线程，可以避免这种尴尬的情况。

多线程使多CPU系统更加有效。操作系统会保证当线程数不大于CPU数目时，不同的线程运行于不同的CPU上。

多线程可以改善程序结构。一个既长又复杂的进程可以考虑分为多个线程，成为几个独立或半独立的运行部分，这样的程序会利于理解和修改。

Linux 线程 API

由第三方pthread库支持，线程包含的基本概念：线程、互斥锁、条件。
1.线程：创建、退出、等待。
2.互斥锁：创建、销毁、加锁、解锁。
3.条件：创建、销毁、触发、广播、等待。
4.基于上面三个基本元素的基本操作封装出来，如信号灯等。
Linux 线程 API

线程的创建、等待和退出

一.线程创建
原型： int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg);//成功返回0，失败返回错误编号。

参数：
pthread_t *thread:无符号长整型指针
const pthread_attr_t *attr:线程属性
void *(*start_routine) (void *):线程执行的控制流
void *arg:对线程进行传参的参数

当pthread_create成功返回时，由tidp指向的内存单元被设置为新创建线程的线程ID。attr参数用于定制各种不同的线程属性，暂可以把它设置为NULL，以创建默认属性的线程。
新创建的线程从start_rtn函数的地址开始运行，该函数只有一个无类型指针参数arg.如果需要向start_rtn函数传递的参数不止一个，那么需要把这些参数放到一个结构中，然后把结构体的地址作为arg参数传入。

demo：

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

void *pthread1(void *arg)
{
        while(1)
        {
                printf("This is pthread ID:%ld\n",(unsigned long)pthread_self());//输出该线程的ID
                printf("param is %d\n",*((int*)arg));//输出main函数传过来的参数
                sleep(3);
        }
}

void *pthread2(void *arg)
{
        for(;;)
        {
                printf("This is pthread ID:%ld\n",(unsigned long)pthread_self());//输出线程ID
                printf("param is %d\n",*((int*)arg));
                sleep(3);
        }
}

int main(void)
{
        pthread_t id1;
        pthread_t id2;
        int param=100;

        printf("main's pthread:%ld\n",(unsigned long)pthread_self());//输出main函数的ID

        if(pthread_create(&id1,NULL,pthread1,(void*)&param)!=0)//创建线程pthread1
        {
                printf("create pthread1 fail!!!\n");
        }
        if(pthread_create(&id2,NULL,pthread2,(void*)&param)!=0)//创建线程pthread2
        {
                printf("create pthread2 fail!!!\n");
        }
        while(1);//如果main函数提前退出了，创建的线程就执行不了。
        //这里就可以使用线程等待，功能和while（1）一样。
        //pthread_join(t1,NULL);     //线程等待
        return 0;
}

二.线程退出
原型：void pthread_exit(void *retval);

参数：void *retval：无类型指针，与传给启动例程的单个参数类似。进程中的其他线程可以通过调用pthread_join函数访问到这个指针。

单线程可以通过以下三种方式退出，在不终止整个进程的情况下停止它的控制流：
1.线程只是从启动例程中返回，返回值是线程的退出码。
2.线程可以被同一进程中的其他线程取消。
3.线程调用pthread_exit;

三.线程等待
原型：int pthread_join(pthread_t thread, void **retval);

参数：
pthread_t thread:线程ID
void **retva:线程的退出状态

demo:

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

typedef struct test
{
        char a;
        int b;
        char c[30];
}TEST;

void* pthread1(void *arg)           //arg is structure  使用结构体进行传参
{
        static int ret = 10; 
        TEST *test=(TEST*)arg;

        printf("The pthread ID:%ld\n",pthread_self());//打印线程ID
        printf("arg information:\n");
        printf("structure: %c %d %s\n",test->a,test->b,test->c);  //输出结构体参数的数据
        pthread_exit((void *)&ret);  //线程退出并返回地址中的值
}

int main(void)
{
        pthread_t id; 
        TEST structure={'A',99,"This is test!"};  //结构体初始化
        int *pret;

        printf("main pthread ID:%ld\n",(unsigned long)pthread_self());  //打印main函数ID

        if(pthread_create(&id,NULL,pthread1,(void*)&structure)!=0)  //创建线程
        {
                printf("creat pthread fail!!!\n");
        }

        pthread_join(id,(void **)&pret);//get pthread waid (symbol)number;  //等待并获取线程ID的退出状态
        printf("pthread id quit number:%d\n",*pret);  //打印线程退出状态
        return 0;
}

线程共享内存

demo：

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

void *pthread1(void *arg)
{
	*((int*)arg)*=2;
	printf("This pthread ID:%ld\n",(unsigned long)pthread_self());//该线程使main函数中的数据乘2
	printf("testdata*2:\n");
}

void *pthread2(void *arg)
{
	*((int*)arg)+=10;
	printf("This pthread ID:%ld\n",(unsigned long)pthread_self());//该线程使main函数中的数据加10
	printf("testdata+=10:\n");
}

int main(void)
{
	int testdata=10;
		
	pthread_t id1;
	pthread_t id2;

	printf("testdata = %d\n",testdata);//打印出最初的值

	if(pthread_create(&id1,NULL,pthread1,(void*)&testdata)==0)//创建线程1
	{
		printf("creat pthread1 YES.\n");
	}
	pthread_join(id1,NULL);//等待线程1执行完毕
	printf("pthread1 testdata:%d\n",testdata);//打印被线程1改变后的值

	if(pthread_create(&id2,NULL,pthread2,(void*)&testdata)==0)//创建线程2
	{
		printf("creat pthread2 YES.\n");
	}
	pthread_join(id2,NULL);//等待线程2执行完毕
	printf("pthread2 testdata:%d\n",testdata);//打印被线程2改变后的值
	
	return 0;
}

互斥（量）锁

互斥量（mutex）从本质上来说是一把锁，在访问共享资源前对互斥量进行加锁，在访问完成后释放互斥量的锁。对互斥量进行加锁后，任何其他试图再次对互斥量加锁的线程将会被阻塞到当前线程释放该互斥锁。如果释放互斥锁时有多个线程阻塞，所有在该互斥锁上的阻塞线程都会变成可运行状态，第一个变为可运行状态的线程可以互斥量加锁，其他线程将会看到互斥锁依然被锁住，只能回去等待它重新变为可用，在这种方式下，每次只有一个线程可以向前运行。

在设计时需要规定所有的线程必须遵守相同的数据访问规则。只有这样，互斥机制才能正常工作。操作系统并不会做数据访问的串行化。如果允许其中的某个线程在没有得到锁的情况下也可以访问共享资源，那么即使其他的线程在使用共享资源前都获取了锁，也还是会出现数据不一致的问题。

互斥变量用pthread_mutex_t数据类型表示。在使用互斥变量前必须对它进行初始化，可以把它置为常量PTHREAD_MUTEX_INITIALIZER(只对静态奉陪的互斥量)，也可以通过调用pthread_mutex_init函数进行初始化。如果动态地分配互斥量（例如通过调用malloc函数），那么在释放内存需要调用pthread_mutex_destroy.

原型：
int pthread_mutex_init(pthread_mutex_t *restrict mutex,const pthread_mutexattr_t *restrict attr);//创建锁
int pthread_mutex_destroy(pthread_mutex_t mutex);//销毁锁

int pthread_mutex_lock(pthread_mutex_t mutex);
int pthread_mutex_trylock(pthread_mutex_t mutex);
int pthread_mutex_unlock(pthread_mutex_t mutex);
成功返回0，否则返回错误编号

demo：

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

pthread_mutex_t mutex;//定义一把锁

void *pthread1(void *arg)
{
	while(1)
	{
		pthread_mutex_lock(&mutex);//加锁
		printf("pthread1:%d\n",(*((int*)arg))++);//该进程循环打印数据
		sleep(3);
		//pthread_mutex_unlock(&mutex);解锁
		//if(*((int*)arg)==5)break;  //有一个线程退出条件，但是因为还有其他线程使用这个资源，所以它可能遇不到退出条件
		//所以互斥锁的使用很重要
	}
}

void *pthread2(void *arg)
{
	while(1)
	{
		printf("pthread2:%d\n",(*((int*)arg))++);//该进程循环打印数据
		sleep(3);
	}
}

int main(void)
{
	int data=0;
	int test=0;
	
	pthread_t id1;
	pthread_t id2;
	
 	test=pthread_mutex_init(&mutex,NULL);//创建锁
	if(test!=0)printf("fail!!!\n");
	
	if(pthread_create(&id1,NULL,pthread1,(void*)&data)!=0)
	{
		printf("creat pthread1 fail!!!\n");
	}
	if(pthread_create(&id2,NULL,pthread2,(void*)&data)!=0)//创建了两个线程
	{
		printf("creat pthread2 fail!!!\n");
	}

	while(1)
	{
		printf("main:%d\n",data++);   //主函数里也在不断打印数据
		sleep(3);
	}
	pthread_join(id1,NULL);
	pthread_join(id2,NULL);	

	test=pthread_mutex_destroy(&mutex);//销毁锁
	if(test!=0)printf("fail!!!\n");
	return 0;
}

条件

原型：
pthread_cond_init
pthread_cond_destroy
int pthread_cond_signal(pthread_cont_t cond)//这两个是线程触发
int pthread_cond_broadcast(pthread_cont_t cond)
int pthread_cond_wait(pthread_cont_t *restrict cond,pthread_mutex_t *restrict mutex)//下面两个都是线程等待
int pthread_cond_timedwait(pthread_cond_t *restrict cond,pthread_mutext_t *restrict mutex,cond struct timespec *restrict timeout)

demo：

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

int testdata=0;
//可以用宏静态初始化锁和信号
pthread_mutex_t mutex;//=PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond;  //=PTHREAD_COND_INITIALIZER;

void *pthread1(void* data)
{
	pthread_cond_wait(&cond,&mutex);//加锁并等待条件信号
	printf("pthread ID:%ld\n",(unsigned long)pthread_self());
	while(1)
	{
		printf("pthread1:%d\n",testdata++);
		sleep(2);
		if(testdata==6)testdata=0;
	}
}

void *pthread2(void *data)
{
	printf("pthread ID:%ld\n",(unsigned long)pthread_self());
	while(1)
	{
		printf("pthread2:%d\n",testdata++);
		sleep(2);
		if(testdata>3 && testdata<7)
		{
			pthread_cond_signal(&cond);//发送条件信号
		}
	}
}

int main()
{
	int data;

	pthread_t id1;
	pthread_t id2;
	//下面以动态方式初始化锁和信号
	pthread_mutex_init(&mutex,NULL);//创建锁
	pthread_cond_init(&cond,NULL);//创建信号条件
	
	pthread_create(&id1,NULL,pthread1,(void*)&data);//创建两个线程
	pthread_create(&id2,NULL,pthread2,(void*)&data);

	pthread_join(id1,NULL);//等待两个线程
	pthread_join(id2,NULL);

	pthread_mutex_destroy(&mutex);//销毁互斥锁
	pthread_cond_destroy(&cond);//销毁信号条件
	return 0;
}

通过写脚本测试程序

例：脚本以.sh为后缀
vi test.sh 创建一个脚本文件
在脚本中写入内容：
./a.out
./a.out
./a.out
即执行3次当前路径下的程序a.out
chmod +x test.sh 输入指令使脚本生效
./test.sh 执行脚本

另一种技巧：
写一个测试程序

void main(void)
{
	int i=10;
	while(i--)
	{
		system("./a.out");
	}
}

执行程序生成测试文件
三个参数：测试程序名 测试次数 被测程序名

#include <stdlib.h>

void main(int argc,char **argv)
{
	int cnt=atoi(argv[1]);
	while(cnt--)
	{
		system(argv[2]);
	}
}

执行指令：./测试程序 测试次数 >>放置测试结果的文件 &

qq_52380197
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux下c语言多线程编程
m0_47170940的博客
03-30 1万+
创建线程函数pthread_create()和等待线程函数pthread_join()的用法。 注意：在创建线程pthread_create()之前，要先定义线程标识符： pthread_t 自定义线程名； 例子1：创建线程以及等待线程执行完毕。 #include <stdio.h> #include <stdlib.h> #include <pthread.h> //线程要运行的函数，除了函数名myfunc，其他全都是固定的。 void* myfunc() { p
Linux系统下的多线程编程入门.pdf
12-20
在Linux系统下进行多线程编程是开发高效并发应用程序的关键技术之一。本文将深入探讨Linux环境中的多线程概念、创建与管理线程的方法、线程同步与通信机制，以及多线程编程中可能遇到的问题和解决策略。 一、多线程...
Linux多线程编程
C_Trip的博客
11-19 3109
1、线程基本知识 2、线程控制 3、线程同步与互斥 线程互斥 线程同步 条件变量 生产者消费者模型 POSIX信号量 读者写者问题 线程池 单例模式
Linux系统编程代码汇总
buhuidage的博客
05-03 2300
线程：线程从属于进程，一个进程可以有多个线程，线程直接共享进程的资源。systemd(init): 所有进程的父进程。可以查看我们的进程树，就是进程关系。任务：具体要做的事情。
Linux C 线程编程
We choose to go to the moon in this decade and do the other things, not because they are easy, but beacase they are hard.
03-24 3163
线程创建、线程退出、线程等待、线程同步、线程池、进程与线程
linux系统编程
蓝创精英团队
03-30 861
系统调用：系统调用是操作系统提供给用户程序的一组“特殊”接口，用户程序可以通过这组特殊的接口来获得操作系统内核提供的特殊服务。在linux中用户程序不能直接访问内核提供的服务，为了更好的保护内核，将程序的运行空间分为内核空间和用户空间，他们运行在不同的级别上。1.FILE 2.TCP/IP socket TCP UDP 3.进程 进程：一个处于活动状态的程序 进程的运行状态：执行、...
linux 多线程服务端编程 pdf,Linux 多线程服务端编程.pdf
weixin_42246401的博客
05-04 1226
Linux 多线程服务端编程.pdfLinuxmuduoC++(giantchen@)2012-09-30C++TCPC++ x86-64Linux TCPone loopper threadLinux nativemuduoC++IT 5C++muduo2 C++C++Primer 4W.Richard Stevens UNIX Sockets APIechoSockets• • UNIX...
Linux系统编程系列之线程
AABond的博客
10-03 1129
Linux系统编程系列之线程，线程的简单介绍和使用
linux多线程编程 实验,linux操作系统-实验五-linux 多线程编程.docx
weixin_39522170的博客
05-13 1087
linux操作系统-实验五-linux 多线程编程.docx操作系统 实验报告 实验序号 5 实验项目名称 Linux 多线程编程 学 号 姓 名 专业、班 实验地点 指导教师 实验时间 2015.10.13 一、实验目的及要求 通过本实验的学习，使学生掌握 Linux 多线程编程的基本方法。 以学生自主训练为主的开放模式组织教学 二、实验设备(软硬件环境)及要求 安装有 Ubuntu 系统的 V...
Linux编程技术总结
yunfan
12-25 1361
前言 所谓Linux编程技术就是在Linux操作系统环境下进行软件开发时所使用的各种编程技术。 一 常见的Linux系统发行版 在介绍常见的 Linux 系统版本之前，首先需要区分 Linux 系统内核与 Linux 发行版系统的不同。 ➢ Linux 系统内核 指的是一个由 Linus Torvalds 负责维护，提供硬件抽象层、硬盘及文件系统控制及多任务功能的系统核心程序。 ➢ Linux 发行版系统 是我们常说的 Linux 操作系统，也即是由 Linux 内核与各种常用软件的集合产品。 全球
Linux系统编程概述
Darren_Chen_的博客
02-06 1569
操作系统的任务是什么？系统编程是什么？
Linux 操作系统编程 系统编程
09-15
在深入探讨Linux操作系统编程之前，我们首先需要理解操作系统的基本概念。操作系统是计算机系统的核心，它管理硬件资源，提供服务供应用程序使用。Linux是一种开源、免费的操作系统，它遵循Unix的设计哲学，具有高度...
Linux下的多线程编程实例解析
09-14
Linux系统同样支持多线程编程，这使得开发者能够利用这一特性创建高效的、响应迅速的应用程序。多线程允许在同一个进程中执行多个并发的任务，共享资源，并且可以通过线程间的通信进行数据交换。 1. **线程的引入与...
Linux系统编程PPT.zip
07-10
Linux系统编程是IT领域中的重要组成部分，它涵盖了操作系统与应用程序之间的交互，特别是在服务器端和嵌入式设备上。本PPT旨在深入浅出地讲解这一关键主题，通过一系列的幻灯片来帮助学习者理解并掌握Linux环境下的...
创新药系列阿尔兹海默病千万患者迎来新疗法.pdf
07-18
医疗行业研究报告
2024全球数字营销趋势报告25页.pdf
07-18
医疗行业研究报告
计算机控制专业技术.doc
07-18
计算机
计算机审计方法.doc
07-18
计算机
高质量的嵌入式面试试题
最新发布
07-18
原创高质量的嵌入式面试试题，全面考察嵌入式理论功底和工作经验，招聘神器，求职面试神器。原创不易，仅用于学习之用，未经本人授权，禁止以任何形式的传播，或用于其他商业目的。
Linux系统下的多线程编程入门
"基于Linux系统下的多线程简单编程" 在Linux系统中，多线程编程是一种高效利用CPU资源的技术，允许程序同时执行多个任务。本文将深入探讨进程、线程以及多线程的概念，并介绍如何在Linux环境下进行简单的多线程编程...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值