Linux：多线程的操作

已于 2024-06-12 16:31:18 修改
阅读量1.2k 收藏 24
点赞数 10
文章标签： linux c++
于 2024-06-12 15:49:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_57663528/article/details/139514329
版权

多线程操作

进程与线程

  • 进程是资源分配的基本单位
  • 线程是调度的基本单位，共享进程的数据，拥有自己的一部分数据

线程私有的属性：线程的ID、一组寄存器（上下文数据）、栈（独立的栈结构）、调度优先级

进程的多个线程共享同一块地址空间，对堆区、栈区都是共享的

线程共享进程的资源有：文件描述符表、每种信号的处理方式（默认动作、忽略动作、自定义动作）、当前工作目录

线程的创建 create_pthread

Linux下没有真正意义的线程，而是用进程模拟的线程（LWP）。对此，Linux不会提供直接创建线程的系统调用，只会提供创建轻量级进程的接口。

在用户看来会很变扭，进程是进程，线程是线程就要区分开来。

所以出现了用户级线程库 pthread：对Linux接口进行封装，给用户提供进行线程控制的接口

（pthread 线程库在任何版本的Linux操作系统都会存在， pthread也被称为原生线程库）

可以通过 man 的3号手册来查看线程库的使用，这里不作演示

接下来介绍一些线程库的接口使用：

使用原生线程库需要包含头文件：#include <pthread>

  • 创建线程
int pthread_create(pthread_t *thread, const pthread_attr_t* attr,
					void* (*start_routine)(void*), void* arg);

pthread_create 函数参数介绍

thread：线程 id 地址，pthread_t 为无符号整数
attr：线程属性（线程优先级）
start_routine：函数指针，执行对应的函数功能（可以对函数进行传参），也被称为回调函数
arg：是指向任意数据的指针，将参数传递给 start_routine 函数
返回值：线程创建成功返回0，失败错误码被设置

示例：

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

void* thread_run(void* arg)
{
	while(true)
	{
		std::cout << "new thread running" << std::endl;
		sleep(1);
	}
	return nullptr;
}

int main()
{
	pthread_t t;
	pthread_create(&t, nullptr, thread_run, nullptr);//创建线程，t是输出型参数
	
	//主进程
	while(true)
	{
		std::cout << "main thread running, new thread id:" << t << std::endl;
		sleep(1);
	}
	
	return 0;
}

上面代码直接编译的话会出现链接报错，这是因为这个多线程是一个库，直接编译 g++ 会找不到这个库，需要指定编译器去找线程库。
在这里插入图片描述

对此，在编译时，使用 g++ 进行编译要加上 -lpthread 选项

g++ -o threadTest threadTest .c -std=c++11 -lpthread

在这里插入图片描述

可以通过 ldd 对编译好的可执行文件来查看线程库的位置：

ldd threadTest

在这里插入图片描述
执行程序可以看到，主线程与子线程同时运行：

在这里插入图片描述

在这里插入图片描述
此时输出的线程id会很大，很奇怪。其实这些线程的id是地址，创建的线程会被线程库管理起来，形成数组，每个对应的线程id 其实就是数组的下标。

创建的线程是不能确定先后顺序的. Linux下的线程是轻量级的进程，进程创建执行的先后顺序是由调度器决定的，对此线程谁先谁后的问题也要看调度器来决定的

创建线程池

下面来创建一个线程池，让每一个线程都执行 thread_run 这个函数，打印对应的创建编号

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

#define NUM 10

void* thread_run(void* arg)
{
	char* name = (char*)arg;
	
	while(true)
	{
		std::cout << "new thread running,thread name is:" << name << std::endl;
		sleep(1);
	}
	return nullptr;
}

int main()
{
	pthread_t tids[NUM];
	for(int i = 0; i < NUM; i++)
	{
		char thname[64];
		snprintf(thname, sizeof(thname), "thread-%d", i + 1);
		pthread_create(tids + i, nullptr, thread_run, thname);//创建线程池，将thname传参
	}
	
	//主进程
	while(true)
	{
		std::cout << "main thread running" << std::endl;
		sleep(1);
	}
	
	return 0;
}

编译运行：

在这里插入图片描述

结果很不对，输出的结果都是一样的。

在给线程回调函数进行传参时，传入的是 thname 地址。thname 字符数组是属于主线程的，属于临时变量。前面提到线程会共享进程中的数据。对此，每个线程都会对这个变量进行读写，导致最终显示的结果都是一样的。

