入门Linux系统编程--线程

已于 2022-03-27 12:36:33 修改
阅读量238 收藏 5
点赞数 1
分类专栏： Linux系统编程 文章标签： linux unix 服务器
于 2022-02-12 18:29:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mantouyouyou/article/details/122676106
版权

文章目录

以下部分内容参考博文： https://www.cnblogs.com/xiehongfeng100/p/4620852.html

一、线程

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

多线程开发在 Linux 平台上已经有成熟的 pthread 库支持。其涉及的多线程开发的最基本概念主要包含三点：线程，互斥锁，条件。其中，线程操作又分线程的创建，退出，等待 3 种。互斥锁则包括 4 种操作，分别是创建，销毁，加锁和解锁。条件操作有 5 种操作：创建，销毁，触发，广播和等待。其他的一些线程扩展概念，如信号灯等，都可以通过上面的三个基本元素的基本操作封装出来。详细请见表：
在这里插入图片描述

线程与进程的区别:

  • 典型的UNIX/Linux进程可以看成只有一个控制线程：一个进程在同一时刻只做一件事情。有了多个控制线程后，在程序设计时可以把进程设计成在同一时刻做不止一件事，每个线程各自处理独立的任务。

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

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

  • “进程——资源分配的最小单位，线程——程序执行的最小单位”

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

线程的优势：

  • 进程与线程的区别就是我们使用线程的理由。总的来说就是：进程有独立的地址空间，线程没有单独的地址空间（同一进程内的线程共享进程的地址空间）。

  • 使用多线程的理由之一是和进程相比，它是一种非常**"节俭"的多任务操作方式。我们知道，在Linux系统下，启动一个新的进程必须分配给它独立的地址空间，建立众多的数据表来维护它的代码段、堆栈段和数据段，这是一种"昂贵"的多任务工作方式。而运行于一个进程中的多个线程，它们彼此之间使用相同的地址空间，共享大部分数据，**启动一个线程所花费的空间远远小于启动一个进程所花费的空间，而且，线程间彼此切换所需的时间也远远小于进程间切换所需要的时间。据统计，总的说来，一个进程的开销大约是一个线程开销的30倍左右，当然，在具体的系统上，这个数据可能会有较大的区别。

  • 使用多线程的理由之二是线程间方便的通信机制。对不同进程来说，它们具有独立的数据空间，要进行数据的传递只能通过通信的方式进行，这种方式不仅费时，而且很不方便。线程则不然，由于同一进程下的线程之间共享数据空间，所以一个线程的数据可以直接为其它线程所用，这不仅快捷，而且方便。当然，数据的共享也带来其他一些问题，有的变量不能同时被两个线程所修改，有的子程序中声明为static的数据更有可能给多线程程序带来灾难性的打击，这些正是编写多线程程序时最需要注意的地方。

除了以上所说的优点外，不和进程比较，多线程程序作为一种多任务、并发的工作方式，当然有以下的优点：

  • 提高应用程序响应。这对图形界面的程序尤其有意义，当一个操作耗时很长时，整个系统都会等待这个操作，此时程序不会响应键盘、鼠标、菜单的操作，而使用多线程技术，将耗时长的操作（time
    consuming）置于一个新的线程，可以避免这种尴尬的情况。
  • 使多CPU系统更加有效。操作系统会保证当线程数不大于CPU数目时，不同的线程运行于不同的CPU上。
  • 改善程序结构。一个既长又复杂的进程可以考虑分为多个线程，成为几个独立或半独立的运行部分，这样的程序会利于理解和修改。

2、线程创建等待及退出

线程创建函数:
在这里插入图片描述

