2

我已经进行了一些谷歌搜索，并看到了有关此问题的堆栈溢出的类似问题，但我无法理解处理它的原因/解决方案。鉴于在 ThreadPool.hpp 中声明的以下类，我收到以下 2 个错误：

错误 1 ​​错误 C2248: 'std::mutex::mutex' : 无法访问在类 'std::mutex' c:\users\jesse\documents\school\summer term 2012\concurrent processing\project 2\ultra_grep 中声明的私有成员v2\ultra_grep\threadpool.hpp 39 1 ultra_grep2

错误 2 错误 C2248：“std::condition_variable::condition_variable”：无法访问在类“std::condition_variable”c:\users\jesse\documents\school\summer term 2012\concurrent processing\project 2\ultra_grep 中声明的私有成员v2\ultra_grep\threadpool.hpp 39 1 ultra_grep2

class ThreadPool
{
private:
std::queue<std::string> _consoleTasks;
std::queue<std::tr2::sys::path> _tasks;
std::map<std::string, std::vector<GrepMatch>> _grepMatches;
int _nThreads, _fileMatches, _totalMatches, _workingThreads;
std::vector<thread> _threads;
Arguments _args;
std::mutex _taskMutex, _wakeMutex, _consoleMutex, _threadCountMutex;
std::condition_variable _wakeCondition;

public:
ThreadPool( int threads, Arguments args );
~ThreadPool() {};
void GrepFunc();
void ConsoleFunc();
void SearchFile( std::string );
void SearchFileVerbose( std::string );
void DisplayGrepResults();

queue<std::tr2::sys::path> Tasks() { return _tasks; }

};

以及在 ThreadPool.cpp 中实现的代码：

#include "ThreadPool.hpp"

using namespace std;
namespace fs = std::tr2::sys;

ThreadPool::ThreadPool( int threads, Arguments args )
: _nThreads( threads ), _args( args ), _fileMatches( 0 ), _totalMatches( 0 ), _workingThreads( 0 )
{

for( int i = 0; i < _nThreads; ++i )
{
        _threads.push_back( thread( &ThreadPool::GrepFunc, this ) );
        _tasks.push( args.root() );
        ++_workingThreads;
        _wakeCondition.notify_one();
}

for( auto& t : _threads )
{
    t.join();
}

DisplayGrepResults();
}

void ThreadPool::GrepFunc()
{
// implement a barrier()

while( !_workingThreads )
{
    { unique_lock<mutex> lk( _wakeMutex );
    _wakeCondition.wait( lk ); }

    while( !_tasks.empty() )
    {
        fs::path task;
        bool gotTask = false;
        {
            lock_guard<mutex> tl( _taskMutex );
            if( !_tasks.empty() )
            {
                { lock_guard<mutex> tc( _threadCountMutex );
                ++_workingThreads; }
                task = _tasks.front();
                _tasks.pop();
                gotTask = true;
            }
        }

        if( gotTask )
        {
            if( fs::is_directory( task ) )
            {
                for( fs::directory_iterator dirIter( task ), endIter; dirIter != endIter; ++dirIter )
                {
                    if( fs::is_directory( dirIter->path() ) )
                    {
                        { lock_guard<mutex> tl( _taskMutex );
                        _tasks.push( dirIter->path() ); }
                        _wakeCondition.notify_one();
                    }
                    else
                    {
                        for( auto& e : _args.extensions() )
                        {
                            if( !dirIter->path().extension().compare( e ) )
                            {
                                { lock_guard<mutex> tl( _taskMutex );
                                _tasks.push( dirIter->path() ); }
                                _wakeCondition.notify_one();
                                //SearchFile( dirIter->path() );
                            }
                        }
                    }
                }
            }
            else
            {
                for( auto& e : _args.extensions() )
                {
                    if( !task.extension().compare( e ) )
                    {
                        if( _args.is_verbose() )
                            SearchFile( task );
                        else
                            SearchFileVerbose( task );
                    }
                }
            }

            { lock_guard<mutex> tc( _threadCountMutex) ;
            --_workingThreads; }
        }
    }
}
}

void ThreadPool::SearchFileVerbose( string path )
{
fstream file;
file.open( path );

if( !file )
{
    // error handling
}
else
{
    { 
        lock_guard<mutex> cm( _consoleMutex );
        cout << "\nGrepping: " << path << endl;

        int lineNumber = 1;
        string line;
        vector<GrepMatch> matches;
        while( getline( file, line ) )
        {
            int lineMatches = 0;
            sregex_token_iterator end;
            for (sregex_token_iterator i(line.cbegin(), line.cend(), _args.regular_expression() );
                i != end;
                ++i)
            {
                ++lineMatches;
            }

            if( lineMatches > 0 )
            {
                GrepMatch match = GrepMatch( lineNumber, lineMatches, line );
                matches.push_back( match );
                cout << "Matched " << lineMatches << ": " << path << " [" << lineNumber << "] " << line << endl; 
            }

            ++lineNumber;
        }

        if( !matches.empty() )
        {
            _grepMatches[ path ] = matches;
        }
    }
}
}

