Question

首先：我完全是互斥/多线程编程的新手，所以对于任何错误事先抱歉...

我有一个运行多个线程的程序。线程（通常是一个 cpu core）做了很多计算和“思考”，然后有时他们决定打电话给更新某些统计信息的特定（共享）方法。统计信息更新的并发性通过使用互斥锁来管理：

stats_mutex.lock();
common_area->update_thread_stats( ... );
stats_mutex.unlock();

现在问题。在所有这些线程中，有一个特定的线程几乎需要实时优先级，因为它是唯一实际运行的线程。

“几乎实时优先”是指：

假设线程t0是“特权者”，t1 .... t15是正常的现在发生的事情是：

线程t1获取锁定。
线程t2，t3，t0调用lock（）方法并等待它成功。
线程t1调用unlock（）
线程t2，t3，t0中的一个（随机地，据我所知）成功获取锁定，其他人继续等待。

我需要的是：

线程t1获得锁定。
线程t2，t3，t0调用lock（）方法并等待它成功。
线程t1调用unlock（）
线程t0获得锁定，因为它具有特权

那么，做这件事的最佳（可能是最简单的）方法是什么？

我在想的是调用一个bool变量 “privileged_needs_lock”。

但我认为我需要另一个互斥锁来管理对这个变量的访问......我不这样做知道这是否正确...

其他信息：

我的主题使用C ++ 11（从gcc 4.6.3开始）
代码需要在Linux和Windows上运行（但目前仅在Linux上进行测试）。
锁定机制的性能不是问题（我的性能问题是在内部线程计算中，并且线程数总是很低，每个cpu核心最多一个或两个）

任何想法都表示赞赏。感谢

以下解决方案有效（三种互斥方式）：

#include <thread>
#include <iostream>
#include "unistd.h"

std::mutex M;
std::mutex N;
std::mutex L;

void lowpriolock(){
  L.lock();
  N.lock();
  M.lock();
  N.unlock();
}

void lowpriounlock(){
  M.unlock();
  L.unlock();
}

void highpriolock(){
  N.lock();
  M.lock();
  N.unlock();
}

void highpriounlock(){
  M.unlock();
}

void hpt(const char* s){
  using namespace std;
  //cout << "hpt trying to get lock here" << endl;
  highpriolock();
  cout << s << endl;
  sleep(2);
  highpriounlock();
}

void lpt(const char* s){
  using namespace std;
  //cout << "lpt trying to get lock here" << endl;
  lowpriolock();
  cout << s << endl;
  sleep(2);
  lowpriounlock();
}

int main(){
std::thread t0(lpt,"low prio t0 working here");
std::thread t1(lpt,"low prio t1 working here");
std::thread t2(hpt,"high prio t2 working here");
std::thread t3(lpt,"low prio t3 working here");
std::thread t4(lpt,"low prio t4 working here");
std::thread t5(lpt,"low prio t5 working here");
std::thread t6(lpt,"low prio t6 working here");
std::thread t7(lpt,"low prio t7 working here");
//std::cout << "All threads created" << std::endl;
t0.join();
t1.join();
t2.join();
t3.join();
t4.join();
t5.join();
t6.join();
t7.join();
return 0;
}

按照建议尝试了以下解决方案，但不工作（使用“g ++ -std = c ++ 0x -o test test.cpp -lpthread”编译）：

#include <thread>
#include <mutex>

#include "time.h"
#include "pthread.h"

std::mutex l;

void waiter(){
  l.lock();
  printf("Here i am, waiter starts\n");
  sleep(2);
  printf("Here i am, waiter ends\n");
  l.unlock();
}

void privileged(int id){
  usleep(200000);
  l.lock();
  usleep(200000);
  printf("Here i am, privileged (%d)\n",id);
  l.unlock();  
}

void normal(int id){
  usleep(200000);
  l.lock();
  usleep(200000);
  printf("Here i am, normal (%d)\n",id);
  l.unlock();    
}

int main(){
  std::thread tw(waiter);
  std::thread t1(normal,1);
  std::thread t0(privileged,0);
  std::thread t2(normal,2);

  sched_param sch;
  int policy; 

  pthread_getschedparam(t0.native_handle(), &policy, &sch);
  sch.sched_priority = -19;
  pthread_setschedparam(t0.native_handle(), SCHED_FIFO, &sch);

  pthread_getschedparam(t1.native_handle(), &policy, &sch);
  sch.sched_priority = 18;
  pthread_setschedparam(t1.native_handle(), SCHED_FIFO, &sch);

  pthread_getschedparam(t2.native_handle(), &policy, &sch);
  sch.sched_priority = 18;
  pthread_setschedparam(t2.native_handle(), SCHED_FIFO, &sch);

  tw.join();
  t1.join();
  t0.join();
  t2.join();

  return 0;  
}