解决方式如下：

对 thname 变量在堆上申请空间，待到回调函数使用完后对这个资源进行释放：

void* thread_run(void* arg)
{
	char* name = (char*)arg;
	
	while(true)
	{
		std::cout << "new thread running,thread name is:" << name << std::endl;
		sleep(1);
	}
	
	delete name; //释放空间
	return nullptr;
}

int main()
{
	pthread_t tids[NUM];
	for(int i = 0; i < NUM; i++)
	{
		char* thname = new char[64]; //堆上开辟空间
		
		snprintf(thname, 64, "thread-%d", i + 1);
		pthread_create(tids + i, nullptr, thread_run, thname);//创建线程池，将thname传参
	}
	//主进程
	while(true)
	{
		std::cout << "main thread running" << std::endl;
		sleep(1);
	}
	
	return 0;
}

编译运行：
在这里插入图片描述
创建线程前，每次对 thname 进行资源申请，回调函数之后对资源进行释放，可以很好的避免资源共享情况发生。从结果也可以看出不同线程的执行先后顺序也是不确定的。

给线程传入对象的指针

创建线程时，不仅仅只可以传入内置类型变量的指针，还可以传入自定义类型变量的指针

示例：构建 ThreadDate 类，其内部包含线程的基本信息。在类中实现输入型参数和输出型参数，方便我们获取线程处理后的数据结果

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include <string>
#include <ctime>

#define NUM 3

enum { OK=0, ERROR };

struct ThreadDate
{
	//构造
	ThreadDate(const string& name, pthread_t tid, time_t createTime, size_t top = 0)
		:_name(name), 
		_tid(tid), 
		_createTime((uint64_t)createTime),
		_status(OK),
		_top(top),
		_result(0)
	{}

	~ThreadDate(){}

	//成员变量
	//输入型变量
	string _name;
	pthread_t _tid;
	uint64_t _createTime; //创建时间
	//输出型变量
	int _status; //线程退出状态
	size_t _top;//累加到最大值
	int _result;
};

下面通过实例化这个类，来演示线程中传入对象：

int main()
{
	pthread_t tids[NUM];
	// 创建线程池
	for (int i = 0; i < NUM; i++)
	{
		char *thname = new char[64];
		snprintf(thname, 64, "thread-%d", i + 1);
		//定义ThreadDate类，传入到线程中
		ThreadDate* tdate = new ThreadDate(std::string(thname), i+1, time(nullptr), (100+ i * 5));
		pthread_create(tids + i, nullptr, thread_run, tdate); //将tdate对象进行传参
	}

	void *ret = nullptr; // 用于保存子线程退出的信息

	for (size_t i = 0; i < NUM; i++)
	{
		int n = pthread_join(tids[i], &ret); //传入ret指针的地址
		if(n != 0) std::cerr << "pthread_join error" << std::endl;

		ThreadDate* td = static_cast<ThreadDate*>(ret); //指针类型转换
		if(td->_status == OK) //输出对象内容
			std::cout << td->_name << " 计算的结果是: " << td->_result << " (它要计算的是[1, " << td->_top << "])" << std::endl;
		
		//释放资源
		delete td;
	}
	return 0;
}

在这里插入图片描述

线程等待 pthread_join

上面实现的代码中，我们将主线程用死循环的方式，一直维持进程的运行。

如果去掉死循环，线程还能继续执行下去吗？

对上面的代码进行修改：在线程被创建后，维持 3 秒后主进程退出

int main()
{
	pthread_t tids[NUM];
	for(int i = 0; i < NUM; i++)
	{
		char* thname = new char[64]; //堆上开辟空间
		
		snprintf(thname, 64, "thread-%d", i + 1);
		pthread_create(tids + i, nullptr, thread_run, thname);//创建线程池，将thname传参
	}
	
	//主进程
	sleep(3);
	
	return 0;
}

在这里插入图片描述

进程是资源的申请的主体，进程退出了，不管子进程还在进行什么操作都会终止运行。

这样会造成什么后果？

会造成资源泄漏，如果此时的线程在堆区申请了资源还没来得及释放，会导致内存泄漏。

线程与子进程一样，线程退出后需要被回收处理。就拿子进程来说，当子进程退出后会处于僵尸状态，父进程如果没有等待子进程，对子进程的僵尸状态进行回收的话会造成资源的泄漏。

