C++ QMutex::unlock方法代码示例

void sendLoadSceneRPC(Player* player, QString sceneName) // Loads a scene and send to the default spawn
{
    win.logMessage(QString("UDP: Loading scene \"") + sceneName + "\" on "+QString().setNum(player->pony.netviewId));
    Vortex vortex = findVortex(sceneName, 0);
    if (vortex.destName.isEmpty())
    {
        win.logMessage("UDP: Scene not in vortex DB. Aborting scene load.");
        return;
    }

    Scene* scene = findScene(sceneName);
    Scene* oldScene = findScene(player->pony.sceneName);
    if (scene->name.isEmpty() || oldScene->name.isEmpty())
    {
        win.logMessage("UDP: Can't find the scene, aborting");
        return;
    }

    // Update scene players
    //win.logMessage("sendLoadSceneRPC: locking");
    levelLoadMutex.lock();
    player->inGame=1;
    player->pony.pos = vortex.destPos;
    player->pony.sceneName = sceneName;
    player->lastValidReceivedAnimation.clear(); // Changing scenes resets animations
    Player::removePlayer(oldScene->players, player->IP, player->port);
    if (oldScene->name != sceneName)
    {
        // Send remove RPC to the other players of the old scene
        for (int i=0; i<oldScene->players.size(); i++)
            sendNetviewRemove(oldScene->players[i], player->pony.netviewId);

        // Send instantiate to the players of the new scene
        for (int i=0; i<scene->players.size(); i++)
            if (scene->players[i]->inGame>=2)
                sendNetviewInstantiate(player, scene->players[i]);
    }
    scene->players << player;

    QByteArray data(1,5);
    data += stringToData(sceneName);
    sendMessage(player,MsgUserReliableOrdered6,data); // Sends a 48
    //win.logMessage("sendLoadSceneRPC: unlocking");
    levelLoadMutex.unlock();
}

void
IdThreadWorker::getArtistId( const artist_ptr& artist, bool autoCreate )
{
    QueueItem* item = internalGet( artist, album_ptr(), trackdata_ptr(), autoCreate, ArtistType );
    artist->setIdFuture( item->promise.future() );

#if ID_THREAD_DEBUG
    tDebug() << "QUEUEING ARTIST:" << artist->name();
#endif

    s_mutex.lock();
    s_workQueue.enqueue( item );
    s_mutex.unlock();
    s_waitCond.wakeOne();
#if ID_THREAD_DEBUG
    tDebug() << "DONE WOKE UP THREAD:" << artist->name();
#endif
}

Data::Data(int typeId,
           equals_fn equals, lessThan_fn lessThan,
           castTo_fn castTo, convertTo_fn convertTo, convertFrom_fn convertFrom,
           canCastTo_fn canCastTo, canConvertTo_fn canConvertTo, canConvertFrom_fn canConvertFrom ) :
    typeId_( lh_lock_and_filter( typeId ) ),
    equals_( equals ),
    lessThan_( lessThan ),
    castTo_( castTo ),
    convertTo_( convertTo ),
    convertFrom_( convertFrom ),
    canCastTo_( canCastTo ),
    canConvertTo_( canConvertTo ),
    canConvertFrom_( canConvertFrom ),
    next_( typeId_ ? lh_first_info_ : 0 )
{
    if( typeId_ ) lh_first_info_ = this;
    lh_type_data_mutex_.unlock();
}

    void project(const Template &src, Template &dst) const
    {
        dst = src;

        if (Globals->parallelism) {
            qWarning("Edit::project() only works in single threaded mode.");
            return;
        }

        currentTemplateLock.lock();
        currentTemplate = src;
        OpenCVUtils::showImage(src, "Edit", false);
        setMouseCallback("Edit", mouseCallback, (void*)this);
        mouseEvent(0, 0, 0, 0);
        waitKey(-1);
        dst = currentTemplate;
        currentTemplateLock.unlock();
    }

void Person::onReset() {
    QMutex mutex;
    mutex.lock();
    this->stop = true;
    mutex.unlock();

    this->inCS = false;
    this->isWaiting = false;
    this->requests = new QVector<int>();
    this->awks = new QVector<int>();

    QPoint moveBy;
    moveBy.setX(this->initialPosition.x() - this->position.x());
    moveBy.setY(this->initialPosition.y() - this->position.y());
    emit this->ChangePosition(this->id, moveBy);

    this->position += moveBy;
}

