acl::tbox_array< T > 模板类 参考

#include <tbox_array.hpp>

类 acl::tbox_array< T > 继承关系图:

acl::tbox_array< T > 的协作图:

Public 成员函数
	tbox_array (bool free_obj=true)
	~tbox_array (void)
void	clear (bool free_obj=false)
bool	push (T *t, bool notify_first=false)
T *	pop (int wait_ms=-1, bool *found=NULL)
size_t	size (void) const
void	lock (void)
void	unlock (void)

额外继承的成员函数
Protected 成员函数 继承自 acl::acl::noncopyable
	noncopyable ()
	~noncopyable ()

详细描述

template<typename T>
class acl::tbox_array< T >

用于线程之间的消息通信，通过线程条件变量及线程锁实现

示例：

class myobj { public: myobj(void) {} ~myobj(void) {}

void test(void) { printf("hello world\r\n"); } };

acl::tbox_array<myobj> tbox;

void thread_producer(void) { myobj* o = new myobj; tbox.push(o); }

void thread_consumer(void) { myobj* o = tbox.pop(); o->test(); delete o; }

在文件 tbox_array.hpp 第 44 行定义.

构造及析构函数说明

tbox_array()

template<typename T >

acl::tbox_array< T >::tbox_array ( bool  free_obj = true )

inline

构造方法

参数

free_obj

{bool} 当 tbox_array 销毁时，是否自动检查并释放 未被消费的动态对象

在文件 tbox_array.hpp 第 52 行定义.

        : capacity_(10000)
        , off_curr_(0)
        , off_next_(0)
        , waiters_(0)
        , free_obj_(free_obj)
        , cond_(&lock_)
        {
                array_ = (T**) malloc(sizeof(T*) * capacity_);
        }

~tbox_array()

template<typename T >

acl::tbox_array< T >::~tbox_array ( void  )

inline

在文件 tbox_array.hpp 第 63 行定义.

        {
                clear(free_obj_);
                free(array_);
        }

引用了 acl::tbox_array< T >::clear().

函数调用图:

成员函数说明

clear()

template<typename T >

void acl::tbox_array< T >::clear ( bool  free_obj = false )

inline

清理消息队列中未被消费的消息对象

参数

free_obj

{bool} 释放调用 delete 方法删除消息对象

在文件 tbox_array.hpp 第 73 行定义.

        {
                if (free_obj) {
                        for (size_t i = off_curr_; i < off_next_; i++) {
                                delete array_[i];
                        }
                }
        }

被这些函数引用 acl::tbox_array< T >::~tbox_array().

这是这个函数的调用关系图:

lock()

template<typename T >

void acl::tbox_array< T >::lock ( void  )

inline

在文件 tbox_array.hpp 第 194 行定义.

        {
                if (lock_.lock() == false) {
                        abort();
                }
        }

引用了 acl::thread_mutex::lock().

函数调用图:

pop()

template<typename T >

T* acl::tbox_array< T >::pop ( int  wait_ms = -1, bool *  found = NULL  )

inline

接收消息对象

参数

wait_ms	{int} >= 0 时设置等待超时时间(毫秒级别)， 否则永远等待直到读到消息对象或出错
found	{bool*} 非空时用来存放是否获得了一个消息对象，主要用在 当允许传递空对象时的检查

返回

{T*} 非 NULL 表示获得一个消息对象，返回 NULL 时得需要做进一 步检查，生产者如果 push 了一个空对象（NULL），则消费者也会获得 NULL， 但此时仍然认为获得了一个消息对象，只不过为空对象；如果 wait_ms 参数 为 -1 时返回 NULL 依然认为获得了一个空消息对象，如果 wait_ms 大于 等于 0 时返回 NULL，则应该检查 found 参数的值为 true 还是 false 来 判断是否获得了一个空消息对象

在文件 tbox_array.hpp 第 148 行定义.

        {
                long long n = ((long long) wait_ms) * 1000;
                bool found_flag;

                if (lock_.lock() == false) {
                        abort();
                }
                while (true) {
                        T* t = peek(found_flag);
                        if (found_flag) {
                                if (lock_.unlock() == false) {
                                        abort();
                                }
                                if (found) {
                                        *found = found_flag;
                                }
                                return t;
                        }

                        // 注意调用顺序，必须先调用 wait 再判断 wait_ms
                        waiters_++;
                        if (!cond_.wait(n, true) && wait_ms >= 0) {
                                waiters_--;
                                if (lock_.unlock() == false) {
                                        abort();
                                }
                                if (found) {
                                        *found = false;
                                }
                                return NULL;
                        }
                        waiters_--;
                }
        }

引用了 acl::thread_mutex::lock(), acl::thread_mutex::unlock() , 以及 acl::thread_cond::wait().

函数调用图:

push()

template<typename T >

bool acl::tbox_array< T >::push ( T *  t, bool  notify_first = false  )

inline

发送消息对象，本过程是添加完对象后先解锁后通知

参数

t	{T*} 非空消息对象
notify_first	{bool} 如果为 true，则先通知后解锁，否则先解锁 后通知，注意二者的区别

返回

{bool}

在文件 tbox_array.hpp 第 89 行定义.

        {
                if (lock_.lock() == false) {
                        abort();
                }

                if (off_next_ == capacity_) {
                        if (off_curr_ >= 10000) {
#if 1
                                size_t n = 0;
                                for (size_t i = off_curr_; i < off_next_; i++) {
                                        array_[n++] = array_[i];
                                }
#else
                                memmove(array_, array_ + off_curr_,
                                        (off_next_ - off_curr_) * sizeof(T*));
#endif

                                off_next_ -= off_curr_;
                                off_curr_ = 0;
                        } else {
                                capacity_ += 10000;
                                array_ = (T**) realloc(array_, sizeof(T*) * capacity_);
                        }
                }
                array_[off_next_++] = t;

                if (notify_first) {
                        if (cond_.notify() == false) {
                                abort();
                        }
                        if (lock_.unlock() == false) {
                                abort();
                        }
                } else {
                        if (lock_.unlock() == false) {
                                abort();
                        }
                        if (cond_.notify() == false) {
                                abort();
                        }
                }

                return true;
        }

引用了 acl::thread_mutex::lock(), acl::thread_cond::notify() , 以及 acl::thread_mutex::unlock().

函数调用图:

size()

template<typename T >

size_t acl::tbox_array< T >::size ( void  ) const

inline

返回当前存在于消息队列中的消息数量

返回

{size_t}

在文件 tbox_array.hpp 第 188 行定义.

        {
                return off_next_ - off_curr_;
        }

unlock()

template<typename T >

void acl::tbox_array< T >::unlock ( void  )

inline

在文件 tbox_array.hpp 第 201 行定义.

        {
                if (lock_.unlock() == false) {
                        abort();
                }
        }

引用了 acl::thread_mutex::unlock().

函数调用图:

---

该类的文档由以下文件生成:

• include/acl_cpp/stdlib/tbox_array.hpp