1. pj_status_t status;

2. status = pj_init();         //初始化pjlib库返回PJ_SUCCESS表示成功

3. status = pjlib_util_init(); //初始化pjlib-util库

4. status = pjnath_init();     //初始化pjnath库

5. status = pjsua_create();    //初始化pjsua-lib库;(里面初始化了pjlib,pjlib-util,pjnath) 

6.  

7. pj_shutdown();    //pjlib停止

8. pjsua_destroy();  //pjsua-lib库的清理
    

1. //系统初始化的时候调用

2. void create()
   

3. {
   

4. //初始化pjlib库返回PJ_SUCCESS表示成功
   

5. pj_status_t status = pj_init(); 
   

6.  

7. pj_caching_pool_init(&this->m_caching, NULL, 0);
   

8. this->m_pool = pj_pool_create(&this->m_caching.factory, "", 256, 256, NULL);
   

9.  

10.  //初始化mutex
    

11. pj_mutex_create(this->m_pool, "", PJ_MUTEX_SIMPLE, &this->m_pool_mutex);
    

12.  

13.  //创建一个lock给定时器用
    

14. pj_lock_create_simple_mutex(this->m_pool, "timer_lock", &this->timer_heap_lock);
    

15.  

16.  //在内存池上开辟一块空间
    

17. char *pmem = (char*)pj_pool_alloc(this->m_pool, 1024); 
    

18.  

19.  //创建一个定时器堆
    

20. pj_timer_heap_create(this->m_pool, MAX_TIMER_COUTN, &this->timer_heap);
    

21.  

22.  //给定时器加锁; 将来自动删除该锁，无需手工删除
    

23. pj_timer_heap_set_lock(this->timer_heap, this->timer_heap_lock, true);
    

24.  }
    

25.  

26.  //系统退出的时候调用
    

27. void destroy()
    

28.  {
    

29.  //删除mutex
    

30. pj_mutex_destroy(this->m_pool_mutex);
    

31.  

32.  //删除定时器的堆
    

33. pj_timer_heap_destroy(this->timer_heap);
    

34.  

35.  //清理内存池，这一步也可以删略；让caching_pool来清理
    

36. pj_pool_destroy_int(this->m_pool); 
    

37.  

38.  //清理缓冲池；所有在缓冲池建立的内存池都会被清理掉
    

39. pj_caching_pool_destroy(&this->m_caching);
    

40.  

41.  //pjlib停止
    

42. pj_shutdown();
    

43.  }
    

1. pj_thread_desc desc;

2. pj_bzero(desc, sizeof(desc));
   

3. pj_thread_t *thread_;
   

4. if (pj_thread_register("", desc, &thread_) != PJ_SUCCESS) 
   

5.     return 0; /* 失败*/ 
   

   2: {

   3:     //1.实现一个int ()(void*)的函数，且在结束的地方设置m_thread_t=NULL

   4:     pj_thread_t *m_thread_t;

   5: protected:

   6:  

   7:     /* int (pj_thread_proc)(void*);

   8:     * 线程函数；子类需要使用static函数来实现

   9:     * 子类函数中在结束的时候：必须将m_thread_t = NULL;

  10:     */

  11:     pj_thread_proc *m_thread_function;

  12:  

  13:     /* 这个是实现函数；

  14:     * 子类需要实现一个run()的函数；在run函数中调用run_父类的函数

  15:     */

  16:     virtual void run_(pj_pool_t *pool, pj_thread_proc *function);

  17: public:

  18:     CSipThread();

  19:     virtual ~CSipThread();

  20:     virtual bool thread_running();

  21:  

  22:     //等待线程结束，自动释放资源，且会将m_thread_t=NULL

  23:     virtual void thread_join();

  24:  

  25:     //在线程自己退出的时候，没有需要手工释放资源，和设置m_thread_t=NULL

  26:     virtual void thread_destroy();

  27: };

  28: CSipThread::CSipThread()

  29: {

  30:     this->m_thread_t = NULL;

  31: }

  32: CSipThread::~CSipThread()

  33: {

  34:  

  35: }

  36: void CSipThread::run_(pj_pool_t *pool, pj_thread_proc *function)

  37: {

  38:     if ( this->thread_running())

  39:         return;

  40:     pj_status_t status = pj_thread_create(pool, "", function, this, 

  41:         PJ_THREAD_DEFAULT_STACK_SIZE, NULL, &this->m_thread_t);

  42:     if (status != PJ_SUCCESS)

  43:     {

  44:         CFunctions::write_log(LM_ERROR, "Can't create timer thread. [result=%d]..\n", status);

  45:     }

  46: }

  47: bool CSipThread::thread_running()

  48: {

  49:     if (this->m_thread_t == NULL)

  50:         return false;

  51:     else

  52:         return true;

  53: }

  54:  

  55: void CSipThread::thread_join()

  56: {

  57:     if (this->m_thread_t == NULL)

  58:         return;

  59:  

  60:     // 等待线程结束

  61:     pj_thread_join(this->m_thread_t);

  62: }

  63:  

  64: void CSipThread::thread_destroy()

  65: {

  66:     pj_thread_destroy(this->m_thread_t);

  67:     this->m_thread_t = NULL;

  68: }

   2: * 1. 必须定义一个static的静态函数

   3: * 2. 在静态函数结束的时候必须调用thread_destroy();

   4: */

   5: class CSendThread : public CSipThread

   6: {

   7:     //线程函数；在函数退出的时候必须调用thread_destroy();

   8:     static int thread_func(void * argv);

   9: public:

  10:     CSendThread(void);

  11:     virtual ~CSendThread(void);

  12:  

  13:     //再次封装了run_函数

  14:     void run();

  15: }

  16:  

  17: void CSendThread::run()

  18: {

  19:     if ( this->thread_running())

  20:         return;

  21:  

  22:     SIP_GUARD(CInterFace::instance()->m_pool_mutex, obj);

  23:  

  24:     //调用父类的run_函数进行创建函数，开始运行；注意如果线程已经存在，那么直接返回

  25:     //不会再创建一个线程

  26:     this->run_(CInterFace::instance()->m_pool, &CSendThread::thread_func);

  27: }

  28:  

  29: int CSendThread::thread_func(void * argv)

  30: {

  31:     // 线程函数的参数默认是当前对象，等同于this指针

  32:     CSendThread *this_thread = (CSendThread*)argv;

  33:  

  34: thread_end:

  35:     // 在线程结束的时候，一定要调用thread_destroy();来删除线程

  36:     this_thread->thread_destroy();

  37:     return 0;

  38: }