pthread_t是unsigned long的类型

  • 当pthread_create成功返回时，新创建线程的线程D会被设置成tidp指向的内存单元。attr参数用于定制各种不同的线程属性。现在我们把它置为NULL，创建一个具有默认属性的线程。
  • 新创建的线程从start_rtn函数的地址开始运行，该函数只有一个无类型指针参数arg。如果需要向start_rtn函数传递的参数有一个以上，那么需要把这些参数放到一个结构中，然后把这个结构的地址作为arg参数传入。
  • 线程创建时并不能保证哪个线程会先运行:是新创建的线程，还是调用线程。新创建的线程可以访问进程的地址空间，并且继承调用线程的浮点环境和信号屏蔽字，但是该线程的挂起信号集会被清除。

线程退出函数：
在这里插入图片描述

rval_ptr参数是一个无类型指针

线程等待函数：
在这里插入图片描述

  • 调用这个函数的线程将一直阻塞，直到指定的线程调用pthread_exit、从启动例程中返回或者被取消。如果例程只是从它的启动例程返回i，rval_ptr将包含返回码。如果线程被取消，由rval_ptr指定的内存单元就置为PTHREAD_CANCELED。
  • 可以通过调用pthread_join自动把线程置于分离状态，这样资源就可以恢复。如果线程已经处于分离状态，pthread_join调用就会失败，返回EINVAL。
  • 如果对线程的返回值不感兴趣，可以把rval_ptr置为NULL。在这种情况下，调用pthread_join函数将等待指定的线程终止，但并不获得线程的终止状态

测试代码：

//create.c
#include<stdio.h>
#include<pthread.h>

//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
void *func1(void *arg)
{
        static int ret = 10;//如果不是static，不然函数调用后就消失
        printf("t1:%ld thread is create\n",(unsigned long)pthread_self());//打印出线程的ID
        printf("t1:param is %d\n",*((int *)arg));//先把arg的类型从void*改为int*，然后再取内容
        pthread_exit((void *)&ret);//线程退出，把ret强转为void*型
}

int main()
{
        int ret;
        int param = 100;//向func1函数传递的数
        pthread_t t1;

        int *pret = NULL;
		//========================创建一个子线程===========================
        ret = pthread_create(&t1,NULL,func1,(void *)&param);
        if(ret == 0)
        {
                printf("main:create t1 successful\n");
        }
        //=================================================================
        printf("main:%ld\n",(unsigned long)pthread_self());//打印主线程的ID号

        pthread_join(t1,(void **)&pret);//等待子线程的退出，把pret强转为void**类型,最终指向ret
        printf("main:t1 quit: %d\n",*pret);
        return 0;
}

输出结果:
在这里插入图片描述

  • pret也可以返回字符串
#include<stdio.h>
#include<pthread.h>

//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
void *func1(void *arg)
{
        static char *ret ="t1 is run out" ;//如果不是static，不然函数调用后就消失
        printf("t1:%ld thread is create\n",(unsigned long)pthread_self());//打印出线程的ID
        printf("t1:param is %d\n",*((int *)arg));//先把arg的类型从void*改为int*，然后再取内容
        pthread_exit((void *)ret);//线程退出，把ret强转为void*型
}

int main()
{
        int ret;
        int param = 100;//要打印的数
        pthread_t t1;

        char *pret = NULL;

        ret = pthread_create(&t1,NULL,func1,(void *)&param);
        if(ret == 0)
        {
                printf("main:create t1 successful\n");

        }
        printf("main:%ld\n",(unsigned long)pthread_self());//打印主线程的ID号

        pthread_join(t1,(void **)&pret);//等待子线程的退出，把pret强转为void**类型,最终指向ret

	printf("main:t1 quit: %s\n",pret);
        return 0;
}

输出结果：
在这里插入图片描述

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

  • 测试代码：
//Test1.c
#include<stdio.h>
#include<pthread.h>
#include <unistd.h>
//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);

int g_data = 0;             //定义一个全局变量

void *func1(void *arg)
{
	static int ret = 10;    //定义一个静态变量
	
	printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
	printf("t1:param is %d\n",*((int *)arg));

	while(1)
	{
		printf("t1:%d\n",g_data++);打印g_data的值
		sleep(1);
	}
	  pthread_exit((void *)&ret);

}

