5

我正在学习编写多线程应用程序。因此，无论何时我希望我的线程访问即使是简单的共享资源，我都会遇到麻烦，尽管使用互斥锁。

例如，考虑以下代码：

using namespace std;
mutex mu;
std::vector<string> ob;

void addSomeAValues(){
    mu.lock();    
    for(int a=0; a<10; a++){
        ob.push_back("A" + std::to_string(a));
        usleep(300);    
    }
    mu.unlock();
}

void addSomeBValues(){    
    mu.lock();    
    for(int b=0; b<10; b++){            
        ob.push_back("B" + std::to_string(b));        
        usleep(300);    
    }   
    mu.unlock();
}

int main() {    
    std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();        
    thread t0(addSomeAValues);        
    thread t1(addSomeBValues);    
    std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();

    t0.join();
    t1.join();

    //Display the results
    cout << "Code Run Complete; results: \n";    
    for(auto k : ob){
        cout << k <<endl;
    }
    //Code running complete, report the time it took
    typedef std::chrono::duration<int,std::milli> millisecs_t;
    millisecs_t duration(std::chrono::duration_cast<millisecs_t>(end-start));
    std::cout << duration.count() << " milliseconds.\n";
    return 0;
}

当我运行该程序时，它的行为不可预测。有时，将值 A0-9 和 B0-9 打印到控制台没有问题，有时会出现崩溃报告的分段错误，有时会显示 A0-3 和 B0-5。

如果我缺少核心同步问题，请帮助

编辑：经过大量有用的反馈后，我将代码更改为

#include <iostream>
#include <string>
#include <vector>
#include <mutex>
#include <unistd.h>
#include <thread>
#include <chrono>

using namespace std;
mutex mu;
std::vector<string> ob;

void addSomeAValues(){

for(int a=0; a<10; a++){
    mu.lock();
        ob.push_back("A" + std::to_string(a));
    mu.unlock();
    usleep(300);
}
}

void addSomeBValues(){
for(int b=0; b<10; b++){
    mu.lock();
        ob.push_back("B" + std::to_string(b));
    mu.unlock();

    usleep(300);
}
}

int main() {

std::chrono::steady_clock::time_point    start = std::chrono::steady_clock::now() ;

    thread t0(addSomeAValues);
    thread t1(addSomeBValues);

std::chrono::steady_clock::time_point       end = std::chrono::steady_clock::now() ;

t0.join();
t1.join();

//Display the results
cout << "Code Run Complete; results: \n";
for(auto k : ob){
    cout << k <<endl;
}
//Code running complete, report the time it took
    typedef std::chrono::duration<int,std::milli> millisecs_t ;
    millisecs_t duration( std::chrono::duration_cast<millisecs_t>(end-start) ) ;
    std::cout << duration.count() << " milliseconds.\n" ;
return 0;

}

但是我有时会得到以下输出：

*** Error in `/home/soliduscode/eclipse_workspace/CppExperiment/Debug/CppExperiment':
double free or corruption (fasttop): 0x00007f19fc000920 ***
======= Backtrace: =========
/lib/x86_64-linux-gnu/libc.so.6(+0x80a46)[0x7f1a0687da46]
/home/soliduscode/eclipse_workspace/CppExperiment/Debug/CppExperiment[0x402dd4]
/home/soliduscode/eclipse_workspace/CppExperiment/Debug/CppExperiment[0x402930]
/home/soliduscode/eclipse_workspace/CppExperiment/Debug/CppExperiment[0x402a8d]
/home/soliduscode/eclipse_workspace/CppExperiment/Debug/CppExperiment[0x402637
/home/soliduscode/eclipse_workspace/CppExperiment/Debug/CppExperiment[0x402278]
/home/soliduscode/eclipse_workspace/CppExperiment/Debug/CppExperiment[0x4019cf]
/home/soliduscode/eclipse_workspace/CppExperiment/Debug/CppExperiment[0x4041e3]
/home/soliduscode/eclipse_workspace/CppExperiment/Debug/CppExperiment[0x404133]
/home/soliduscode/eclipse_workspace/CppExperiment/Debug/CppExperiment[0x404088]
/usr/lib/x86_64-linux-gnu/libstdc++.so.6(+0xb29f0)[0x7f1a06e8d9f0]
/lib/x86_64-linux-gnu/libpthread.so.0(+0x7f8e)[0x7f1a060c6f8e]
/lib/x86_64-linux-gnu/libc.so.6(clone+0x6d)[0x7f1a068f6e1d]

更新与解决方案

对于我遇到的问题（即：程序的不可预测的执行以及间歇性的腐败投诉转储），所有问题都通过将 -lpthread 作为我的 Eclipse 构建的一部分（在项目设置下）来解决。

我正在使用 C++11。奇怪的是，至少对我来说，程序编译时没有发出我尚未与 pthread 链接的投诉。

因此，对于使用 C++11、std::thread 和 linux 的任何人，请确保链接到 pthread，否则您的程序运行时将非常不可预测，并且存在错误。

4

2 回答 2

3

如果您要使用线程，我建议您至少做一些不同的工作。

现在，一个线程获取互斥锁，完成它要做的所有事情（包括休眠 3000 微秒），然后退出。然后另一个线程基本上做同样的事情。在这种情况下，线程基本上没有完成任何积极的事情和相当数量的消极事情（同步代码等）。

您当前的代码在异常方面几乎是不安全的——如果要在您的线程函数之一中引发异常，则即使该线程无法再执行，互斥锁也不会被解锁。

最后，现在，您要公开一个互斥锁，并将其留给访问相关资源的所有代码以正确使用互斥锁。我更喜欢集中互斥锁，以便它的异常安全，并且大多数代码可以完全忽略它。

// use std::lock_guard, if available.
class lock { 
    mutex &m
public:
    lock(mutex &m) : m(m) { m.lock(); }
    ~lock() { m.unlock(); }
};

class synched_vec { 
    mutex m;
    std::vector<string> data;
public:
    void push_back(std::string const &s) { 
        lock l(m);
        data.push_back(s);
    }
} ob;

void addSomeAValues(){
    for(int a=0; a<10; a++){
        ob.push_back("A" + std::to_string(a));
        usleep(300);    
    }
}

这也意味着，如果（例如）您决定将来使用无锁（或最小锁定）结构，您应该只需要修改synched_vec，而不是使用它的所有其余代码。同样，通过将所有互斥体处理保存在一个地方，更容易获得正确的代码，并且如果您确实发现了错误，则更容易确保您已修复它（而不是查看所有客户端代码）。

于 2013-05-29T00:04:03.420 回答
0

问题中的代码运行时没有任何分段错误（添加标头并将睡眠替换为我的系统的睡眠）。

但是，代码有两个问题，可能会导致意外结果：

  • 每个线程在其完整执行期间锁定互斥锁。这可以防止其他线程运行。两个线程没有并行运行！在您的情况下，您应该只在访问向量时锁定。

  • 您的结束时间点是在创建线程之后而不是在它们完成执行之后。当它们都被join编辑时，两个线程都已完成。

使用标头、chrono-sleep 和修复了两个错误的可编译代码：

#include <mutex>
#include <string>
#include <vector>
#include <thread>
#include <iostream>


std::mutex mu;
std::vector<std::string> ob;

void addSomeAValues(){
    for(int a=0; a<10; a++){
        mu.lock();
        ob.push_back("A" + std::to_string(a));
        mu.unlock();
        std::this_thread::sleep_for(std::chrono::milliseconds(300));
    }
}

void addSomeBValues(){
    for(int b=0; b<10; b++){            
        mu.lock();
        ob.push_back("B" + std::to_string(b));        
        mu.unlock();
        std::this_thread::sleep_for(std::chrono::milliseconds(300));
    }
}

int main() {    
    std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();        
    std::thread t0(addSomeAValues);        
    std::thread t1(addSomeBValues);    

    t0.join();
    t1.join();
    std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();

    //Display the results
    std::cout << "Code Run Complete; results: \n";    
    for(auto k : ob){
        std::cout << k << std::endl;
    }
    //Code running complete, report the time it took
    typedef std::chrono::duration<int,std::milli> millisecs_t;
    millisecs_t duration(std::chrono::duration_cast<millisecs_t>(end-start));
    std::cout << duration.count() << " milliseconds.\n";

    return 0;
}
于 2013-05-28T23:14:29.657 回答