我在互斥锁和 condition_variable 上都收到错误，说它们无法访问在类中声明的私有成员。据我了解，这是指复制构造函数？虽然我不明白为什么这会起作用，因为我看不到我要在哪里制作副本，因为它们只是班级的私人成员。

根据最初的评论，我只实例化了一个 ThreadPool 实例，它不会被复制到任何地方。我唯一一次尝试触摸互斥锁是在我的班级的 .cpp 实现中。

谁能帮助我更好地理解为什么会这样？

对于那些感兴趣的是编译器输出：

1>------ Build started: Project: ultra_grep2, Configuration: Debug Win32 ------
1>  ultra_grep_main.cpp
1>  Unknown compiler version - please run the configure tests and report the results
1>c:\users\jesse\documents\school\summer semester 2012\concurrent processing\project 2\ultra_grep v2\ultra_grep\threadpool.hpp(39): error C2248: 'std::mutex::mutex' : cannot access private member declared in class 'std::mutex'
1>          c:\program files (x86)\microsoft visual studio 11.0\vc\include\mutex(116) : see declaration of 'std::mutex::mutex'
1>          c:\program files (x86)\microsoft visual studio 11.0\vc\include\mutex(107) : see declaration of 'std::mutex'
1>          This diagnostic occurred in the compiler generated function 'ThreadPool::ThreadPool(const ThreadPool &)'
1>          c:\program files (x86)\microsoft visual studio 11.0\vc\include\mutex(116) : see declaration of 'std::mutex::mutex'
1>          c:\program files (x86)\microsoft visual studio 11.0\vc\include\mutex(107) : see declaration of 'std::mutex'
1>          c:\program files (x86)\microsoft visual studio 11.0\vc\include\mutex(116) : see declaration of 'std::mutex::mutex'
1>          c:\program files (x86)\microsoft visual studio 11.0\vc\include\mutex(107) : see declaration of 'std::mutex'
1>          c:\program files (x86)\microsoft visual studio 11.0\vc\include\mutex(116) : see declaration of 'std::mutex::mutex'
1>          c:\program files (x86)\microsoft visual studio 11.0\vc\include\mutex(107) : see declaration of 'std::mutex'
1>c:\users\jesse\documents\school\summer semester 2012\concurrent processing\project 2\ultra_grep v2\ultra_grep\threadpool.hpp(39): error C2248: 'std::condition_variable::condition_variable' : cannot access private member declared in class 'std::condition_variable'
1>          c:\program files (x86)\microsoft visual studio 11.0\vc\include\condition_variable(45) : see declaration of 'std::condition_variable::condition_variable'
1>          c:\program files (x86)\microsoft visual studio 11.0\vc\include\condition_variable(30) : see declaration of 'std::condition_variable'
1>          This diagnostic occurred in the compiler generated function 'ThreadPool::ThreadPool(const ThreadPool &)'
1>  ThreadPool.cpp
1>  Generating Code...
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========
4

2 回答 2

7

问题出在你的想法上；编译器生成的复制构造函数和赋值运算符失败，因为 mutex 和 condition_variable 不可复制。在许多不容易看到的情况下，编译器仍然会为这两种情况生成代码，即使您不是故意调用它们。根据我的经验，此错误通常是由于尝试将类型与标准库容器一起使用而引起的。

即使您没有遇到此问题，您也应该添加一个空的私有复制构造函数和赋值运算符；我认为尝试复制线程池是不可取的。

于 2012-08-17T00:44:18.680 回答
3

错误在某处：

1> ultra_grep_main.cpp

使用的复制构造函数的ThreadPool位置：

此诊断发生在编译器生成的函数“ThreadPool::ThreadPool(const ThreadPool &)”中

我实际上很惊讶编译器没有指向源文件中隐式生成复制构造函数的哪一行。

在评论中，您询问复制构造函数的外观。一个更好的问题是复制一个对象是否有意义，ThreadPool答案是一般来说没有意义。要改进错误消息，您可以将复制构造函数标记为deleted，这样（希望）编译器将生成更好的错误报告，说明需要复制的位置：

class ThreadPool {
   ThreadPool( ThreadPool const & ) = delete;
// ...
};

如果您的编译器不支持此 C++11 功能，则另一种方法是声明复制构造函数但不定义它。这将在使用复制构造函数的地方触发访问错误。

于 2012-08-17T12:51:55.370 回答