C++ SpinLock类代码示例

void SingletonReleaseHashTable()
{
	g_SpinLockHashTable.Lock();
	if (g_pObjHash)
	{
		delete g_pObjHash;
		g_pObjHash = 0;
	}
	g_SpinLockHashTable.Unlock();
}

void SingletonReleaseTextVector()
{
	g_SpinLockTextVec.Lock();
	if (g_pTextVec)
	{
		delete g_pTextVec;
		g_pTextVec = 0;
	}
	g_SpinLockTextVec.Unlock();
}

TextBufVecType * SingletonGetTextVector()
{
	if (!g_pTextVec)
	{
		g_SpinLockTextVec.Lock();
		if (!g_pTextVec)
			g_pTextVec = new TextBufVecType;
		g_SpinLockTextVec.Unlock();
	}
	return g_pTextVec;
}

HashType * SingletonGetHashTable()
{
	if (!g_pObjHash)
	{
		g_SpinLockHashTable.Lock();
		if (!g_pObjHash)
			g_pObjHash = new HashType;
		g_SpinLockHashTable.Unlock();
	}
	return g_pObjHash;
}

	void ParsingProcInternal()
	{
		while(true)
		{
			WString currentParsingText;
			{
				SpinLock::Scope scope(parsingTextLock);
				currentParsingText=parsingText;
				parsingText=L"";
			}
			if(currentParsingText==L"")
			{
				isParsingRunning=false;
				break;
			}

			List<Ptr<ParsingError>> errors;
			Ptr<ParsingTreeObject> node=grammarParser->Parse(currentParsingText, L"ParserDecl", errors).Cast<ParsingTreeObject>();
			Ptr<ParserDecl> decl;
			if(node)
			{
				node->InitializeQueryCache();
				decl=new ParserDecl(node);
			}
			{
				SpinLock::Scope scope(parsingTreeLock);
				parsingTreeNode=node;
				parsingTreeDecl=decl;
				node=0;
			}
			RestartColorizer();
		}
		parsingRunningEvent.Leave();
	}

// See that timer_trylock_or_cancel acquires the lock when the holder releases it.
static bool trylock_or_cancel_get_lock() {
    BEGIN_TEST;

    // We need 2 or more CPUs for this test.
    if (get_num_cpus_online() < 2) {
        printf("skipping test trylock_or_cancel_get_lock, not enough online cpus\n");
        return true;
    }

    timer_args arg{};
    timer_t t = TIMER_INITIAL_VALUE(t);

    SpinLock lock;
    arg.lock = lock.GetInternal();
    arg.wait = 1;

    arch_disable_ints();

    uint timer_cpu = arch_curr_cpu_num();
    const Deadline deadline = Deadline::no_slack(current_time() + ZX_USEC(100));
    timer_set(&t, deadline, timer_trylock_cb, &arg);

    // The timer is set to run on timer_cpu, switch to a different CPU, acquire the spinlock then
    // signal the callback to proceed.
    thread_set_cpu_affinity(get_current_thread(), ~cpu_num_to_mask(timer_cpu));
    DEBUG_ASSERT(arch_curr_cpu_num() != timer_cpu);

    arch_enable_ints();

    {
        AutoSpinLock guard(&lock);

        while (!atomic_load(&arg.timer_fired)) {
        }

        // Callback should now be running. Tell it to stop waiting and start trylocking.
        atomic_store(&arg.wait, 0);
    }

    // See that timer_cancel returns false indicating that the timer ran.
    ASSERT_FALSE(timer_cancel(&t), "");

    // Note, we cannot assert the value of arg.result. We have both released the lock and canceled
    // the timer, but we don't know which of these events the timer observed first.

    END_TEST;
}

void Scheduler::sleepAndRelease ( SpinLock &lock )
{
  lockScheduling();
  currentThread->state_=Sleeping;
  lock.release();
  unlockScheduling();
  yield();
}

    TEST(ParallelUtils,SpinLock) {

        const int N = 1000000;

        SpinLock lock;

        volatile int c =0;

        #pragma omp parallel for num_threads(4)
        for(int i=0; i<N; i++) {
            lock.lock();
            c++;
            lock.unlock();
        }

        EXPECT_EQ(N, c);

    }

void duplicate_node::match(vector<duplicate_node*>& entrances,
                           search_duplicate_files_status* status,
                           SpinLock& lock)
{
    duplicate_node* iter = this;
    while (iter) {
        bool first_matched = true;
        duplicate_node* current_node = iter;
        duplicate_node* last_node = iter;
        euint current_symbol = iter->m_symbol;
        while (current_node) {
            {
                SpinLock::Instance inst = lock.Lock();
                if (status) {
                    status->m_current_status = search_duplicate_files_status::Matching;
                    status->m_processing_file = current_node->m_path.c_str();
                }
            }
            if (current_node->m_symbol == current_symbol && current_node != last_node) {
                last_node->m_next1 = current_node;
                if (first_matched) {
                    entrances.push_back(last_node);
                    first_matched = false;
                }
                last_node->m_is_matched = true;
                current_node->m_is_matched = true;
                last_node = current_node;
            }
            current_node = current_node->m_next0;
        }
        iter = iter->m_next0;
        while (iter && iter->m_is_matched) {
            iter = iter->m_next0;
        }
    }
    {
        SpinLock::Instance inst = lock.Lock();
        if (status) {
            status->m_current_status = search_duplicate_files_status::Idling;
            status->m_processing_file = nullptr;
        }
    }
}

void xhn::thread::assign_to_local_thread(thread_ptr& local_thread, thread_ptr& global_thread, SpinLock& lock)
{
    {
        xhn::SpinLock::Instance inst = lock.Lock();
        local_thread = global_thread;
    }
    if (!local_thread) {

        local_thread = VNEW xhn::thread;
        while (!local_thread->is_running()) {}

        {
            xhn::SpinLock::Instance inst = lock.Lock();
            if (!global_thread) {
                global_thread = local_thread;
            }
            else {
                local_thread = global_thread;
            }
        }
    }
}

		Font Font::getDefault()
		{
			static Font font;
			static SpinLock lock;

			lock.lock();

			if (font.getHandle() == nullptr)
			{
				jni::Class Button("libnative/ui/TextComponent");
				jni::method_t viewConstructor = Button.getConstructor("(Landroid/content/Context;)V");
				jni::Object button = Button.newInstance(viewConstructor, (jni::Object*) App::getAppHandle());

				// Android already scales its default fonts.
				font._size = button.call<float>("getScaledTextSize");
				font._shared->handle = new jni::Object(button.call<jni::Object>("getTypeface()Landroid/graphics/Typeface;"));
			}

			lock.release();

			return font;
		}

	void SubmitCurrentText(const wchar_t* text)
	{
		{
			// copy the text because this is a cross thread accessible data
			SpinLock::Scope scope(parsingTextLock);
			parsingText=text;
		}
		if(!isParsingRunning)
		{
			isParsingRunning=true;
			parsingRunningEvent.Enter();
			ThreadPoolLite::Queue(&ParsingProc, this);
		}
	}

	SpinGuard(SpinLock& mutex) : _mutex(&mutex){
		_mutex->lock();
	}

void NetworkManager::Run()
{
	int threadId;
	struct epoll_event events[100];
	int numOfEvent, n;

	g_networkThreadCountLock.Lock();
	threadId = g_networkThreadCount++;
	g_networkThreadCountLock.Unlock();

	for(;;)
	{
		numOfEvent = epoll_wait(m_epollFdList[threadId], m_epollEvent2DList[threadId], 100, 2000);

		//printf("NW thread %d\n", threadId);
		if(numOfEvent < 0){	
			// critical error
			fprintf(stderr, "[ERROR] epoll_wait() ERROR : %s\n", strerror(errno));
			exit(1);
		}

		if(numOfEvent == 0)
		{
			continue;
		}

		//printf("NT %d activated\n", TC);
		OnEvent(numOfEvent, threadId);
	}
	close(m_serverFd);
	for(int i=0; i<NETWORK_THREAD_NUM; i++)
		close(m_epollFdList[i]);
}

void func(int i)
{
	g_lock.lock();
	std::this_thread::sleep_for(std::chrono::milliseconds(10));
	std::cout << std::this_thread::get_id() << "add : " << i << std::endl;
	sum++;
	g_lock.unlock();
}