C++ (Cpp) BOOST_INTERLOCKED_DECREMENT Beispiele

Beispiel #1

Datei: thread_data.hpp Projekt: 4ukuta/core

 friend void intrusive_ptr_release(thread_data_base * p)
 {
     if(!BOOST_INTERLOCKED_DECREMENT(&p->count))
     {
         detail::heap_delete(p);
     }
 }

Beispiel #2

Datei: sp_counted_base_w32.hpp Projekt: brycelelbach/prana

 void weak_release() // nothrow
 {
     if( BOOST_INTERLOCKED_DECREMENT( &weak_count_ ) == 0 )
     {
         destroy();
     }
 }

Beispiel #3

Datei: sp_counted_base_w32.hpp Projekt: brycelelbach/prana

 void release() // nothrow
 {
     if( BOOST_INTERLOCKED_DECREMENT( &use_count_ ) == 0 )
     {
         dispose();
         weak_release();
     }
 }

Beispiel #4

Datei: basic_timed_mutex.hpp Projekt: TheForum/Earth-and-Beyond-server

            bool timed_lock(::boost::system_time const& wait_until)
            {
                if(!win32::interlocked_bit_test_and_set(&active_count,lock_flag_bit))
                {
                    return true;
                }
                long old_count=active_count;
                for(;;)
                {
                    long const new_count=(old_count&lock_flag_value)?(old_count+1):(old_count|lock_flag_value);
                    long const current=BOOST_INTERLOCKED_COMPARE_EXCHANGE(&active_count,new_count,old_count);
                    if(current==old_count)
                    {
                        break;
                    }
                    old_count=current;
                }

                if(old_count&lock_flag_value)
                {
                    bool lock_acquired=false;
                    void* const sem=get_event();

                    do
                    {
                        if(win32::WaitForSingleObject(sem,::boost::detail::get_milliseconds_until(wait_until))!=0)
                        {
                            BOOST_INTERLOCKED_DECREMENT(&active_count);
                            return false;
                        }
                        old_count&=~lock_flag_value;
                        old_count|=event_set_flag_value;
                        for(;;)
                        {
                            long const new_count=((old_count&lock_flag_value)?old_count:((old_count-1)|lock_flag_value))&~event_set_flag_value;
                            long const current=BOOST_INTERLOCKED_COMPARE_EXCHANGE(&active_count,new_count,old_count);
                            if(current==old_count)
                            {
                                break;
                            }
                            old_count=current;
                        }
                        lock_acquired=!(old_count&lock_flag_value);
                    }
                    while(!lock_acquired);
                }
                return true;
            }

Beispiel #5

Datei: server.hpp Projekt: maydayzm/Bex

        // 接受连接请求回调
        void on_async_accept(error_code const& ec, socket_ptr sp)
        {
            if (ec)
            {
                if (BOOST_INTERLOCKED_DECREMENT(&accept_count_) == 1 && shutdowning_.is_set())
                    shutdown_sessions();

                return ;
            }

            async_accept(true);

            /// create session
            session_type * session_p = allocate<session_type, allocator>();
            session_ptr session(session_p, BEX_IO_BIND(&this_type::session_deleter, this, _1), allocator());
            session_p->initialize(sp, opts_, callback_);
            session_mgr_.insert(session);
        }

Beispiel #6

Datei: thread_pool.hpp Projekt: coldzhang/Bex

            /// 任务处理函数(线程执行函数)
            void run()
            {
                while ( true )
                {
                    if ( m_taskQueue.empty() )
                    {
                        sys_sleep(1);
                        continue;
                    }

                    Task task;
                    m_taskQueue.pop(task);
                    if ( !task )
                        continue;

                    task();
#if !defined(BEX_SUPPORT_CXX11)
                    BOOST_INTERLOCKED_DECREMENT(&m_unfinished);
#else
                    --m_unfinished;
#endif
                }
            }

Beispiel #7

Datei: condition_variable.hpp Projekt: Habeebah2013/Growing-Neural-Gas

 void remove_waiter()
 {
     BOOST_INTERLOCKED_DECREMENT(&waiters);
 }

Beispiel #8

Datei: session_list_mgr.hpp Projekt: hyg19831230/Bex

 /// 删除
 void erase(session_type * sp)
 {
     BOOST_INTERLOCKED_DECREMENT(&size_);
     typename lock_type::scoped_lock lock(lock_);
     list_.erase(sp);
 }

Beispiel #9

Datei: win32_api.hpp Projekt: BioinformaticsArchive/MulRFRepo

static inline long interlocked_decrement(long volatile *addr)
{  return BOOST_INTERLOCKED_DECREMENT(addr);  }