[osip2,linux] linux 下使用 osip2 编写线程基类

linux posix pthread 中通常会使用到多线程并发运行多个函数实体的情况，osip2 中也提供相同的功能。
大体的流程便是: 声明并实现函数，创建匹配的函数指针，将函数指针指向函数实体，
传入函数指针，传入函数运行需要的参数列表到线程方法中(pthread : thread , osip:osip_create_thread ) , 运行线程。

本文介绍的是如何将 osip2 中线程的创建、运行、空间释放封装到一个类中。
这样在需要使用并发运行多个函数的时候，只需要创建一个类实例，通过该类实例中的成员方法调用便可执行上述的流程。

在这里使用的线程并发方式是 join ，线程的并发方式有: join , detach
简单的举例解释，比如说现有 3 个线程 main 函数，main 函数中另起的两个线程 A , B
join ------->  main 函数会等到 A， B 线程运行结束之后，在终止自己这一主线程
detach----> main 函数的结束不受 A， B线程执行结束所影响

适用场景:
join------>(a = b + c , b = 1+2 , c = 2+3  | main running (a=b+c) , A running (b = 1+2)  , B running (c = 2+3))
这种情况下， main 这一主线程中需要执行计算是需要线程 A 和 线程 B 执行结果的，也就是说有时序性的，并发方式使用 join

detach-----> (a= 1+1 , b= 1+2 , c = 1+3 | main running ( a = 1+1 ) ,A running ( b = 1+2 ) , B running ( c = 1+3 ) )
这种情况下， main ,A ,B 这三个线程所需要执行的计算是互相独立的，没有任何的时序性，并发方式使用 detach 可以将
系统中的并发度增加到最大，可以充分利用系统资源

实例代码如下:

---

---

1. my_pipe.h && 2. my_pipe.cpp : linker 

3. ThreadLoader.h

#ifndef THREAD_BASE_H__
#define THREAD_BASE_H__

#include "my_pipe.h"

class ThreadLoader
{
public :
    void *thread ;
    myPipe wakeup ;
public :
    ThreadLoader () ;
    ~ThreadLoader () ;

    int ThreadRelease () ;
    int ThreadStart ( void *(*loader)(void*) , void *arg_list) ;
    int ThreadWakeUp () ;

    int ThreadPrintState () ;

} ;

#endif

4. ThreadLoader.cpp

#ifndef OSIP_MT
#define OSIP_MT
#endif

#include <osip2/osip_mt.h>
#include <osip2/osip_condv.h>
#include <osip2/osip.h>
#include <osipparser2/osip_port.h>

#include <stdio.h>
#include <stdlib.h>

#include "ThreadLoader.h"
#include "my_pipe.h"

//--------------------------

ThreadLoader::ThreadLoader () : wakeup()
{
  thread = NULL ;
}

ThreadLoader::~ThreadLoader ()
{
  if ( thread != NULL )
  {
    ThreadRelease () ;
    perror ("release method always called before free method") ;
    return ;
  }
}


int ThreadLoader::ThreadRelease ()
{
   char c_exit[19] = "thread obj release";
   int len ;

   if ( thread == NULL )
    return 0 ;

   len = wakeup.write_in_pipe (&c_exit, 18) ;

   if ( len != 18 )
   {
    perror ("write_in_pipe method goes error ") ;
    return -1 ;
   }

   len = osip_thread_join (( struct osip_thread*)thread ) ;

   if ( len != 0 )
   {
    perror ("osip_thread_join method goes wrong") ;
    return -1 ;
   }

   free ( thread ) ;
   thread = NULL ;

   return 0 ;
}

int ThreadLoader::ThreadStart ( void *(*loader)(void *) , void *arg_list )
{
   if ( loader == NULL )
    return -1 ;
   thread = (void*)osip_thread_create ( 20000 , loader , arg_list ) ;

   if ( thread == NULL )
    return -1 ;

   return 0 ;
}


int ThreadLoader::ThreadWakeUp ()
{
    int ret ;
    char c_wake[15] = "thread wake up" ;

    ret = wakeup.write_in_pipe( &c_wake, 14 ) ;

     if ( ret != 14 )
    {
       perror ("write_in_pipe method goes wrong") ;
        return -1 ;
    }

    return 0 ;
}

int ThreadLoader::ThreadPrintState ()
{
    int ret ;
    char c_contents [1024] ;

    ret = wakeup.read_from_pipe ( &c_contents , 1024) ;

        c_contents[ret] = '\0' ;

    if ( ret <= 0 )
    {
        perror ("read_from_pipe method goes wrong") ;
        return -1 ;
    }

    printf("pipe contents : %s \n\n",c_contents ) ;

     return 0 ;
}

5. Main.cpp

#include <cstdio>
#include <iostream>
#include <string>
#include <pthread.h>

#include "ThreadLoader.h"

using namespace std ;

void* sayHi ( void *name )
{

  cout << "hi "<< (const char*)name << endl ;
  return NULL ;
}

void* sayHello ( void* name )
{
   cout << "hi " << (const char*)name << endl ;
   return NULL ;
}

typedef void*(*func_ptr_t )(void*) ;


int main ( int argc , char **argv )
{
  string name ;
  ThreadLoader loader1 , loader2 ;

  func_ptr_t hello_ptr ,hi_ptr ;

  hello_ptr = sayHello ;
  hi_ptr = sayHi ;

  cout << "test start method "<< endl ;

  cout << "name" << endl ;
  cin >> name ;

  loader1.ThreadStart (hi_ptr, (void*)name.c_str()) ;

  sleep (2) ;


  cout << "\n\nname" << endl ;
  cin >> name ;
  loader2.ThreadStart ( hello_ptr , (void*)name.c_str()) ;
  sleep (2) ;


  cout << "here we test wake up method" << endl ;
  loader1.ThreadWakeUp () ;
  loader2.ThreadWakeUp () ;

// cout << "print pipe pair contents tests "<< endl ;
// loader1.ThreadPrintState () ;
// loader2.ThreadPrintState () ;

  cout << "test release method "<< endl ;
  loader1.ThreadRelease () ;
  loader2.ThreadRelease () ;

  cout << "print pipe pair contents tests "<< endl ;
  loader1.ThreadPrintState () ;
  loader2.ThreadPrintState () ;


  return 0 ;
}

end