C++ SpinLock::lock方法代码示例

    ThreadingManagerOMP(int req = -1)
    : start_counter(1),
      barrier_protocol(*static_cast<ThreadingManager*>(this))
    {
        assert(req == -1);

        // In the OpenMP backend, the ThreadManager is instantiated
        // in a serial section, so in contrast to the threaded backend
        // we do not know the number of threads here.
        // Instead we find out when we are called again in thread_main()
        startup_lock.lock();
        lock_workers_initialized.lock();

        Options::ThreadAffinity::init();
    }

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();
}

    void init_worker(int id) {
        Options::ThreadAffinity::pin_workerthread(id);
        // allocate Worker on thread
        TaskExecutor<Options> *te = new TaskExecutor<Options>(id, *this);

        // wait until main thread has initialized the threadmanager
        startup_lock.lock();
        startup_lock.unlock();

        threads[id] = te;
        task_queues[id] = &te->get_task_queue();

        Atomic::increase(&start_counter);

        lock_workers_initialized.lock();
        lock_workers_initialized.unlock();

        te->work_loop();
    }

    void stop() {
        if (get_thread_num() != 0) {
            
            // workers don't come here until terminate() has been called

            int nv = Atomic::decrease_nv(&start_counter);

            // wait until all workers reached this step
            // all threads must agree that we are shutting
            // down before we can continue and invoke the
            // destructor
            startup_lock.lock();
            startup_lock.unlock();
            return;
        }

        start_executing(); // make sure threads have been started, or we will wait forever in barrier
        barrier_protocol.barrier(*threads[0]);

        startup_lock.lock();

        for (int i = 1; i < get_num_cpus(); ++i)
            threads[i]->terminate();


        // wait for all threads to join
        while (start_counter != 1)
            Atomic::rep_nop();

        // signal that threads can destruct
        startup_lock.unlock();

        for (int i = 1; i < get_num_cpus(); ++i)
            delete threads[i];

        delete [] threads;
        delete [] task_queues;
    }

 /**
  * Return the number of bytes consumed by all free list blocks.
  *
  * This does not define the number of bytes available for actual usable allocation, and should not be used
  * by non-implementation code outside of unit tests or debugging.
  */
 vm_size_t debug_bytes_free () {
     vm_size_t bytes_free = 0;
     
     _lock.lock();
     control_block *first = _free_list;
     for (control_block *b = _free_list; b != NULL; b = b->_next) {
         bytes_free += b->_size;
         
         if (b->_next == first)
             break;
     }
     _lock.unlock();
     
     return bytes_free;
 }

    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);

    }

		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;
		}

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

void func(int n)
{
    g_Lock.lock();
    std::cout << "Output from thread: " << n << std::endl;
    g_Lock.unlock();
}