void *func2(void *arg)
{
        static int ret = 10;

        printf("t2:%ld thread is create\n",(unsigned long)pthread_self());
        printf("t2:param is %d\n",*((int *)arg));

	  while(1)
        {
                printf("t2:%d\n",g_data++);打印g_data的值
                sleep(1);
        }

	  pthread_exit((void *)&ret);
}

	
int main()
{
	int ret1,ret2;
	int param = 100;
	
	pthread_t t1;
	pthread_t t2;
	int *pret = NULL;
	
	//创建线程1
	ret1 = pthread_create(&t1,NULL,func1,(void *)&param);
	if(ret1 == 0)
	{
		printf("main:create t1 successful\n");
	}	
	
	//创建线程2
	ret2= pthread_create(&t2,NULL,func2,(void *)&param);
	 if(ret2 == 0)
        {
                printf("main:create t2 successful\n");
        }


	  while(1)
        {
                printf("main:%d\n",g_data++);//主线程也打印g_data的值
                sleep(1);
        }
        
	printf("main:%ld\n",(unsigned long)pthread_self());
	
	pthread_join(t1,NULL);//等待子线程t1退出
	pthread_join(t2,NULL);//等待子线程t2退出
	return 0;
}

输出结果:
每次线程之间的运行顺序不定，g_data打印出来的值没重复，说明多个线程操作的是同一个数
从运行结果可以知道，线程是共享内存空间的。
在这里插入图片描述

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

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

  • 创建及销毁互斥锁
    在这里插入图片描述
    注：要用默认的属性初始化互斥量，只需把attr设置为NULL。
    　
    互斥变量用pthread_mutex_t数据类型表示。在使用互斥变量前必须对它进行初始化，可以把它置为常量PTHREAD_MUTEX_INITIALIZER（只对静态分配的互斥量），也可以通过调用pthread_mutex_init函数进行初始化。如果动态地分配互斥量（例如通过调用malloc函数），那么在释放内存前需要调用pthread_mutex_destroy。
  • 加锁及解锁
    -
    如果线程不希望被阻塞，它可以使用pthread_mutex_trylock尝试对互斥量进行加锁。如果调用pthread_mutex_trylock时互斥量处于未锁住状态，那么pthread_mutex_trylock将锁住互斥量，不会出现阻塞并返回0，否则pthread_mutex_trylock就会失败，不能锁住互斥量，而返回EBUSY。
  • 测试代码：
//Test3.c
#include<stdio.h>
#include<pthread.h>
#include <unistd.h>


//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
int g_data = 0;

pthread_mutex_t mutex;//定义互斥变量，全局变量，每个线程都能访问到这把锁

void *func1(void *arg)
{
	int i;
	
	pthread_mutex_lock(&mutex);//加锁
	for(i=0;i<5;i++)
	{
		printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
	        printf("t1:param is %d\n",*((int *)arg));
		sleep(1);
	}

	pthread_mutex_unlock(&mutex);//解锁
}


void *func2(void *arg)
{
	pthread_mutex_lock(&mutex);//加锁
	
	printf("t2:%ld thread is create\n",(unsigned long)pthread_self());
    printf("t2:param is %d\n",*((int *)arg));
	
	pthread_mutex_unlock(&mutex);//解锁

}


int main()
{
	int ret1,ret2,ret3;
	int param = 100;
	
	pthread_t t1;
	pthread_t t2;


	pthread_mutex_init(&mutex,NULL);//创建互斥锁

	int *pret = NULL;

	//----------------创建两个子线程---------------------
	ret1 = pthread_create(&t1,NULL,func1,(void *)&param);
	if(ret1 == 0)
	{
		printf("main:create t1 successful\n");
	}	


	 ret2 = pthread_create(&t2,NULL,func2,(void *)&param);
	 if(ret2 == 0)
        {
                printf("main:create t2 successful\n");
        }

	//----------------------------------------------------
	
	printf("main:%ld\n",(unsigned long)pthread_self());//打印主线程的ID号

	pthread_join(t1,NULL);//等待子线程t1退出
	pthread_join(t2,NULL);//等待子线程t2退出
	
	pthread_mutex_destroy(&mutex);//销毁互斥锁
	return 0;
}