有僵尸进程，但是有没有僵尸线程一说。与进程相似，线程退出后也会处于一种被回收的状态，没有及时回收线程的话，也会造成内存泄漏！

对此，线程退出是需要进行等待的

下面来介绍一个函数接口：pthread_join 等待线程

 int pthread_join(pthread_t thread, void **retval);

参数介绍：

thread：等待的线程 id 号
retval：是一个指向指针的指针，用于存储被等待线程的返回值
返回值：等待成功返回0，失败错误码被返回

对上面的代码进行修改，写一个等待进程的版本：

void* thread_run(void* arg)
{
	char* name = (char*)arg;
	while(true)
	{
		std::cout << "new thread running,thread name is:" << name << std::endl;
		sleep(1);
	}
	delete name; //释放空间
	return nullptr;
}

int main()
{
	pthread_t tids[NUM];
	for(int i = 0; i < NUM; i++)
	{
		// char thname[64];
        char* thname = new char[64];
		// snprintf(thname, sizeof(thname), "thread-%d", i + 1);
		snprintf(thname, 64, "thread-%d", i + 1);
		pthread_create(tids + i, nullptr, thread_run, thname);//创建线程池，将thname传参
	}

	for(size_t i = 0; i < NUM; i++)
	{
		pthread_join(tids[i], nullptr);//等待线程
	}

	return 0;
}

有了线程等待，可以很好的避免内存泄漏。主进程会等待所有的子线程，只有当所有的线程都退出后才会结束整个程序的运行。

退出线程 pthread_exit

如何控制线程的退出呢？

这里还是拿进程来说，也比较好举例（前面也说过线程是轻量级的进程）。进程退出的方式可以在main函数中使用 return 语句、在任意行代码处调用 exit 函数。

那么线程可以使用类似的方法吗？

先来看看 return 语句的作用，还是拿刚刚编写的代码来举例。这里我们直接往死循环内部编写 3 秒的停顿，之后直接执行break 语句，后续执行 return 语句。为了方便展示，下面只展示修改的代码：

void* thread_run(void* arg)
{
	char* name = (char*)arg;
	while(true)
	{
		std::cout << "new thread running,thread name is:" << name << std::endl;
		sleep(3);
		break;  //跳出循环
	}
	delete name; 
	return nullptr;
}

编译运行，来看看执行结果：

在这里插入图片描述
所有的线程都会打印一次，然后停顿卡住，到执行 return 语句后所有的线程都会退出。执行的效果也是符合我们的预期的。

下面来使用 exit 函数来测试线程退出情况，还是上面的代码，将 break 语句换成 exit 函数

void* thread_run(void* arg)
{
	char* name = (char*)arg;
	
	while(true)
	{
		std::cout << "new thread running,thread name is:" << name << std::endl;
		exit(10); //调用exit函数
	}

    delete name; //释放空间
	return nullptr;
}

下面来看看现象：
在这里插入图片描述

线程池只创建了一部分，然后直接终止了运行。在右边监视 threadTest 进程也没有任何显示。

exit 函数退出作用是整个 threadTest 进程，当某一子线程调用了 exit 函数的时候，就会导致整个进程都退出。这也是为什么会只创建了一些子线程，然后导致整个进程都结束运行了。

对此，在线程执行流中，非必要情况下，不要轻易的调用 exit 函数。

不能使用 exit 函数，但是线程库中提供了一个API，用于退出某一线程：pthread_exit

void pthread_exit(void *retval);

参数介绍：

retval：指向线程退出状态的指针

当线程调用 pthread_exit 时，它会立即停止执行，并释放其栈空间。但是，线程的资源（如线程ID和线程属性）直到其他线程调用 pthread_join 来回收它时才会被完全释放。

示例：

#define NUM 3

void* thread_run(void* arg)
{
	char* name = (char*)arg;
	
	while(true)
	{
		std::cout << "new thread running,thread name is:" << name << std::endl;
		sleep(4);
		break;
	}
    delete name; //释放空间
	
	pthread_exit(nullptr); //退出调用的线程
}