Answer 1

我可以想到只使用线程原语的三种方法：

三重互斥

三个互斥锁可以在这里工作：

数据互斥（'M'）
next-to-access互斥锁（'N'）和
低优先级访问互斥锁（'L'）

访问模式是：

低优先级线程：锁定L，锁定N，锁定M，解锁N，{执行内容}，解锁M，解锁L
高优先级线程：锁定N，锁定M，解锁N，{执行内容}，解锁M

这样就可以保护对数据的访问，并且高优先级线程可以在访问它的低优先级线程之前。

Mutex，条件变量，原子标志

执行此操作的基本方法是使用条件变量和原子：

Mutex M;
Condvar C;
atomic bool hpt_waiting;

数据访问模式：

低优先级线程：锁定M，同时（hpt_waiting）在M上等待C，{do stuff}，广播C，解锁M
高优先级线程：hpt_waiting：= true，锁定M，hpt_waiting：= false，{do stuff}，广播C，解锁M

Mutex，条件变量，两个非原子标志

或者你可以使用两个非原子bool和condvar;在这种技术中，互斥锁/ condvar保护标志，数据不受互斥锁保护，而是受标志保护：

Mutex M;
Condvar C;
bool data_held，hpt_waiting;
低优先级线程：锁定M，而（hpt_waiting或data_held）等待C on M，data_held：= true，解锁M，{do stuff}，锁定M，data_held：= false，广播C，解锁中号
高优先级线程：锁定M，hpt_waiting：= true，while（data_held）等待C on M，data_held：= true，{do stuff}，锁定M，data_held：= false，hpt_waiting：= false，广播C ，解锁M

Answer 2

将请求线程放在'优先级队列'上。特权线程可以在数据空闲时首先获取数据。

一种方法是使用ConcurrentQueues [privilegeLevel]数组，一个锁和一些事件。

任何想要数据的线程都会进入锁定状态。如果数据是空闲的（布尔值），它将获取数据对象并退出锁定。如果另一个线程正在使用该数据，则请求线程将事件推送到其中一个并发队列，具体取决于其权限级别，退出锁定并等待事件。

当线程想要释放其对数据对象的所有权时，它获取锁并从最高权限端向下迭代ConcurrentQueues数组，寻找事件（即队列计数> 0）。如果它找到一个，它会发出信号并退出锁定，如果没有，它会设置'dataFree'布尔值并退出锁。

当等待事件访问数据的线程准备就绪时，它可以访问数据对象。

我觉得应该有用。请其他开发人员检查这个设计，看看你是否能想到任何比赛等？去CZ旅行后，我仍然受到“好客超载”的影响。

编辑 - 可能甚至不需要并发队列，因为它们全部显式锁定。任何旧队列都可以。

Answer 3

#include <thread>
#include <mutex>
#include <condition_variable>
#include <cassert>

class priority_mutex {
  std::condition_variable cv_;
  std::mutex gate_;
  bool locked_;
  std::thread::id pr_tid_; // priority thread
public:
  priority_mutex() : locked_(false) {}
  ~priority_mutex() { assert(!locked_); }
  priority_mutex(priority_mutex&) = delete;
  priority_mutex operator=(priority_mutex&) = delete;

  void lock(bool privileged = false) {
    const std::thread::id tid = std::this_thread::get_id();
    std::unique_lock<decltype(gate_)> lk(gate_);
    if (privileged)
      pr_tid_ = tid;
    cv_.wait(lk, [&]{
      return !locked_ && (pr_tid_ == std::thread::id() || pr_tid_ == tid);
    });
    locked_ = true;
  }

  void unlock() {
    std::lock_guard<decltype(gate_)> lk(gate_);
    if (pr_tid_ == std::this_thread::get_id())
      pr_tid_ = std::thread::id();
    locked_ = false;
    cv_.notify_all();
  }
};

注意：此priority_mutex提供了不公平的线程调度。如果特权线程经常获取锁，则其他非特权线程几乎不会被调度。

用法示例：

#include <mutex>
priority_mutex mtx;

void privileged_thread()
{
  //...
  {
    mtx.lock(true);  // acquire 'priority lock'
    std::unique_lock<decltype(mtx)> lk(mtx, std::adopt_lock);
    // update shared state, etc.
  }
  //...
}

void normal_thread()
{
  //...
  {
    std::unique_lock<decltype(mtx)> lk(mtx);  // acquire 'normal lock'
    // do something
  }
  //...
}

Answer 4

在linux上你可以查看这个man：pthread_setschedparam以及man sched_setscheduler

