问题描述
场景
我创建了三个线程，固定到单核，并在SCHED_FIFO下具有以下优先级：
- 主要：
sched_priority = 99 - 线程_1 ：
sched_priority = 97 - 线程_2 ：
sched_priority = 98
工作线程（thread_1，thread_2）计算出50,000,000个素数（〜10s）之和。它们直到最后（打印输出）才阻塞或执行系统调用。
主线程睡眠一秒钟，然后检查工作线程的承诺，看是否完成。
预期行为
主线程处于最高优先级。根据{{3}}：
一个SCHED_FIFO线程运行直到被I / O阻塞 请求，它被更高优先级的线程抢占，或者它调用 sched_yield（2）。
因此，Main应在第二个间隔中打印（checking ...）。它是最高优先级，因此应抢先运行。当它休眠时，它正在阻塞，因此其他线程应该运行。
-
thread_1：首先完成，因为 main 不忙时它具有优先权。 -
thread_2：最后完成，只有在thread_1完成后才开始。
实际行为
线程以与预期相反的顺序完成：
Thread 1 summed 3001134 primes at priority level: 97
Thread 2 summed 3001134 primes at priority level: 98
Main: Checking ...
Main: Task 1 has finished!
Main: Task 2 has finished!
Main: Exiting at priority level: 99
颠倒优先顺序，使 main 具有最低的产生相同的结果。
复制
- 使用
g++ -o <exec_name> <file_name>.cpp -pthread编译程序 - 运行：
sudo taskset --cpu-list 1 ./<exec_name>
我的内核是5.4.0-42-generic，我的发行版（如果有）：Ubuntu 18.04.5 LTS。我未安装了preempt-rt补丁。
类似问题
-
我发现了sched个问题，似乎可以描述相同的问题，但没有给出答案。
-
我还读过this，说我的高优先级线程可以被抢占，但是我不关心这一点，只要它不能被同一进程中产生的其他线程抢占即可。我没有足够的信息关于这种情况是否可能发生。
示例代码
#include <thread>
#include <mutex>
#include <iostream>
#include <chrono>
#include <cstring>
#include <future>
#include <pthread.h>
#include <math.h>
// IO Access mutex
std::mutex g_mutex_io;
// computation function (busy work)
static bool isPrime (unsigned int value)
{
unsigned int i,root;
if (value == 1) return false;
if (value == 2) return true;
if ((value % 2) == 0) return false;
root = (int)(1.0 + sqrt(value));
for (i = 3; (i < root) && (value % i != 0); i += 2);
return (i < root ? false : true);
}
// Thread function
void foo (unsigned int id,unsigned int count)
{
sched_param sch;
int policy,sum = 0;
// Get information about thread
pthread_getschedparam(pthread_self(),&policy,&sch);
// Compute primes
for (unsigned int i = 1; i < count; ++i) {
sum += (isPrime(i) ? 1 : 0);
}
// Print
{
std::lock_guard<std::mutex> lock(g_mutex_io);
std::cout << "Thread " << id << " summed " << sum << " primes"
<< " at priority level: " << sch.sched_priority << std::endl;
}
}
int main ()
{
sched_param sch;
int policy;
// Declare and init task objects
std::packaged_task<void(unsigned int,unsigned int)> task_1(foo);
std::packaged_task<void(unsigned int,unsigned int)> task_2(foo);
// Get the futures
auto task_fut_1 = task_1.get_future();
auto task_fut_2 = task_2.get_future();
// Declare and init thread objects
std::thread thread_1(std::move(task_1),1,50000000);
std::thread thread_2(std::move(task_2),2,50000000);
// Set first thread policy
pthread_getschedparam(thread_1.native_handle(),&sch);
sch.sched_priority = 97;
if (pthread_setschedparam(thread_1.native_handle(),SCHED_FIFO,&sch)) {
std::cerr << "pthread_setschedparam: " << std::strerror(errno)
<< std::endl;
return -1;
}
// Set second thread policy
pthread_getschedparam(thread_2.native_handle(),&sch);
sch.sched_priority = 98;
if (pthread_setschedparam(thread_2.native_handle(),&sch)) {
std::cerr << "pthread_setschedparam: " << std::strerror(errno)
<< std::endl;
return -1;
}
// Set main process thread priority
pthread_getschedparam(pthread_self(),&sch);
sch.sched_priority = 99;
if (pthread_setschedparam(pthread_self(),&sch)) {
std::cerr << "pthread_setschedparam: " << std::strerror(errno)
<< std::endl;
return -1;
}
// Detach these threads
thread_1.detach(); thread_2.detach();
// Check their status with a timeout
for (int finished = 0; finished < 2; ) {
std::this_thread::sleep_for(std::chrono::seconds(1));
{
std::lock_guard<std::mutex> lock(g_mutex_io);
std::cout << "Main: Checking ..." << std::endl;
}
if (task_fut_1.wait_for(std::chrono::seconds(0)) == std::future_status::ready) {
{
std::lock_guard<std::mutex> lock(g_mutex_io);
std::cout << "Main: Task 1 has finished!" << std::endl;
}
finished++;
}
if (task_fut_2.wait_for(std::chrono::seconds(0)) == std::future_status::ready) {
{
std::lock_guard<std::mutex> lock(g_mutex_io);
std::cout << "Main: Task 2 has finished!" << std::endl;
}
finished++;
}
}
pthread_getschedparam(pthread_self(),&sch);
std::cout << "Main: Exiting at priority level: " << sch.sched_priority << std::endl;
return 0;
}
实验
使用两个内核sudo taskset --cpu-list 1,2运行该程序会导致以下异常输出：
Thread 2 computed 3001134 primes at priority level: 98
Thread 1 computed 3001134 primes at priority level: 0
Main: Checking ...
Main: Task 1 has finished!
Main: Task 2 has finished!
Main: Exiting at priority level: 99
thread_1的优先级为零。
如果我将其扩展为包括三个核心sudo taskset --cpu-list 1,3，那么我将获得我希望在单核上运行的行为：
Main: Checking ...
Main: Checking ...
Main: Checking ...
Main: Checking ...
Main: Checking ...
Main: Checking ...
Main: Checking ...
Main: Checking ...
Main: Checking ...
Main: Checking ...
Main: Checking ...
Main: Checking ...
Main: Checking ...
Main: Checking ...
Main: Checking ...
Main: Checking ...
Main: Checking ...
Thread 2 computed 3001134 primes at priority level: 98
Thread 1 computed 3001134 primes at priority level: 0
Main: Checking ...
Main: Task 1 has finished!
Main: Task 2 has finished!
Main: Exiting at priority level: 99
重新排列优先级的配置顺序，以便首先完成主线程，而在原始方案中不会更改输出
解决方法
启动两个线程时
// Declare and init thread objects
std::thread thread_1(std::move(task_1),1,50000000);
std::thread thread_2(std::move(task_2),2,50000000);
他们可能（！）立即运行并获取计划参数
// Get information about thread
pthread_getschedparam(pthread_self(),&policy,&sch);
甚至在将pthread_setschedparam()设置为另一个值之前。
如果两个线程都已相应安排，则输出甚至可能显示0和0。
子线程可以在主线程设置优先级之后进行调度（！）。然后，您将获得预期的输出。但是任何结果都是可能的。
当将pthread_getschedparam()移动到线程末尾之前时，您更有可能获得97和98的预期输出。但是即使那样，两个线程也可能一直运行到末尾，甚至在按计划安排主线程设置优先级。