int main()
{
	pthread_t tids[NUM];
	for(int i = 0; i < NUM; i++)
	{
		// char thname[64];
        char* thname = new char[64];
		// snprintf(thname, sizeof(thname), "thread-%d", i + 1);
		snprintf(thname, 64, "thread-%d", i + 1);
		pthread_create(tids + i, nullptr, thread_run, thname);//创建线程池，将thname传参
	}

	//等待线程
	for(size_t i = 0; i < NUM; i++){ pthread_join(tids[i], nullptr); }
	return 0;
}

这里只创建了三个子线程的线程池，来看看运行的效果：
在这里插入图片描述

线程等待参数 retval 与 线程退出参数 retval

先来看看这两个API的接口声明：

int pthread_join(pthread_t thread, void **retval); //线程等待接口
void pthread_exit(void *retval); //线程退出接口

两个函数之间的 retval 参数有关联吗？答案是有的。

一般创建进程都是为了帮助我们去完成某些任务，线程也是如此，创建线程也是为了帮助进程完成一部分任务。进程在完成任务后正常退出，返回对应的退出码。当然，进程完成到一定的任务时也会直接退出。

下面是进程退出的几个情况：

  1. 在 main 函数中调用 return 语句，返回对应的退出码；
  2. 在进程中任意代码处调用 exit 函数。当然调用 exit 函数需要传参，进程退出的退出码也就是传入exit 函数参数的值；
  3. 收到OS的终止信号

进程的退出码、退出信号的返回，是方便我们去查看当前进程是不是完成了指定的任务。线程也是如此，线程退出是否正常我们也要知道。对此，上面提到的 两个 API 接口的参数作用就是用于获取线程退出的退出信息！

线程退出接口 pthread_exit 一般是用在回调函数内部，也就是子线程中。我们可以先将 pthread_exit 功能想象成 exit 函数那般，在子线程退出后我们将子线程退出码带出来。

但是问题来了，为什么 pthread_exit 传入的参数是 void* retval 一级指针？

这个要结合 pthread_join 来看：

int pthread_join(pthread_t thread, void **retval);

pthread_join 是等待线程的一个接口，会回收退出的子线程（线程的ID、线程的属性等）。pthread_join 的 retval 是一个输出型参数。

这里的 retval 如同在进程中调用的 wait 函数时，传入 status 参数，这个 status 也是输出型参数，会将 子进程的退出码、退出信号带出来。

retval 参数的作用就是将子线程的退出数据带出来，不同的是这里是二级指针。在使用前需要定义一个指针，然后将这个指针的地址传入 pthread_join 的 retval 参数中。在子线程调用 pthread_exit 函数时，传出对应的数据即可。

光说不做，假把戏。下面来看看测试案例：

void *thread_run(void *arg)
{
	char *name = (char *)arg;
	while (true)
	{
		std::cout << "new thread running,thread name is:" << name << std::endl;
		sleep(3);
		break;
	}

	delete name; // 释放空间
	pthread_exit((void*)1); //子线程退出，退出信息设置为1
}

int main()
{
	pthread_t tids[NUM];
	for (int i = 0; i < NUM; i++)
	{
		char *thname = new char[64];
		snprintf(thname, 64, "thread-%d", i + 1);
		pthread_create(tids + i, nullptr, thread_run, thname); // 创建线程池，将thname传参
	}

	void *ret = nullptr; // 用于保存子线程退出的信息

	for (size_t i = 0; i < NUM; i++)
	{
		int n = pthread_join(tids[i], &ret); //传入ret指针的地址
		if(n != 0) std::cerr << "pthread_join error" << std::endl;
		std::cout << "子线程：thread->" << i+1 << "，退出码为：" << (uint64_t)ret << std::endl;
	}
	
	return 0;
}

这里需要注意就是传指针的问题：

定义 ret 一级指针，传参到 pthread_join 内部时，传入的是 ret 指针的地址。pthread_exit 传参需要传入指针类型，对此上面代码需要对 1 进行 void* 类型的强转。在输出子线程退出信息时，ret 是指针，经过子线程的等待，ret内部值已经被设置为了除了低位的第一位为1其他全为 0 的二进制序列，在通过 uint64_t 类型强转即可将数据打印输出！

在这里插入图片描述

还要提一点就是：在获取线程的退出码时，是不需要考虑异常的。如果一个线程中出现了异常，那么就会带动的整个主进程退出。主进程都退出了还需要考虑等待进程的异常吗？是不需要的。对此，在多线程中是不需要考虑异常的！异常问题通常是由进程来考虑。

线程中断 pthread_cancel

