自学教程：C++ workerThread函数代码示例

void Filter::use(        Filter::SharedDataLocker *locker,        const std::function<void ()> &cb,        const std::function<void ()> &rs){    if ( !workerThread() ){        cb();        rs();    } else if ( locker && locker->m_allLocked ){        workerThread()->postWork(cb, rs);    }    delete locker;}

Database::Database( const QString& dbname, QObject* parent )    : QObject( parent )    , m_ready( false )    , m_impl( new DatabaseImpl( dbname ) )    , m_workerRW( new DatabaseWorkerThread( this, true ) )    , m_idWorker( new IdThreadWorker( this ) ){    s_instance = this;    if ( MAX_WORKER_THREADS < DEFAULT_WORKER_THREADS )        m_maxConcurrentThreads = MAX_WORKER_THREADS;    else        m_maxConcurrentThreads = qBound( DEFAULT_WORKER_THREADS, QThread::idealThreadCount(), MAX_WORKER_THREADS );    tDebug() << Q_FUNC_INFO << "Using" << m_maxConcurrentThreads << "database worker threads";    connect( m_impl, SIGNAL( indexReady() ), SIGNAL( indexReady() ) );    connect( m_impl, SIGNAL( indexReady() ), SIGNAL( ready() ) );    connect( m_impl, SIGNAL( indexReady() ), SLOT( setIsReadyTrue() ) );    Q_ASSERT( m_workerRW );    m_workerRW.data()->start();    while ( m_workerThreads.count() < m_maxConcurrentThreads )    {        QPointer< DatabaseWorkerThread > workerThread( new DatabaseWorkerThread( this, false ) );        Q_ASSERT( workerThread );        workerThread.data()->start();        m_workerThreads << workerThread;    }    m_idWorker->start();}

 void* OperationQueue::Impl::onWorkerThread(void* data) {     auto impl = (OperationQueue::Impl*)data;     impl->workerThread();     impl->release();     return nullptr; }

void WebSharedWorkerImpl::connect(WebMessagePortChannel* webChannel, ConnectListener* listener){    workerThread()->runLoop().postTask(        createCallbackTask(&connectTask, adoptPtr(webChannel)));    if (listener)        listener->connected();}

int main(int argc, char **argv){    ros::init(argc, argv, "move_controller_node");    move_controller = new vigir_ocs::PSMoveTemplateController();    boost::thread workerThread(workerFunc);    while(ros::ok())    {        //hotkey_relay.onUpdate();        ros::spinOnce();        usleep(3000);    }    io_mutex.lock();    ros_down = true;    io_mutex.unlock();    workerThread.join();    delete move_controller;    return 0;}

int main(int argc, char **argv){    ros::init(argc, argv, "image_raw");    ros::NodeHandle n;    image_transport::Publisher image_pub;    image_transport::ImageTransport it(n);    image_pub = it.advertise("image_raw", 1);    sensor_msgs::Image img_;    ros::Rate loop_rate(10);    PixyCam cam;    boost::thread workerThread(&PixyCam::run, &cam);//    cam.run();    int count = 0;    while (ros::ok()){        cv::Mat frame = cam.getImage();        fillImage(img_, "bgr8", frame.rows, frame.cols, frame.channels() * frame.cols, frame.data);        image_pub.publish(img_);        ros::spinOnce();        loop_rate.sleep();        ++count;    }    return 0;}

void WebSharedWorkerImpl::onScriptLoaderFinished(){    ASSERT(m_loadingDocument);    ASSERT(m_mainScriptLoader);    if (m_askedToTerminate)        return;    if (m_mainScriptLoader->failed()) {        m_mainScriptLoader->cancel();        m_client->workerScriptLoadFailed();        // The SharedWorker was unable to load the initial script, so        // shut it down right here.        delete this;        return;    }    Document* document = m_mainFrame->frame()->document();    WorkerThreadStartMode startMode = DontPauseWorkerGlobalScopeOnStart;    if (InspectorInstrumentation::shouldPauseDedicatedWorkerOnStart(document))        startMode = PauseWorkerGlobalScopeOnStart;    // FIXME: this document's origin is pristine and without any extra privileges. (crbug.com/254993)    SecurityOrigin* starterOrigin = document->securityOrigin();    OwnPtrWillBeRawPtr<WorkerClients> workerClients = WorkerClients::create();    provideLocalFileSystemToWorker(workerClients.get(), LocalFileSystemClient::create());    WebSecurityOrigin webSecurityOrigin(m_loadingDocument->securityOrigin());    provideContentSettingsClientToWorker(workerClients.get(), adoptPtr(m_client->createWorkerContentSettingsClientProxy(webSecurityOrigin)));    RefPtrWillBeRawPtr<ContentSecurityPolicy> contentSecurityPolicy = m_mainScriptLoader->releaseContentSecurityPolicy();    OwnPtr<WorkerThreadStartupData> startupData = WorkerThreadStartupData::create(        m_url,        m_loadingDocument->userAgent(),        m_mainScriptLoader->script(),        nullptr,        startMode,        contentSecurityPolicy ? contentSecurityPolicy->headers() : nullptr,        starterOrigin,        workerClients.release());    m_loaderProxy = WorkerLoaderProxy::create(this);    setWorkerThread(SharedWorkerThread::create(m_name, m_loaderProxy, *this));    InspectorInstrumentation::scriptImported(m_loadingDocument.get(), m_mainScriptLoader->identifier(), m_mainScriptLoader->script());    m_mainScriptLoader.clear();    workerThread()->start(startupData.release());    m_workerInspectorProxy->workerThreadCreated(m_loadingDocument.get(), workerThread(), m_url);    m_client->workerScriptLoaded();}

void DiskLocation::fetchItems(QDir::Filter dirFilter, bool recursive){    DirListWorker *dlw  = new DirListWorker(m_info->absoluteFilePath(), dirFilter, recursive);    connect(dlw,  SIGNAL(itemsAdded(DirItemInfoList)),            this, SIGNAL(itemsAdded(DirItemInfoList)));    connect(dlw,  SIGNAL(workerFinished()),            this, SLOT(onItemsFetched()));    workerThread()->addRequest(dlw);}

int main(int argc, char* argv[])  {      std::cout << "main: startup" << std::endl;      Worker w = Worker();    boost::thread workerThread(w);      std::cout << "main: waiting for thread" << std::endl;      workerThread.join();      std::cout << "main: done" << std::endl;      return 0;  }

void WebWorkerImpl::startWorkerContext(const WebURL& scriptUrl,                                       const WebString& userAgent,                                       const WebString& sourceCode){    initializeLoader(scriptUrl);    setWorkerThread(DedicatedWorkerThread::create(scriptUrl, userAgent,                                                  sourceCode, *this, *this));    // Worker initialization means a pending activity.    reportPendingActivity(true);    workerThread()->start();}

//----------------------------------------------------------------------------------------//Command worker thread control//----------------------------------------------------------------------------------------void DeviceContext::StartCommandWorkerThread(size_t deviceIndex, volatile ReferenceCounterType& remainingThreadCount, volatile ReferenceCounterType& suspendedThreadCount, std::mutex& commandMutex, std::condition_variable& commandSent, std::condition_variable& commandProcessed, IExecutionSuspendManager* asuspendManager, const DeviceContextCommand& command){	std::unique_lock<std::mutex> lock(commandMutex);	if(!commandWorkerThreadActive)	{		commandWorkerThreadActive = true;		std::thread workerThread(std::bind(std::mem_fn(&DeviceContext::CommandWorkerThread), this, deviceIndex, std::ref(remainingThreadCount), std::ref(suspendedThreadCount), std::ref(commandMutex), std::ref(commandSent), std::ref(commandProcessed), asuspendManager, std::ref(command)));		workerThread.detach();		commandThreadReady.wait(lock);	}}

void WebSharedWorkerImpl::startWorkerContext(const WebURL& url, const WebString& name, const WebString& userAgent, const WebString& sourceCode, const WebString& contentSecurityPolicy, WebContentSecurityPolicyType policyType, long long){    initializeLoader(url);    WorkerThreadStartMode startMode = m_pauseWorkerContextOnStart ? PauseWorkerGlobalScopeOnStart : DontPauseWorkerGlobalScopeOnStart;    OwnPtr<WorkerClients> workerClients = WorkerClients::create();    provideLocalFileSystemToWorker(workerClients.get(), WorkerFileSystemClient::create());    OwnPtr<WorkerThreadStartupData> startupData = WorkerThreadStartupData::create(url, userAgent, sourceCode, startMode, contentSecurityPolicy, static_cast<WebCore::ContentSecurityPolicy::HeaderType>(policyType), workerClients.release());    setWorkerThread(SharedWorkerThread::create(name, *this, *this, startupData.release()));    workerThread()->start();}

 void startWithSourceCode(const String& source) {   std::unique_ptr<Vector<CSPHeaderAndType>> headers =       wrapUnique(new Vector<CSPHeaderAndType>());   CSPHeaderAndType headerAndType("contentSecurityPolicy",                                  ContentSecurityPolicyHeaderTypeReport);   headers->append(headerAndType);   workerThread()->start(WorkerThreadStartupData::create(       KURL(ParsedURLString, "http://fake.url/"), "fake user agent", source,       nullptr /* cachedMetaData */, DontPauseWorkerGlobalScopeOnStart,       headers.get(), "" /* referrerPolicy */, m_securityOrigin.get(),       nullptr /* workerClients */, WebAddressSpaceLocal,       nullptr /* originTrialTokens */, nullptr /* workerSettings */,       V8CacheOptionsDefault)); }

int main(){    std::cout << "main: startup" << std::endl;    boost::thread workerThread(workerFunc);    std::cout << "main: waiting for thread" << std::endl;    workerThread.join();    std::cout << "main: done" << std::endl;    return 0;}

int main(int argc, char* argv[]){	if (argc != 2)	{		std::cerr << "Usage: TCP_echo_server <port>/n";		return -1;	}	wiringPiSetup();	wiringPiI2CSetup(I2C_TEMP_ADDRESS);	boost::thread workerThread(listener_loop, std::atoi(argv[1])); // Creates a thread that loops to accept sockets	workerThread.join();		return 0;}

void DiskLocation::addExternalFsWorkerRequest(ExternalFileSystemChangesWorker *extFsWorker){    connect(extFsWorker,    SIGNAL(added(DirItemInfo)),            this,           SIGNAL(extWatcherItemAdded(DirItemInfo)));    connect(extFsWorker,    SIGNAL(removed(DirItemInfo)),            this,           SIGNAL(extWatcherItemRemoved(DirItemInfo)));    connect(extFsWorker,    SIGNAL(changed(DirItemInfo)),            this,           SIGNAL(extWatcherItemChanged(DirItemInfo)));    connect(extFsWorker,    SIGNAL(finished(int)),            this,           SIGNAL(extWatcherChangesFetched(int)));        workerThread()->addRequest(extFsWorker);}

void scoring::MarkovNetworkScoreCalculator::calculateScores(FloatMap &cache) {    this->outOfTime = false;    boost::asio::io_service io_t;    t = new boost::asio::deadline_timer(io_t);    if (runningTime > 0) {        t->expires_from_now(boost::posix_time::seconds(runningTime));        t->async_wait(boost::bind(&scoring::MarkovNetworkScoreCalculator::timeout, this, boost::asio::placeholders::error));        boost::thread workerThread(boost::bind(&scoring::MarkovNetworkScoreCalculator::calculateScores_internal, this, boost::ref(cache)));        io_t.run();        workerThread.join();        io_t.stop();    } else {        calculateScores_internal(cache);    }}

Database::Database( const QString& dbname, QObject* parent )    : QObject( parent )    , m_ready( false )    , m_impl( new DatabaseImpl( dbname ) )    , m_workerRW( new DatabaseWorkerThread( this, true ) )    , m_idWorker( new IdThreadWorker( this ) ){    s_instance = this;    // register commands    registerCommand<DatabaseCommand_AddFiles>();    registerCommand<DatabaseCommand_DeleteFiles>();    registerCommand<DatabaseCommand_CreatePlaylist>();    registerCommand<DatabaseCommand_DeletePlaylist>();    registerCommand<DatabaseCommand_LogPlayback>();    registerCommand<DatabaseCommand_RenamePlaylist>();    registerCommand<DatabaseCommand_SetPlaylistRevision>();    registerCommand<DatabaseCommand_CreateDynamicPlaylist>();    registerCommand<DatabaseCommand_DeleteDynamicPlaylist>();    registerCommand<DatabaseCommand_SetDynamicPlaylistRevision>();    registerCommand<DatabaseCommand_SocialAction>();    registerCommand<DatabaseCommand_SetCollectionAttributes>();    registerCommand<DatabaseCommand_SetTrackAttributes>();    registerCommand<DatabaseCommand_ShareTrack>();    if ( MAX_WORKER_THREADS < DEFAULT_WORKER_THREADS )        m_maxConcurrentThreads = MAX_WORKER_THREADS;    else        m_maxConcurrentThreads = qBound( DEFAULT_WORKER_THREADS, QThread::idealThreadCount(), MAX_WORKER_THREADS );    tDebug() << Q_FUNC_INFO << "Using" << m_maxConcurrentThreads << "database worker threads";    connect( m_impl, SIGNAL( indexReady() ), SLOT( markAsReady() ) );    connect( m_impl, SIGNAL( indexReady() ), SIGNAL( indexReady() ) );    Q_ASSERT( m_workerRW );    m_workerRW.data()->start();    while ( m_workerThreads.count() < m_maxConcurrentThreads )    {        QPointer< DatabaseWorkerThread > workerThread( new DatabaseWorkerThread( this, false ) );        Q_ASSERT( workerThread );        workerThread.data()->start();        m_workerThreads << workerThread;    }    m_idWorker->start();}

void MainWindow::released(){    if(btnSearch->text() == QString(ConstStrings::search)){        btnSearch->setText(QString(ConstStrings::cancel));        model->removeRows(0, model->rowCount());        int nFrom = txtFrom->text().toInt();        int nTo = txtTo->text().toInt();        thread = new QThread();        worker = new Worker(nFrom, nTo);        worker->moveToThread(thread);        workerThread();        thread->start();    }else{        worker->exit();        btnSearch->setText(QString(ConstStrings::search));    }}

void WebWorkerImpl::postMessageToWorkerContext(const WebString& message,                                               const WebMessagePortChannelArray& webChannels){    OwnPtr<MessagePortChannelArray> channels;    if (webChannels.size()) {        channels = new MessagePortChannelArray(webChannels.size());        for (size_t i = 0; i < webChannels.size(); ++i) {            RefPtr<PlatformMessagePortChannel> platform_channel =                PlatformMessagePortChannel::create(webChannels[i]);            webChannels[i]->setClient(platform_channel.get());            (*channels)[i] = MessagePortChannel::create(platform_channel);        }    }    workerThread()->runLoop().postTask(        createCallbackTask(&postMessageToWorkerContextTask,                           this, String(message), channels.release()));}

TEST(WorkerThread_Test1, JustRun){	int a[5] = {11, 22, 33, 44, 55};	int b[5];	int size = _countof(a);	std::copy(&a[0], &a[_countof(a)], b);	TestWorker testWorker;	testWorker.Run();	Worker worker;	//WorkerThread<Worker, std::tr1::shared_ptr<Task> > workerThread(&worker, &Worker::RunMethod);	WorkerThread<Worker, Task > workerThread(&worker, &Worker::RunMemberMethod);	workerThread.Start();	//WorkerThread<Worker, Task > workerThread(&Worker::RunStaticMethod);	int numberOfTasks = 5;	for(int i = 0; i < numberOfTasks; ++i)	{		Task task(i);		//std::tr1::shared_ptr<Task> task(new Task(i));		workerThread.Enqueue(task);		//Sleep(1000);	}		//Sleep(3000);	workerThread.Stop();	workerThread.Stop();	//workerThread.TerminateGracefully();	workerThread.Join();	/*DWORD result = workerThread.Join(4000);	if(WAIT_OBJECT_0 != result)		workerThread.Terminate();*/	//ASSERT_TRUE(worker.counter == numberOfTasks);	EXPECT_EQ(worker.counter, numberOfTasks);}

RC_Widget::RC_Widget(bool block_Y,                     int max_up_down, int min_up_down,                     int max_left_right, int min_left_right,                     int rev_up_down, int rev_left_right,                     QWidget *parent) :    QWidget(parent){    if (pthread_mutex_init(&mutex, NULL) != 0){        std::cout << "mutex init failed" << std::endl;    }    QPalette pal_background;    pal_background.setColor(QPalette::Background, Qt::black);    setAutoFillBackground(true);    setPalette(pal_background);    setMaximumSize(500, 500);    setMinimumSize(500, 500);    press = false;    automatic = false;    this->block_Y = block_Y;    boost::thread workerThread(&RC_Widget::run, this);    connect(this, SIGNAL(update_GUI()), this, SLOT(on_update_GUI_recieved()));    p_actual.setX(250);    if(block_Y)        p_actual.setY(495);    else        p_actual.setY(250);    this->min_value_up_down = min_up_down;    this->max_value_up_down = max_up_down;    this->min_value_left_right = min_left_right;    this->max_value_left_right = max_left_right;    this->rev_left_right = rev_left_right;    this->rev_up_down = rev_up_down;}

int main(int argc, char **argv){  #ifdef POINT_CLOUD  update = false;  boost::thread workerThread(visualize);  #endif  ros::init(argc, argv, "pfilterTest");  ros::NodeHandle n;  // ros::Publisher pub = n.advertise<geometry_msgs::PoseArray>("/particles_from_filter", 5);  ROS_INFO("Testing particle filter");    particleFilter::cspace b_Xprior[2];	  computeInitialDistribution(b_Xprior, n);  PFilterTest pFilterTest(NUM_PARTICLES, b_Xprior);    ros::spin();  #ifdef POINT_CLOUD  workerThread.interrupt();  workerThread.join();  #endif}

void WebSharedWorkerImpl::connect(WebMessagePortChannel* webChannel){    workerThread()->postTask(        BLINK_FROM_HERE, createCrossThreadTask(&connectTask, adoptPtr(webChannel)));}