输出结果:
加锁后，这些代码执行完，才释放锁
在这里插入图片描述

在这里插入图片描述

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

实现功能:当全局变量g_data等于3时，线程t1退出

  • 测试代码：
//Test3.c
#include<stdio.h>
#include<pthread.h>
#include <unistd.h>
#include<stdlib.h>

//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);

int g_data = 0;          //定义一个全局变量g_data
pthread_mutex_t mutex;   //定义一个互斥变量

void *func1(void *arg)
{	
	printf("t1:%ld thread is create\n",(unsigned long)pthread_self());
	printf("t1:param is %d\n",*((int *)arg));
	
	pthread_mutex_lock(&mutex);//上锁
	while(1)
	{
		printf("t1:%d\n",g_data++);
		sleep(1);
		if(g_data == 3)
		{
			pthread_mutex_unlock(&mutex);//解锁
			printf("================t1 quit==============\n");
			//pthread_exit(NULL);
			exit(0);//进程是线程的容器，线程退出后，整个进程也就退出了
		}
	}
}


void *func2(void *arg)
{
        printf("t2:%ld thread is create\n",(unsigned long)pthread_self());
        printf("t2:param is %d\n",*((int *)arg));

	  while(1)
        {              
			 printf("t2:%d\n",g_data);
	         pthread_mutex_lock(&mutex);//上锁
			 g_data++;
			 pthread_mutex_unlock(&mutex);//解锁
			 sleep(1);
        }
}

	
int main()
{
	int ret1,ret2;
	int param = 100;
	pthread_t t1;
	pthread_t t2;
	pthread_mutex_init(&mutex,NULL);//创建互斥锁
	int *pret = NULL;

	//===================创建两个子线程=============================
	ret1 = pthread_create(&t1,NULL,func1,(void *)&param);
	if(ret1 == 0)
	{
		printf("main:create t1 successful\n");

	}	

	ret2 = pthread_create(&t1,NULL,func2,(void *)&param);
	if(ret2 == 0)
        {
                printf("main:create t2 successful\n");
        }
	//===============================================================
	while(1)
	{
		printf("main:%d\n",g_data);
		sleep(1);
	}


	pthread_join(t1,NULL);//等待子线程t1退出
	pthread_join(t2,NULL);//等待子线程t2退出
	
	pthread_mutex_destroy(&mutex);//销毁互斥锁
	return 0;
}

输出结果:
在这里插入图片描述

6、什么情况造成死锁

  • 如果线程试图对同一个互斥量加锁两次，那么它自身就会陷入死锁状态，但是使用互斥量时，还有其他不太明显的方式也能产生死锁。例如，程序中使用一个以上的互斥量时，如果允许一个线程–直占有第一个互斥量，并且在试图锁住第二个互斥量时处于阻塞状态，但是拥有第二个互斥量的线程也在试图锁住第一个互斥量。因为两个线程都在相互请求另一个线程拥有的资源，所以这两个线程都无法向前运行,于是就产生死锁。
//Test4.c
#include<stdio.h>
#include<pthread.h>
#include <unistd.h>
#include<stdlib.h>

//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);
int g_data = 0; //定义一个全局变量


//---------------定义两把锁-------------------
pthread_mutex_t mutex1;
pthread_mutex_t mutex2;
//-------------------------------------------