void processsimthread::run()
{
    QMutex mutex;
    int counter = 0;
    this->Stop = false;
    while(!this->Stop)
    {
       mutex.lock();
       counter++;
       if (counter == 100) {
           counter = 0;
       }
       emit processValueChanged(counter);
       mutex.unlock();
       QThread::msleep(100);

    }
}

void QWaitConditionPrivate::post(QWaitConditionEvent *wce, bool ret)
{
    mtx.lock();

    // remove 'wce' from the queue
    queue.removeAll(wce);
    ResetEvent(wce->event);
    freeQueue.append(wce);

    // wakeups delivered after the timeout should be forwarded to the next waiter
    if (!ret && wce->wokenUp && !queue.isEmpty()) {
        QWaitConditionEvent *other = queue.first();
        SetEvent(other->event);
        other->wokenUp = true;
    }

    mtx.unlock();
}

void customMessageHandler(QtMsgType type, const char *msg)
{
    static QMutex mutex;
    mutex.lock();

    QString text;
    switch(type)
    {
    case QtDebugMsg:
        text = QString("Debug:");
        break;

    case QtWarningMsg:
        text = QString("Warning:");
        break;

    case QtCriticalMsg:
        text = QString("Critical:");
        break;

    case QtFatalMsg:
        text = QString("Fatal:");
    }

    QString current_date_time = QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss");
    QString current_date = QString("(%1)").arg(current_date_time);
    QString message = QString("%1 %2 %3").arg(text).arg(current_date).arg(msg);

    QFile file("log.txt");
    if (file.size() > 104857600)//size large than 100M split
    {
        QString filedate = QDateTime::currentDateTime().toString("yyyy-MM-dd--hh-mm-ss");
        file.rename(QString("log_%1.txt").arg(filedate));
        file.setFileName("log.txt");
    }
    file.open(QIODevice::WriteOnly | QIODevice::Append);
    QTextStream text_stream(&file);
    text_stream.setCodec(QTextCodec::codecForName("System"));
    text_stream << message << "\r\n";
    file.flush();
    file.close();

    mutex.unlock();
}

void sendLoadSceneRPC(Player* player, QString sceneName, UVector pos) // Loads a scene and send to the given pos
{
    win.logMessage(QString(QString("UDP: Loading scene \"")+sceneName
                           +"\" to "+QString().setNum(player->pony.netviewId)
                           +" at "+QString().setNum(pos.x)+" "
                           +QString().setNum(pos.y)+" "
                           +QString().setNum(pos.z)));

    Scene* scene = findScene(sceneName);
    Scene* oldScene = findScene(player->pony.sceneName);
    if (scene->name.isEmpty() || oldScene->name.isEmpty())
    {
        win.logMessage("UDP: Can't find the scene, aborting");
        return;
    }

    // Update scene players
    //win.logMessage("sendLoadSceneRPC pos: locking");
    levelLoadMutex.lock();
    player->inGame=1;
    player->pony.pos = pos;
    player->pony.sceneName = sceneName.toLower();
    player->lastValidReceivedAnimation.clear(); // Changing scenes resets animations
    Player::removePlayer(oldScene->players, player->IP, player->port);
    if (oldScene->name.toLower() != sceneName.toLower())
    {
        // Send remove RPC to the other players of the old scene
        for (int i=0; i<oldScene->players.size(); i++)
            sendNetviewRemove(oldScene->players[i], player->pony.netviewId);

        // Send instantiate to the players of the new scene
        for (int i=0; i<scene->players.size(); i++)
            if (scene->players[i]->inGame>=2)
                sendNetviewInstantiate(&player->pony, scene->players[i]);
    }
    scene->players << player;

    QByteArray data(1,5);
    data += stringToData(sceneName.toLower());
    sendMessage(player,MsgUserReliableOrdered6,data); // Sends a 48
    //win.logMessage("sendLoadSceneRPC pos: unlocking");
    levelLoadMutex.unlock();
}

 bool GetDataFromQueuen(pComdata pData)
 {
     bool m_bbSuccess=false;
     if(pData == NULL)
     return m_bbSuccess;
     memset(pData,0,sizeof(Comdata));
     DataMutex.lock();
     if(m_outCount!=m_intoCount)
    {
     memcpy(pData,&mtQueuen[m_outCount++],sizeof(Comdata));
     if(m_outCount>=QueuenSize)
     m_outCount=0;
     m_bbSuccess=true;
     }


     DataMutex.unlock();
     return  m_bbSuccess;
 }