在实际开发需求中，如果想要将创建的线程中断运行需要用到 API：pthread_cancel

int pthread_cancel(pthread_t thread);

参数介绍：

thread：传入的线程编号

示例：我们先来创建一个正常线程，再执行一段任务后线程会自动退出：

void* thread_run(void* args)
{
	//静态类型转换
	const char* str = static_cast<const char*>(args);

	int cnt = 5;
	while(cnt)
	{
		cout << str << "is runing :" << cnt-- << endl;
		sleep(1);
	}

	//退出线程
	pthread_exit((void*)1);
}	

int main()
{
	//创建线程
	pthread_t tid;
	pthread_create(&tid, nullptr, thread_run, (void*)"thread 1");

	//等待线程
	void* ret = nullptr;
	pthread_join(tid, &ret);

	return 0;
}

在这里插入图片描述

修改上述代码，在线程执行两秒任务后，直接调用 pthread_cancel 接口，查看现象：

void* thread_run(void* args)
{
	//静态类型转换
	const char* str = static_cast<const char*>(args);

	int cnt = 5;
	while(cnt)
	{
		cout << str << "is runing :" << cnt-- << endl;
		sleep(1);
	}

	//退出线程
	pthread_exit((void*)1);
}	

int main()
{
	//创建线程
	pthread_t tid;
	pthread_create(&tid, nullptr, thread_run, (void*)"thread 1");

	//2秒后，中断线程
	sleep(2);
	pthread_cancel(tid);

	//等待线程
	void* ret = nullptr;
	pthread_join(tid, &ret);

	return 0;
}

在这里插入图片描述
可以看到当线程执行两秒后直接中断

获取线程编号 pthread_self

pthread_t pthread_self(void);

谁调用这个接口就获取谁的线程 id 编号，示例：

void* thread_run(void* args)
{
	//静态类型转换
	const char* str = static_cast<const char*>(args);

	int cnt = 5;
	while(cnt)
	{
		cout << str << "is runing :" << cnt-- << "obtain self id ->" << pthread_self() << endl; //获取线程id
		sleep(1);
	}

	//退出线程
	pthread_exit((void*)1);
}	

int main()
{
	//创建线程
	pthread_t tid;
	pthread_create(&tid, nullptr, thread_run, (void*)"thread 1");
	//等待线程
	void* ret = nullptr;
	pthread_join(tid, &ret);
	cout << " new thread exit : " << (int64_t)ret << "quit thread: " << tid << endl;
	return 0;
}

在这里插入图片描述

线程分离 pthread_detach

新线程被创建，默认情况下是 joinable 的，线程退出，主进程需要对这个线程进行 pthread_join 操作。不对线程进行等待的操作就会造成内存泄漏，无法释放资源。

如果不关心线程的返回值，那么等待就会变成一种负担。

就是主线程自己为了等待子线程，难道不用去做自己的事情了吗？这个时候，我们可以告诉OS，当线程退出的时候，自己去释放资源。如何操作呢？需要用到下面这个 API ：

int pthread_detach(pthread_t thread);

pthread_detach 功能是将一个线程分离出来，但是要记住一个点：被分离的线程在后续操作是不能被等待的！！如果对被分离的线程进行 pthread_join 操作，主进程是会报错的。报错出现后，就不会再对子线程进行等待操作，直接向后运行属于主进程的代码。

线程分离好比现实生活中的：已婚与未婚，是属于一种属性。
线程分离，并不是字面上的意思将线程与进程分离开那种。分离是一种属性，没有被分离的线程，是 joinable 的。该线程需要被等待回收资源；已经被分离的线程，其内部属性会发生变化，表示这个线程不需要再被等待回收资源。

示例：创建一个子线程，在等待子线程之前对该子线程进行分离操作

#include <pthread.h>
#include <iostream>
#include <cstdio>
#include <cstring>
#include <unistd.h>
#include <string>

using namespace std;

void* threadRoution(void* arg)
{
    const char* tname = static_cast<const char*>(arg);
    int cnt = 5;
    while(cnt)
    {
        cout << tname << ":" << cnt-- << endl;
        sleep(1);
    }
    return nullptr;
}

int main()
{
    //创建线程
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoution, (void*)"thread 1");

    //对子线程进行分离操作
    pthread_detach(tid);

    //等待线程
    void* ret = nullptr;
    int n = pthread_join(tid, &ret);
    if(n != 0) cerr << "error:" << errno << strerror(n) << endl;
    return 0;
}