pthread_setschedparam（pthread_t thread，int policy， const struct sched_param * param）;

同样检查c ++ 2011： http://msdn.microsoft.com/en-us/library/system.threading.thread.priority.aspx#Y78

Answer 5

尝试以下内容。你可以让这个类成为一个线程安全的单例，你甚至可以把它变成一个函子。

#include <pthread.h>
#include <semaphore.h>
#include <map>

class ThreadPrioFun
{
    typedef std::multimap<int, sem_t*> priomap_t;
public:
    ThreadPrioFun()
    {
        pthread_mutex_init(&mtx, NULL);
    }
    ~ThreadPrioFun()
    {
        pthread_mutex_destroy(&mtx);
    }
    void fun(int prio, sem_t* pSem)
    {
        pthread_mutex_lock(&mtx);
        bool bWait = !(pm.empty());
        priomap_t::iterator it = pm.insert(std::pair<int, sem_t*>(prio, pSem) );
        pthread_mutex_unlock(&mtx);

        if( bWait ) sem_wait(pSem);

        // do the actual job
        // ....
        //

        pthread_mutex_lock(&mtx);
        // done, remove yourself
        pm.erase(it);
        if( ! pm.empty() )
        {
             // let next guy run:
            sem_post((pm.begin()->second));
        }
        pthread_mutex_unlock(&mtx);
    }
private:
    pthread_mutex_t mtx;
    priomap_t pm;
};

Answer 6

pthreads有线程优先级：

pthread_setschedprio( (pthread_t*)(&mThreadId), wpri );

如果多个线程正在等待锁定，则调度程序将首先唤醒优先级最高的线程。

Answer 7

由于线程优先级对您不起作用：

创建2个互斥锁，常规锁定和优先级锁定。

常规线程必须先锁定普通锁，然后再锁定优先级。优先级线程只需锁定优先级锁：

Mutex mLock;
Mutex mPriLock;


doNormal()
{
   mLock.lock();
   pthread_yield();
   doPriority();
   mLock.unlock();
}

doPriority()
{
   mPriLock.lock();
   doStuff();
   mPriLock.unlock();
}

Answer 8

略微修改 ecatmur 回答，添加第4个互斥锁以同时处理多个高优先级线程（请注意，在原始问题中不需要）：

#include <thread> #include <iostream> #include "unistd.h" std::mutex M; //data access mutex std::mutex N; // 'next to access' mutex std::mutex L; //low priority access mutex std::mutex H; //hptwaiting int access mutex int hptwaiting=0; void lowpriolock(){ L.lock(); while(hptwaiting>0){ N.lock(); N.unlock(); } N.lock(); M.lock(); N.unlock(); } void lowpriounlock(){ M.unlock(); L.unlock(); } void highpriolock(){ H.lock(); hptwaiting++; H.unlock(); N.lock(); M.lock(); N.unlock(); } void highpriounlock(){ M.unlock(); H.lock(); hptwaiting--; H.unlock(); } void hpt(const char* s){ using namespace std; //cout << "hpt trying to get lock here" << endl; highpriolock(); cout << s << endl; usleep(30000); highpriounlock(); } void lpt(const char* s){ using namespace std; //cout << "lpt trying to get lock here" << endl; lowpriolock(); cout << s << endl; usleep(30000); lowpriounlock(); } int main(){ std::thread t0(lpt,"low prio t0 working here"); std::thread t1(lpt,"low prio t1 working here"); std::thread t2(hpt,"high prio t2 working here"); std::thread t3(lpt,"low prio t3 working here"); std::thread t4(lpt,"low prio t4 working here"); std::thread t5(lpt,"low prio t5 working here"); std::thread t6(hpt,"high prio t6 working here"); std::thread t7(lpt,"low prio t7 working here"); std::thread t8(hpt,"high prio t8 working here"); std::thread t9(lpt,"low prio t9 working here"); std::thread t10(lpt,"low prio t10 working here"); std::thread t11(lpt,"low prio t11 working here"); std::thread t12(hpt,"high prio t12 working here"); std::thread t13(lpt,"low prio t13 working here"); //std::cout << "All threads created" << std::endl; t0.join(); t1.join(); t2.join(); t3.join(); t4.join(); t5.join(); t6.join(); t7.join(); t8.join(); t9.join(); t10.join(); t11.join(); t12.join(); t13.join(); return 0; }

你怎么看？好吗？确实，信号量可以更好地处理这种事情，但互斥量对我来说更容易管理。

如何在互斥锁定中优先使用特权线程？

8 个答案:

三重互斥

Mutex，条件变量，原子标志

Mutex，条件变量，两个非原子标志