void TextProducer::run()
{
    static int index = 0;
    static QMutex indexMutex;

    for( int i=0; i<m_text.length(); ++i )
    {
        freeSpace.acquire();
        indexMutex.lock();
        buffer[ index++ % bufferSize ] = m_text[i];
        indexMutex.unlock();

        if( i == m_text.length()-1 )
            //atEnd = true;
            atEnd.acquire();

        availableData.release();
    }
}

    void run()
    {
        test_mutex.lock();
        test_mutex.lock();
        test_mutex.lock();
        test_mutex.lock();

        mutex.lock();
        for (int i = 0; i < iterations; ++i) {
            cond.wakeOne();
            cond.wait(&mutex);
        }
        mutex.unlock();

        test_mutex.unlock();
        test_mutex.unlock();
        test_mutex.unlock();
        test_mutex.unlock();
    }

bool QSpotifySearch::event(QEvent *e)
{
    if (e->type() == QEvent::User) {
        auto ev = static_cast<SearchResultEvent*>(e);
        if (ev) {
            if (auto search = ev->getSearch()) {
                g_mutex.lock();
                bool is_current = (m_sp_search == search);
                g_mutex.unlock();
                if (sp_search_error(search) == SP_ERROR_OK && is_current) {
                    if(ev->getPtr()) {
                        switch(ev->getPtr()->mType) {
                        case Albums:
                            populateAlbums(search);
                            break;
                        case Artists:
                            populateArtists(search);
                            break;
                        case Playlists:
                            populatePlaylists(search);
                            break;
                        case Tracks:
                            populateTracks(search);
                            break;
                        default:
                            populateResults(search);
                            break;
                        }
                    } else
                        populateResults(search);
                }
                clearSearch(search);
            }
        }
        setBusy(false);

        emit resultsChanged();

        e->accept();
        return true;
    }
    return QObject::event(e);
}

MsvClientMessage* AuctionAction::getPlayerMessage(AuctionPlayerModel* resultPlayer) { // returns null if player didnt send anything
	qDebug() << "AuctionAction::doAuction# Waiting " << *(resultPlayer->getGamePlayer()->getPlayerModel()->getName())<< " action..." ;
	QMutex* mutex = new QMutex();
	QWaitCondition cond;
	mutex->lock();
	for (int i = 0;i<20;i++) { // waiting for action 20 seconds
		qDebug() << "...";
		cond.wait(mutex,1000);
		if (!(resultPlayer->getGamePlayer()->getPlayerModel()->getMessagePool()->isEmpty())) {
			qDebug() << endl << "AuctionAction::doAuction# i got action message from " << *(resultPlayer->getGamePlayer()->getPlayerModel()->getName()) << endl;
			MsvClientMessage* returnMessage = resultPlayer->getGamePlayer()->getPlayerModel()->getMessagePool()->last();
			resultPlayer->getGamePlayer()->getPlayerModel()->getMessagePool()->clear();
			return returnMessage;
		}
	}
	mutex->unlock();
	delete mutex;
	return NULL;
}

bool OpenConnection(in_addr_t ipReal, const QString & strClient)
{
	std::map<in_addr_t, Client *>::iterator iterClient, iterOldClient;
	std::map<QString, ClientCreator>::iterator iterCreator;
	bool bSuccess = false;
	Client * pClient;

	g_mutexClients.lock();

	g_pLogger->LogInfo(QString("Starting %1 to host %2...").arg(strClient).arg(IPAddressToString(ipReal)));

	iterCreator = g_mapClientCreators.find(strClient);
	iterClient = g_mapClients.find(ipReal);

	if (iterClient != g_mapClients.end())
	{
		if (iterClient->second != NULL)
		{
			iterClient->second->Stop();
			delete iterClient->second;
		}
		g_mapClients.erase(iterClient);
	}
	if (iterCreator != g_mapClientCreators.end())
		pClient = (*iterCreator->second)();
	else
		pClient = NULL;

	if (pClient != NULL && pClient->Start(ipReal))
		bSuccess = g_mapClients.insert(std::pair<in_addr_t, Client *>(ipReal, pClient)).second;
	else if (pClient != NULL)
		delete pClient;

	if (bSuccess)
		g_pLogger->LogInfo("Successful\n");
	else
		g_pLogger->LogInfo("Failed\n");

	g_mutexClients.unlock();

	return bSuccess;
}