编译查看效果：

在这里插入图片描述

主进程在等待子线程时，发现该线程已经被分离。对此，不会再阻塞等待子线程，程序直接向后运行走，子线程也没有机会继续执行对应的功能，整个进程就退出了。

因此，线程分离的主要功能就是将子线程分离出来，让主进程有更多的时间去处理属于自己事情，也不需要对子线程的资源释放与否而担心。

不过在使用线程分离的时候，要注意执行流先后问题，不然会出现奇奇怪怪的现象。

下面来举个例子：在子线程内部去调用本线程的分离

void* threadRoution(void* arg)
{
    //将调用的线程分离开来
    pthread_detach(pthread_self());

    const char* tname = static_cast<const char*>(arg);

    int cnt = 5;

    while(cnt)
    {
        cout << tname << ":" << cnt-- << endl;
        sleep(1);
    }

    return nullptr;
}

int main()
{
    //创建线程
    pthread_t tid;
    pthread_create(&tid, nullptr, threadRoution, (void*)"thread 1");

    int n = pthread_join(tid, nullptr);
    if(n != 0) cerr << "error:" << errno << strerror(n) << endl;

    return 0;
}

在这里插入图片描述

此时会发现，线程正常的跑，主进程也等待成功。

子线程调用分离没有用吗？其实不然，这是由于执行流先后问题：

子线程被创建出来之前，主进程就执行到了 pthread_join 代码处，子线程还没有来得及分离，分离属性没有被修改，造成主进程阻塞等待子线程。对此，就算子线程将自己分离开来，主进程早就处于进行了等待状态，也就造成了子线程继续往后执行的现象。

提示：使用线程分离的接口，尽量在创建线程之后进行调用，防止奇奇怪怪的执行流的问题产生

线程操作就讲到这里，感谢大家的支持！！