//线程t1获得了mutex1这把锁，然后在没有解这把锁的情况下，再想去获得另一把锁，另一把锁被线程t2拿了，线程t2再没有解锁的情况下，也想去获得线程t1获得的锁，造成死锁
void *func1(void *arg)
{	
	
	pthread_mutex_lock(&mutex1);
	pthread_mutex_lock(&mutex2);	
}
void *func2(void *arg)
{
	pthread_mutex_lock(&mutex2);
    pthread_mutex_lock(&mutex1);
}

	
int main()
{
	int ret1,ret2;
	int param = 100;
	pthread_t t1;
	pthread_t t2;

	//创建两个互斥锁
	pthread_mutex_init(&mutex1,NULL);
	pthread_mutex_init(&mutex2,NULL);

	int *pret = NULL;
	
	//=====================创建两个子线程========================
	ret1 = pthread_create(&t1,NULL,func1,(void *)&param);
	if(ret1 == 0)
	{
		printf("main:create t1 successful\n");
	}	
	
	 ret2 = pthread_create(&t2,NULL,func2,(void *)&param);
	 if(ret2 == 0)
        {
                printf("main:create t2 successful\n");
        }
    //===========================================================
	pthread_join(t1,NULL);//等待子线程t1退出
	pthread_join(t2,NULL);//等待子线程t2退出
	
	pthread_mutex_destroy(&mutex1);//销毁互斥锁
	pthread_mutex_destroy(&mutex2);//销毁互斥锁
	return 0;
}

输出结果:

可以看出程序卡住了
在这里插入图片描述

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

（1）条件变量是线程另一可用的同步机制。条件变量给多个线程提供了一个会合的场所。条件变量与互斥量一起使用时，允许线程以无竞争的方式等待特定的条件发生
（2）条件本身是由互斥量保护的。线程在改变条件状态前必须首先锁住互斥量，其他线程在获得互斥量之前不会察觉到这种改变，因为必须锁定互斥量以后才能计算条件。
（3）条件变量使用之前必须首先初始化，pthread_cond_t数据类型代表的条件变量可以用两种方式进行初始化，可以把常量PTHREAD_COND_INITIALIZER赋给静态分配的条件变量，但是如果条件变量是动态分配的，可以使用pthread_cond_destroy函数对条件变量进行去除初始化（deinitialize）。

  • 创建及销毁条件变量
    在这里插入图片描述
    除非需要创建一个非默认属性的条件变量，否则pthread_cont_init函数的attr参数可以设置为NULL。

  • 等待
    在这里插入图片描述

  • 触发
    在这里插入图片描述

  • 测试代码：

//Test5.c
#include<pthread.h>
#include <unistd.h>
#include<stdlib.h>
#include<stdio.h>
//int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg);

int g_data = 0;

pthread_cond_t cond;
pthread_mutex_t mutex;

void *func1(void *arg)
{	
	while(1)
	{
		pthread_cond_wait(&cond,&mutex);//线程t1被唤醒	
		printf("===============t1 run==============\n");
		printf("t1:%d\n",g_data);
		g_data = 0;
		sleep(1);
	}
}
void *func2(void *arg)
{
	  while(1)
        {              
			printf("t2:%d\n",g_data);
            pthread_mutex_lock(&mutex);
			g_data++;
			
			if(g_data == 3)
			{
				pthread_cond_signal(&cond);//触发
			}
			pthread_mutex_unlock(&mutex);
			sleep(1);
        }
}

	
int main()
{
	int ret1,ret2;
	int param = 100;
	pthread_t t1;
	pthread_t t2;
	pthread_mutex_init(&mutex,NULL);//创建互斥锁
	pthread_cond_init(&cond, NULL);//创建条件变量

	ret1 = pthread_create(&t1,NULL,func1,(void *)&param);
	ret2 = pthread_create(&t2,NULL,func2,(void *)&param);

	pthread_join(t1,NULL);//等待子线程t1退出
	pthread_join(t2,NULL);//等待子线程t2退出
	
	pthread_mutex_destroy(&mutex);//销毁互斥锁
	pthread_cond_destroy(&cond);//销毁条件变量
	return 0;
}

