Question

我有一个程序将10个线程推入一个向量，每个都应该在完成之前打印出一个字符5次（第一个线程为'A'，第二个线程为'B'等）。我可以让它们一次运行（使用detach（））或让它们一次运行一个（使用join（））。现在我想使用Mutex将允许打印的线程数限制为2.我已经能够声明互斥锁并将锁定到位，但我不确定如何应用这样的限制。任何人对如何进行有任何想法？

deque<int> q ;
mutex print_mutex ;
mutex queue_mutex ;
condition_variable queue_cond ;

void begin(int num) {
    unique_lock<mutex> ul {queue_mutex};
    q.emplace_back(num);
    queue_cond.wait(ul,[num]{
        return q.front() == num; });
    q.pop_front();
    cout << num << " leaves begin " << endl ;
}

void end ( int num ) {
    lock_guard<mutex>lg{queue_mutex};
    queue_cond.notify_all();
    cout << num << " has ended " << endl ;
}

void run(int num, char ch) {
    begin(num);
    for (int i = 0; i < 5; ++i) {
        {
            lock_guard<mutex> lg { print_mutex };
            cout << ch << endl << flush ;
        }
        sleep_for(milliseconds(250));
    }
    end(num);
}

int main() {
    vector<thread>threads {};
    for (int i = 0; i < 10; ++i) {
        threads.push_back(thread{run,i,static_cast<char>(65+i)});
        threads.at(i).join();
    }
}

Answer 1

您已经为全局deque<int> q的线程设置了一个FIFO。所以，让我们使用它。

目前，您正在尝试限制执行，直到当前线程位于前端。虽然有一个错误，因为begin会立即从双端队列中弹出该线程。调用end时最好删除该值。这是改变的，首先：

void end(int num)
{
    {
        lock_guard<mutex>lg{queue_mutex};
        cout << num << " has ended " << endl ;
        q.erase(find(q.begin(), q.end(), num));
    }
    queue_cond.notify_all();
}

这会使用std::find中的<algorithm>来删除特定值。您可以使用pop_front，但我们即将更改该逻辑，因此这更通用。另请注意，在通知时不需要锁定条件变量。

因此，将begin中的逻辑扩展到前两个位置并不是一件容易的事。这里：

void begin(int num)
{
    unique_lock<mutex> ul {queue_mutex};
    q.emplace_back(num);
    queue_cond.wait(ul,[num]{
        auto end = q.begin() + std::min(2, static_cast<int>(q.size()));
        return find(q.begin(), end, num) != end;
        });
    cout << num << " leaves begin " << endl ;
}

您可以将2更改为您想要的任何内容，允许通过多个线程。在某些时候，您可能会放弃这种方法并使用更简单的方法，如单个计数器变量，然后依靠线程调度程序来管理唤醒哪个线程，而不是强制它们进入FIFO。这样您就可以切换到使用notify_one唤醒单个线程并减少切换开销。

无论如何，最后要做的是从线程生成循环中删除join。现在，并发由begin和end管理。所以你会这样做：

for (int i = 0; i < 10; ++i) {
    threads.push_back( thread{run, i, 'A'+i} );
}
for (auto & t : threads) t.join();

使用互斥锁将一次运行的线程数限制为2

1 个答案: