C++ Threads类代码示例

int main()
{
  static const int NUM_THREADS = 64;
  typedef boost::array<boost::thread, NUM_THREADS> Threads;

  std::cout<<"hardware concurrency "<<boost::thread::hardware_concurrency()<<std::endl;
  std::cout<<"threads "<<NUM_THREADS<<std::endl;
  std::cout<<"iterations per threads "<<NUM_IT<<std::endl;

  volatile int i = 0;
  boost::barrier barrier(NUM_THREADS);

  Threads threads;
  for(Threads::iterator it = threads.begin(); it != threads.end(); ++it)
  {
    *it = boost::thread(boost::bind(&IncThreadFunc, &barrier, &i));
  }

  for(Threads::iterator it = threads.begin(); it != threads.end(); ++it)
  {
    (*it).join();
  }

  std::cout<<"result  "<<i<<" expected "<<(NUM_THREADS*NUM_IT)<<" ("<<(NUM_THREADS*NUM_IT-i)<<")"<<std::endl;

  return 0;
}

Viewer::~Viewer()
{
    //OSG_NOTICE<<"Viewer::~Viewer()"<<std::endl;

    Threads threads;
    getAllThreads(threads);

    OSG_INFO<<"Viewer::~Viewer():: start destructor getThreads = "<<threads.size()<<std::endl;

    stopThreading();

    if (_scene.valid() && _scene->getDatabasePager())
    {
        _scene->getDatabasePager()->cancel();
        _scene->setDatabasePager(0);
    }

    Contexts contexts;
    getContexts(contexts);

    // clear out all the previously assigned operations
    for(Contexts::iterator citr = contexts.begin();
        citr != contexts.end();
        ++citr)
    {
        (*citr)->close();
    }

    //OSG_NOTICE<<"finish Viewer::~Viewer()"<<std::endl;

    getAllThreads(threads);

    OSG_INFO<<"Viewer::~Viewer() end destructor getThreads = "<<threads.size()<<std::endl;
}

void CompositeViewer::getAllThreads(Threads& threads, bool onlyActive)
{
    OperationThreads operationThreads;
    getOperationThreads(operationThreads);

    for(OperationThreads::iterator itr = operationThreads.begin();
            itr != operationThreads.end();
            ++itr)
    {
        threads.push_back(*itr);
    }

    Scenes scenes;
    getScenes(scenes);

    for(Scenes::iterator sitr = scenes.begin();
            sitr != scenes.end();
            ++sitr)
    {
        Scene* scene = *sitr;
        osgDB::DatabasePager* dp = scene->getDatabasePager();
        if (dp)
        {
            for(unsigned int i=0; i<dp->getNumDatabaseThreads(); ++i)
            {
                osgDB::DatabasePager::DatabaseThread* dt = dp->getDatabaseThread(i);
                if (!onlyActive || dt->isRunning())
                {
                    threads.push_back(dt);
                }
            }
        }
    }
}

Threads ThreadsHandler::parseGdbmiThreads(const GdbMi &data, int *currentThread)
{
    // ^done,threads=[{id="1",target-id="Thread 0xb7fdc710 (LWP 4264)",
    // frame={level="0",addr="0x080530bf",func="testQString",args=[],
    // file="/.../app.cpp",fullname="/../app.cpp",line="1175"},
    // state="stopped",core="0"}],current-thread-id="1"
    const QList<GdbMi> items = data.findChild("threads").children();
    const int n = items.size();
    Threads threads;
    threads.reserve(n);
    for (int index = 0; index != n; ++index) {
        bool ok = false;
        const GdbMi item = items.at(index);
        const GdbMi frame = item.findChild("frame");
        ThreadData thread;
        thread.id = item.findChild("id").data().toInt();
        thread.targetId = QString::fromLatin1(item.findChild("target-id").data());
        thread.core = QString::fromLatin1(item.findChild("core").data());
        thread.state = QString::fromLatin1(item.findChild("state").data());
        thread.address = frame.findChild("addr").data().toULongLong(&ok, 0);
        thread.function = QString::fromLatin1(frame.findChild("func").data());
        thread.fileName = QString::fromLatin1(frame.findChild("fullname").data());
        thread.lineNumber = frame.findChild("line").data().toInt();
        thread.module = QString::fromLocal8Bit(frame.findChild("from").data());
        // Non-GDB (Cdb2) output name here.
        thread.name = QString::fromLatin1(frame.findChild("name").data());
        threads.append(thread);
    }
    if (currentThread)
        *currentThread = data.findChild("current-thread-id").data().toInt();
    return threads;
}

