Блог

Я попытался реализовать обратный отсчет, используя повышающие мьютексы и переменную условия. Ниже приведен код, и я хотел бы знать, нужно ли мне добавить что-нибудь еще.

Как я могу также модульно протестировать этот код?

 template< class TypeVal >
    class AtomicCounter
    {
    public:
        AtomicCounter( TypeVal val ) : m_typeVal( val ) 
        {
        }

        AtomicCounter() : m_typeVal(0)
        {
        }

        AtomicCounter(const AtomicCounteramp; cpy) : m_typeVal(cpy.m_typeVal)
        {   
            boost::mutex::scoped_lock scoped_lock(cpy.m_atomicMutex);
            m_typeVal = cpy.m_typeVal;
        }

        const AtomicCounteramp; operator=(const AtomicCounteramp; other)
        {
           if (this == amp;other)
              return *this;
           boost::mutex::scoped_lock lock1(amp;m_atomicMutex < amp;other.m_atomicMutex ? m_atomicMutex : other.m_atomicMutex);
           boost::mutex::scoped_lock lock2(amp;m_atomicMutex > amp;other.m_atomicMutex ? m_atomicMutex : other.m_atomicMutex);
           m_typeVal = other.m_typeVal;
           return *this;
        }

        virtual ~AtomicCounter() 
        {
        }

        const TypeValamp; getCount() const
        { 
            boost::mutex::scoped_lock lock( m_atomicMutex ); 
            return m_typeVal; 
        }

        const TypeValamp; setCount( const TypeVal amp;val ) 
        { 
            boost::mutex::scoped_lock lock( m_atomicMutex ); 
            m_typeVal = val; 
            return m_typeVal; 
        }

        const TypeValamp; increment() 
        { 
            boost::mutex::scoped_lock lock( m_atomicMutex ); 
            m_typeVal   ; 
            return m_typeVal; 
        }

        const TypeValamp; decrement() 
        { 
            boost::mutex::scoped_lock lock( m_atomicMutex ); 
            m_typeVal-- ; 
            return m_typeVal; 
        }

        const TypeValamp; increment(const TypeValamp; t) 
        { 
            boost::mutex::scoped_lock lock( m_atomicMutex ); 
            m_typeVal =t ; 
            return m_typeVal; 
        }

        const TypeValamp; decrement(const TypeValamp; t) 
        { 
            boost::mutex::scoped_lock lock( m_atomicMutex ); 
            m_typeVal-=t ; 
            return m_typeVal; 
        }


    private:
        mutable boost::mutex m_atomicMutex;
        TypeVal m_typeVal;
    };

           class CountDownLatch
    {
    public:
        CountDownLatch( int count ): m_cdlCount( count ) 
        {
        }

        CountDownLatch(const CountDownLatchamp; cpy)
        {
             boost::unique_lock<boost::mutex>::unique_lock(const_cast<boost::mutexamp;>(cpy.m_cdlMutex));
            m_cdlCount = cpy.m_cdlCount;
        }

        const CountDownLatchamp; operator=(const CountDownLatchamp; other)
        {
           if (this == amp;other)
              return *this;
           boost::mutex::scoped_lock lock1(const_cast<boost::mutexamp;>(amp;m_cdlMutex < amp;other.m_cdlMutex ? m_cdlMutex : other.m_cdlMutex));
           boost::mutex::scoped_lock lock2(const_cast<boost::mutexamp;>(amp;m_cdlMutex > amp;other.m_cdlMutex ? m_cdlMutex : other.m_cdlMutex));
           m_cdlCount = other.m_cdlCount;
           return *this;
        }

        virtual ~CountDownLatch() 
        {
        }
        void wait() 
        { 
            boost::mutex::scoped_lock lock( m_cdlMutex ); 
            if( m_cdlCount.getCount() > 0 ) 
            { 
                m_cdlCondition.wait( lock ); 
            } 
        }
        void wait( uint64_t timeoutMicros ) 
        { 
            boost::mutex::scoped_lock lock( m_cdlMutex ); 
            if( m_cdlCount.getCount() > 0 ) 
            {
                boost::posix_time::time_duration td = boost::posix_time::milliseconds( timeoutMicros ); 
                m_cdlCondition.timed_wait( lock, td ); 
            } 
        }
        void countDown() 
        {  
            boost::mutex::scoped_lock lock( m_cdlMutex ); 
            if( m_cdlCount.decrement() == 0 ) 
            { 
                m_cdlCondition.notify_all(); 
            } 
        }

        int getCount()
        {
            return m_cdlCount.getCount();
        }


    private:
        boost::mutex m_cdlMutex;
        boost::condition_variable m_cdlCondition;
        AtomicCounter< int >  m_cdlCount;           
    };
  

Для модульного тестирования вы можете попробовать стресс-тестирование. Например, для обратного отсчета создайте 25 тестовых потоков, которые одновременно вызывают CountDownLatch::countDown() , 25 других потоков, которые одновременно вызывают CountDownLatch::getCount() , и 25 других потоков, которые вызывают CountDownLatch::wait() . Чтобы сделать процесс более одновременным, используйте барьер или переводите потоки в режим ожидания до того же абсолютного времени. Убедитесь, что все потоки завершаются должным образом (без взаимоблокировок), объединив их все. Убедитесь, что CountDownLatch::m_cdlCount значение равно нулю.

Запускайте один и тот же тест много раз (в течение разумного промежутка времени).

Вы можете использовать ту же основную идею для AtomicCounter.

Вероятно, существуют другие методы тестирования многоглавого кода, но это тот, с которым я наиболее знаком.