输出结果:
在这里插入图片描述

二、往期文章

1、入门Linux系统编程–文件
2、入门Linux系统编程–进程
3、入门Linux系统编程–线程
4、入门Linux系统编程–进程间通信
5、入门Linux系统编程–网络编程

秃秃秃秃哇
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Linux多线程之基本编程
MakersSky的博客
12-19 248
线程是指运行中的程序的调度单位。一个线程指的是进程中一个单一顺序的控制流，也被称为轻量级线程。它是系统独立调度和分配的基本单位。同一进程中的多个线程将共享该系统中的全部系统资源，比如文件描述符和信号处理等。一个进程可以有很多线程，每个线程并行执行不同的任务。
Linux编程之线程基本编程
骨头和狗的博客
04-25 394
#include<stdio.h> #include<stdlib.h> #include<pthread.h>#define THREAD_NUMBER 3/*线程数*/ #define REPEAT_NUMBER 5 /*每个线程中的小任务数*/ #define DELAY_TIME_LEVELS 10.0 /*小任务之间的最大时间间隔*/ void *thrd_func(void *arg)
Linux多线程编程|线程基本编程
安迪西_嵌入式攻城狮
09-02 440
线程基本编程 1. 线程简介 为了进一步减少处理机的空转时间，支持多处理器，以及减少上下文切换开销，进程在演化过程中出现了另一个概念------线程。它是进程内独立的一条运行线路，是处理器调度的最小单元，也称为轻量级进程。由于线程的高效性和可操作性，在嵌入式系统开发中应用非常广泛。 一个进程中的多个线程共享的资源有：可执行的指令、静态数据、进程中打开的文件描述符、当前工作目录、用户ID和用户组ID 每个线程私有的资源包括：线程ID（TID）、PC（程序计数器）和相关寄存器、堆栈、错误号、优先级、执行状态和属
Linux编程基础 ：线程
weixin_59343712的博客
05-25 130
首先我们要了解线程的基本操作 线程操作 创建线程 挂起线程 终止线程 其它操作 1.1 创建线程 #include <pthread.h> int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg); 功能：创建线程；线程调用pthread_create函数创建新线程后，当前线程会从pthread_create函数
Linux线程编程（一）
qq_42882082的博客
06-07 109
一.线程基本知识 1.定义 （1）进程是资源管理的基本单元，而线程是系统调度的基本单元，线程是操作系统能够进行调度运算的最小单位，它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。 （2）一个进程在某一个时刻只能做一件事情，有了多个控制线程以后， 程序设计成在某一个时刻能够做不止一件事，每个线程处理独自的任务。 需要注意的是：即使程序运行在单核处理器上，也能够得到多线程编程模型的好处。处理器的数量并不影响程序结构，所
Linux系统下的多线程编程入门.pdf
12-20
在Linux系统下进行多线程编程是开发高效并发应用程序的关键技术之一。本文将深入探讨Linux环境中的多线程概念、创建与管理线程的方法、线程同步与通信机制，以及多线程编程中可能遇到的问题和解决策略。 一、多线程...
头歌Linux系统编程之c编程入门
11-20
【头歌Linux系统编程之C编程入门】是一个关于在Linux环境下进行C语言编程学习的教程。这个教程覆盖了从基础的C语言编程到更高级的Linux系统编程技术，旨在帮助初学者逐步掌握在Linux系统中编写C程序的能力。 1. **...
Linux多线程编程入门
01-20
　需要注意的是：即使程序运行在单核处理器上，也能够得到多线程编程模型的好处。处理器的数量并不影响程序结构，所以不管处理器个数多少，程序都可以通过线程得以简化。 　linux操作系统使用符合POSI
Linux多线程编程快速入门
01-20
本文主要对Linux下的多线程进行一个入门的介绍，虽然是入门，但是十分详细，希望大家通过本文所述，对Linux多线程编程的概念有一定的了解。具体如下。 1 线程基本知识 进程是资源管理的基本单元，而线程是系统调度的...
Linux系统编程——线程
weixin_42149066的博客
10-08 144
Linux系统编程——线程
Linux多线程编程(一)---多线程基本编程
热门推荐
王文松的博客
07-20 2万+
线程是指运行中的程序的调度单位。一个线程指的是进程中一个单一顺序的控制流，也被称为轻量级线程。它是系统独立调度和分配的基本单位。同一进程中的多个线程将共享该系统中的全部系统资源，比如文件描述符和信号处理等。一个进程可以有很多线程，每个线程并行执行不同的任务。
Linux 多线程编程（三）
轮子工厂
06-01 4561
1 线程安全多线程编程环境中，多个线程同时调用某些函数可能会产生错误结果，这些函数称为非线程安全函数。如果库函数能够在多个线程中同时执行并且不会互相干扰，那么这个库函数就是线程安全（ thread-safe）函数 。2 互斥量2.1 临界区 在计算机系统中有许多共享资源不允许用户并行使用。例如打印机设备，如果它同时进行两份文档打印，它的输出就会产生交错，从而都无法获得正确的文档。像打印机这样的共享...
Linux C多线程编程基础
程序人生
08-23 2501
获取线程标识符        每一个线程都有一个在进程中唯一的线程标识符，在Linux中用一个数据类型pthread_t来表示，实际上这个类型是一个机器相关的无符号整型数据。        Linux提供了两个函数用于获取和比较线程标识符。 #inlcude &lt;pthread.h&gt; pthread_t pthread_self(void); //返回值是线程自身的线程标...
【Linux】进程间通信——匿名管道
2201_76024104的博客
07-08 717
1.：一个进程需要将它的数据发送给另一个进程，比如我们有两个进程，一个负责获取数据，另一个负责处理数据，这时第一个进程就要将获取到的数据交给第二个进程2.：多个进程间共享同样的资源3.：一个进程需要给其他进程发送消息，通知他们发生了某种事件4.：有些事件需要完全控制另一个进程，比如我们在使用gdb调试时，gdb就是一个进程，它控制了我们要调试的进程进程之前是有互相传递信息的需求，但是，一个进程不可能去另一个进程的地址空间中取信息，所以这就要求操作系统去提供一块交换数据的空间来供进程之间使用。
【linux/shell】linux如何去除字符串中空格
qq_35902025的博客
07-06 321
linux如何去除字符串中空格 tr命令可以用来替换或删除字符 sed是一个流编辑器，可以用来处理文本
nginx安装（win和linux）
f552126506的博客
07-07 534
nginx安装（win和linux）
RedHat运维-LinuxSELinux基础4-端口绑定SELinux上下文
a15735748145a的博客
07-06 606
12. 将60001/tcp端口上的SELinux上下文由http_port_t调整为gopher_port_t的方法是______________________；13. 将60002/tcp端口上的SELinux上下文由gopher_port_t调整为ssh_port_t的方法是______________________；14. 将60003/tcp端口上的SELinux上下文由ssh_port_t调整为http_port_t的方法是_______________________；
保姆级教程：Linux (Ubuntu) 部署流光卡片开源 API
最新发布
梦染 * 星尘 的博客
07-09 436
流光卡片 API 开源地址 Github：https://github.com/ygh3279799773/streamer-card流光卡片 API 开源地址 Gitee：https://gitee.com/y-gh/streamer-card流光卡片在线使用地址：https://fireflycard.shushiai.com/想要使用 api 调用服务，需要有一个服务器来时刻监听请求。服务器终端界面阅读不方便，因此需要使用宝塔面板进行管理。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

秃秃秃秃哇

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

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

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

打赏作者

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

抵扣说明：

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

余额充值