void IPCEngineHost::selectThread(int index)
{
    resetLocation();
    Threads threads = threadsHandler()->threads();
    QTC_ASSERT(index < threads.size(), return);
    QByteArray p;
    {
        QDataStream s(&p, QIODevice::WriteOnly);
        SET_NATIVE_BYTE_ORDER(s);
        s << quint64(threads.at(index).id);
    }
    rpcCall(SelectThread, p);
}

Viewer::~Viewer()
{
    //OSG_NOTICE<<"Viewer::~Viewer()"<<std::endl;

    Threads threads;
    getAllThreads(threads);

    OSG_INFO<<"Viewer::~Viewer():: start destructor getThreads = "<<threads.size()<<std::endl;

    stopThreading();

    if (_scene.valid() && _scene->getDatabasePager())
    {
        _scene->getDatabasePager()->cancel();
        _scene->setDatabasePager(0);
    }

    Contexts contexts;
    getContexts(contexts);

    // clear out all the previously assigned operations
    for(Contexts::iterator citr = contexts.begin();
        citr != contexts.end();
        ++citr)
    {
        osg::GraphicsContext* gc = *citr;

        // Run destroy operation on each context before closing it
        if (_cleanUpOperation.valid() && gc->valid())
        {
            gc->makeCurrent();

            (*_cleanUpOperation)(gc);

            gc->releaseContext();
        }

        gc->close();
    }

    //OSG_NOTICE<<"finish Viewer::~Viewer()"<<std::endl;

    getAllThreads(threads);

    OSG_INFO<<"Viewer::~Viewer() end destructor getThreads = "<<threads.size()<<std::endl;
}

std::string gdbmiThreadList(CIDebugSystemObjects *debugSystemObjects,
                            CIDebugSymbols *debugSymbols,
                            CIDebugControl *debugControl,
                            CIDebugAdvanced *debugAdvanced,
                            std::string *errorMessage)
{
    Threads threads;
    ULONG currentThreadId;
    if (!threadList(debugSystemObjects, debugSymbols, debugControl,
                    debugAdvanced, &threads, &currentThreadId, errorMessage))
        return std::string();
    std::ostringstream str;
    str << "{threads=[";
    const Threads::const_iterator cend = threads.end();
    for (Threads::const_iterator it = threads.begin(); it != cend; ++it)
        it->formatGDBMI(str);
    str << "],current-thread-id=\"" << currentThreadId << "\"}";
    return str.str();
}

int main()
{
  static const int NUM_THREADS = 64;
  typedef boost::array<boost::thread, NUM_THREADS> Threads;

  std::cout<<"hardware concurrency "<<boost::thread::hardware_concurrency()<<std::endl;
  std::cout<<"threads "<<NUM_THREADS<<std::endl;
  std::cout<<"iterations per threads "<<NUM_IT<<std::endl;

  volatile int i = 0;
  boost::condition_variable cond;
  boost::mutex mut;
  volatile int started = 0;

  Threads threads;
  for(Threads::iterator it = threads.begin(); it != threads.end(); ++it)
  {
    *it = boost::thread(boost::bind(&IncThreadFunc, &started, &i, &cond, &mut));
  }

  while(started < NUM_THREADS)
  {
    boost::this_thread::sleep(boost::posix_time::milliseconds(10));
  }

  cond.notify_all();

  for(Threads::iterator it = threads.begin(); it != threads.end(); ++it)
  {
    (*it).join();
  }

  std::cout<<"result  "<<i<<" expected "<<(NUM_THREADS*NUM_IT)<<" ("<<(NUM_THREADS*NUM_IT-i)<<")"<<std::endl;

  return 0;
}