深夜吞食
关注
  • 10
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Linux 多线程原理深剖
qq_61500888的博客
12-24 3万+
带你一命通关 Linux 多线程原理 三十分钟手撕底层内涵
实验二：Linux多线程创建.docx
04-13
Linux 多线程创建实验 本实验的目的是为了进一步掌握在 Linux 系统进行 C 语言编程的方法，进一步了解线程的概念，进一步理解进程与线程的概念，并掌握 C 语言线程创建的方法。 实验原理： 1. Pthread_create ...
Linux: 多线程
miaomiaoAmlp的博客
12-04 4581
线程概念: 线程是进程中的一条执行流程. 在linux之前学习进程的时候 ，进程就是一个pcb, 但是在现在学习线程的时候, 发现线程是进程中的一条执行流，而因为linux下执行流是通过pcb来完成的，所以理解pcb是linux下的执行流，反推得到了一个结论，linux下的一个pcb是一个线程。只不过人家linux下通常不谈线程，而叫做轻量级进程. ( 有些地方认为Linux没有真正的线程的说法, 线程实际上是一个轻量级进程. ) 从另一个角度来说: 线程是cpu调度的基本单位, 进程是资源分.
【Linux】多线程操作
m0_72563041的博客
05-28 1344
多线程操作
Linux系统编程：多线程交替打印ABC
NiGo的博客
07-21 2825
引言 分享关于线程的一道测试题，因为网上基本都是Java的解决方法，决定自己写一篇来记录一下线程的学习。 问题描述 编写一个至少具有三个线程的程序(称之为线程 A、B 和 C),其中线程 A 输出字符’A’，线程 B 输出字符’B’,线程 C 输出字符’C’。使得最终输出结果为“ABCABCABC…”。 思路 拿到这题后，我的想法是把问题简化。 原题让我们交替打印ABC，那么我们只要先考虑如何交替打印AB即可，然后在B之后衔接C，在C之后衔接A即可。 那么，如何使两个线程能够按照顺序去执行任务呢？ 关于线程
Linux：线程优先级设置
小嵌同学的博客
12-24 4284
同一优先级的多个线程中，一旦某个抢占式线程获取CPU，除非被更高优先级线程抢占（比如在非实时线程中创建一个更高优先级的实时线程），或该线程主动让出CPU资源，否则该线程将会一直占用CPU（但总会分配一点资源给SCHED_OTHER非实时线程）。另外，需要注意的是，只有具有足够权限的用户才能设置较高的实时线程优先级。，轮询式调度（实时线程），实时循环，设置优先级1-99，以循环方式运行，每个线程都有一个时间片来执行任务，时间片耗尽后，该线程将被放入队列的末尾，而较低优先级的线程有机会执行。
Linux下多线程间通信
09-14
在Linux环境下，多线程间通信是实现并发执行任务并协调数据访问的关键技术。线程间的通信主要通过共享内存和同步机制来实现，因为线程天然具有共享数据结构的能力，这意味着全局变量可以在多个线程之间共享。然而，...
多线程编程之：Linux线程编程
08-02
Linux 多线程编程是指在 Linux 操作系统中使用多线程技术来实现并发编程。线程是一种轻量级的进程，它可以共享同一个进程的资源和地址空间。在 Linux 中，pthread 线程库是一套通用的线程库，由 POSIX 提出的，因此...
Linux系统下的多线程编程入门.pdf
12-20
在Linux系统下进行多线程编程是开发高效并发应用程序的关键技术之一。本文将深入探讨Linux环境中的多线程概念、创建与管理线程的方法、线程同步与通信机制，以及多线程编程中可能遇到的问题和解决策略。 一、多线程...
Linux下的多线程编程实例解析
09-14
【Linux下的多线程编程实例解析】 在计算机操作系统中，多线程编程是实现并行处理和提高系统效率的一种重要技术。Linux系统同样支持多线程编程，这使得开发者能够利用这一特性创建高效的、响应迅速的应用程序。多...
【Linux服务器Java环境搭建】010在linux中安装Redis，以及对Redis的配置与远程连接
最新发布
liuzhenhe1988的专栏
07-19 691
好久没有更新博客了，今天下了班回到家，看到电脑桌上尘封已久的《Spring Boot应用开发实战》，翻开目录想起来之前写的系列【Linux服务器Java环境搭建】还未完结，那就继续吧，今天主要是按linux服务器中安装和配置redis。本系列其他文章，请查看系列【Linux服务器Java环境搭建】
Qmi8658a姿态传感器使用心得（2）linux
Starry的博客
07-19 688
COD 原理，CTRL9，自检（详细代码示例）
Linux 权限
includemainprinf的博客
07-18 517
在Linux操作系统中，权限管理是一个至关重要的概念，它确保了系统的安全性和稳定性。同时可以在工作中，设置对象的权限，就算我们很多人使用一台服务器，我们也可以让别人看不到我们文件的内容，或者让别人无法对自己的文件进行操作！
Linux 注意事项
m0_74012211的博客
07-19 194
Linux 与 Windows 是两个相互独立的操作系统，两者有较大差距
【Linux】深入探索`cp`命令：文件复制的全面指南
lph159的博客
07-18 310
cp命令用于复制文件或目录的内容。cp [选项] 源文件 目标文件或目录使用cp命令可以在文件系统中创建新的副本，无论是单个文件还是整个目录树。接下来我们将详细介绍cp命令的各个选项及其用法。
【Linux】文件管理常用命令【超详细】
2301_82023330的博客
07-16 718
这篇博客介绍了Linux系统中的常用文件管理命令，包括`ls`、`cd`、`cp`、`mv`、`rm`和`mkdir`等。通过这些命令，用户可以高效地浏览目录、复制和移动文件、删除文件以及创建新目录。文章详细讲解了每个命令的基本用法和常见选项，并通过实例演示了这些命令在实际操作中的应用，帮助读者掌握文件管理的基本技能，提升Linux系统的使用效率。
Linux——多路复用之select
kkbca的博客
07-19 793
在前面，我们学习了五种IO模型，对IO有了基本的认识，知道了select效率很高，可以等待多个文件描述符，那他是如何等待的呢？我们又该如何使用呢？
【Linux】文件创建与写入系统调用流程摸索
07-19 180
第五行是搜索我们操作的文件名，看看在操作系统层面对文件的操作，内核里边源代码对应函数的打印的流程是否正确，因为有些函数同名函数很多，不一定是我们找到的，而且代码中函数里还有各种分支，判断等等，所以也有点点难度。第一行是打开日志输出（其实操作系统运行时日志是输出到/var/log/kern.log和/var/log/syslog里了，这也即是为什么我们老是去syslog文件搜索我们在内核源代码的打印信息）；第二行是把字符串写入到一个文件，这个文件原来是没有的，其实就是创建文件，写入文件；

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值