void ThreadsHandler::setThreads(const Threads &threads)
{
    beginResetModel();
    m_threads = threads;
    bool found = false;
    for (int i = 0, n = m_threads.size(); i < n; ++i)
        if (threads.at(i).id == m_currentId) {
            found = true;
            break;
        }
    if (!found)
        m_currentId = ThreadId();
    m_resetLocationScheduled = false;
    endResetModel();
    updateThreadBox();
}

int main(int argc, char** argv)
{
    osg::ArgumentParser arguments(&argc, argv);

    // construct the viewer.
    osgViewer::Viewer viewer(arguments);

    typedef std::list< osg::ref_ptr<osg::OperationThread> > Threads;

    Threads operationThreads;
    osg::ref_ptr<UpdateTextOperation> updateOperation;

    unsigned int numThreads = 0;
    if (arguments.read("--mt", numThreads) || arguments.read("--mt"))
    {
        // construct a multi-threaded text updating test.
        if (numThreads==0) numThreads = 1;

        // create a group to add everything into.
        osg::Group* mainGroup = new osg::Group;

        osg::Vec3 center(0.5f,0.5f,0.5f);
        float diameter = 1.0f;

        osg::ref_ptr<osg::Node> loadedModel = osgDB::readNodeFiles(arguments);
        if (loadedModel.valid())
        {
            mainGroup->addChild(loadedModel.get());

            center = loadedModel->getBound().center();
            diameter = loadedModel->getBound().radius() * 2.0f;
        }

        for(unsigned int i=0; i<numThreads; ++i)
        {
            osg::Group* textGroup = new osg::Group;
            mainGroup->addChild(textGroup);

            // create the background thread
            osg::OperationThread* operationThread = new osg::OperationThread;

            operationThreads.push_back(operationThread);

            // create the operation that will run in the background and
            // sync once per frame with the main viewer loop.
            updateOperation = new UpdateTextOperation(center, diameter, textGroup);

            // add the operation to the operation thread and start it.
            operationThread->add(updateOperation.get());
            operationThread->startThread();

            // add the operation to the viewer to sync once per frame.
            viewer.addUpdateOperation(updateOperation.get());


            // add a unit cube for the text to appear within.
            osg::Geode* geode = new osg::Geode;
            geode->getOrCreateStateSet()->setAttribute(new osg::PolygonMode(osg::PolygonMode::FRONT_AND_BACK,osg::PolygonMode::LINE));
            geode->addDrawable(new osg::ShapeDrawable(new osg::Box(center,diameter)));

            mainGroup->addChild(geode);
        }

        viewer.setSceneData(mainGroup);
    }
    else
    {
        // prepare scene.
        osg::Vec3 center(0.0f,0.0f,0.0f);
        float radius = 1.0f;

        // make sure the root node is group so we can add extra nodes to it.
        osg::Group* group = new osg::Group;

        if (true)
        {
            // create the hud.
            osg::Camera* camera = new osg::Camera;
            camera->setReferenceFrame(osg::Transform::ABSOLUTE_RF);
            camera->setProjectionMatrixAsOrtho2D(0,1280,0,1024);
            camera->setViewMatrix(osg::Matrix::identity());
            camera->setClearMask(GL_DEPTH_BUFFER_BIT);
            camera->addChild(createHUDText());
            camera->getOrCreateStateSet()->setMode(GL_LIGHTING,osg::StateAttribute::OFF);

            group->addChild(camera);
        }

        if (true)
        {
            group->addChild(create3DText(center,radius));
        }

        // set the scene to render
        viewer.setSceneData(group);
    }

    std::string filename;
    if (arguments.read("-o",filename))
    {
//.........这里部分代码省略.........

 void threadFinishedSlot() {
   auto const thread = qobject_cast<QThread*>(QObject::sender());
   QMutexLocker lock(&m_mutex);
   auto it = m_threads.find(thread);
   if (it == m_threads.end()) return;
   auto const histogram(it->histogram);
   bool stuck = it->stuck;
   m_threads.erase(it);
   lock.unlock();
   emit newHistogram(thread, histogram);
   if (stuck) emit loopStateChanged(thread, 0);
   emit threadFinished(thread);
 }

void GlutViewer::Start(int argc, char** argv, int w, int h, float r)
{
	a_argc = argc;
	a_argv = argv;
	width = w;
	height = h;
    rad = r;

    threads.create(glut_thread, 0);
}