mysql_thr.c
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:6k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Testing of connecting to MySQL from X threads */
  2. #include <windows.h>
  3. #include <process.h>
  4. #include <stdio.h>
  5. #include <mysql.h>
  6. #include <errno.h>
  7. #define TEST_COUNT 20
  8. /*****************************************************************************
  9. ** The following is to emulate the posix thread interface
  10. *****************************************************************************/
  11. typedef HANDLE  pthread_t;
  12. typedef struct thread_attr {
  13. DWORD dwStackSize ;
  14. DWORD dwCreatingFlag ;
  15. int priority ;
  16. } pthread_attr_t ;
  17. typedef struct { int dummy; } pthread_condattr_t;
  18. typedef unsigned int uint;
  19. typedef struct {
  20.   uint waiting;
  21.   HANDLE semaphore;
  22. } pthread_cond_t;
  23. typedef CRITICAL_SECTION pthread_mutex_t;
  24. #define pthread_mutex_init(A,B)  InitializeCriticalSection(A)
  25. #define pthread_mutex_lock(A)    (EnterCriticalSection(A),0)
  26. #define pthread_mutex_unlock(A)  LeaveCriticalSection(A)
  27. #define pthread_mutex_destroy(A) DeleteCriticalSection(A)
  28. #define pthread_handler_decl(A,B) unsigned __cdecl A(void *B)
  29. typedef unsigned (__cdecl *pthread_handler)(void *);
  30. #define pthread_self() GetCurrentThread()
  31. static unsigned int thread_count;
  32. static pthread_cond_t COND_thread_count;
  33. static pthread_mutex_t LOCK_thread_count;
  34. pthread_mutex_t THR_LOCK_malloc,THR_LOCK_open,THR_LOCK_keycache,
  35. THR_LOCK_lock,THR_LOCK_isam;
  36. /*
  37. ** We have tried to use '_beginthreadex' instead of '_beginthread' here
  38. ** but in this case the program leaks about 512 characters for each
  39. ** created thread !
  40. */
  41. int pthread_create(pthread_t *thread_id, pthread_attr_t *attr,
  42.    pthread_handler func, void *param)
  43. {
  44.   HANDLE hThread;
  45.  
  46.   hThread=(HANDLE)_beginthread(func,
  47.        attr->dwStackSize ? attr->dwStackSize :
  48.        65535,param);
  49.   if ((long) hThread == -1L)
  50.   {
  51.     return(errno ? errno : -1);
  52.   }
  53.   *thread_id=hThread;
  54.   return(0);
  55. }
  56. void pthread_exit(unsigned A)
  57. {
  58.   _endthread();
  59. }
  60. /*
  61. ** The following simple implementation of conds works as long as
  62. ** only one thread uses pthread_cond_wait at a time.
  63. ** This is coded very carefully to work with thr_lock.
  64. */
  65. /*****************************************************************************
  66. ** The following is a simple implementation of posix conditions
  67. *****************************************************************************/
  68. int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr)
  69. {
  70.   cond->waiting=0;
  71.   cond->semaphore=CreateSemaphore(NULL,0,0x7FFFFFFF,(char*) 0);
  72.   if (!cond->semaphore)
  73.     return ENOMEM;
  74.   return 0;
  75. }
  76. int pthread_cond_destroy(pthread_cond_t *cond)
  77. {
  78. return CloseHandle(cond->semaphore) ? 0 : EINVAL;
  79. }
  80. int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
  81. {
  82.   InterlockedIncrement(&cond->waiting);
  83.   LeaveCriticalSection(mutex);
  84.   WaitForSingleObject(cond->semaphore,INFINITE);
  85.   InterlockedDecrement(&cond->waiting);
  86.   EnterCriticalSection(mutex);
  87.   return 0 ;
  88. }
  89. int pthread_cond_signal(pthread_cond_t *cond)
  90. {
  91.   long prev_count;
  92.   if (cond->waiting)
  93.     ReleaseSemaphore(cond->semaphore,1,&prev_count);
  94.   return 0;
  95. }
  96. int pthread_attr_init(pthread_attr_t *connect_att)
  97. {
  98.   connect_att->dwStackSize = 0;
  99.   connect_att->dwCreatingFlag = 0;
  100.   connect_att->priority = 0;
  101.   return 0;
  102. }
  103. int pthread_attr_setstacksize(pthread_attr_t *connect_att,DWORD stack)
  104. {
  105.   connect_att->dwStackSize=stack;
  106.   return 0;
  107. }
  108. int pthread_attr_setprio(pthread_attr_t *connect_att,int priority)
  109. {
  110.   connect_att->priority=priority;
  111.   return 0;
  112. }
  113. int pthread_attr_destroy(pthread_attr_t *connect_att)
  114. {
  115.   return 0;
  116. }
  117. /* from my_pthread.c */
  118. #ifndef REMOVE_BUG
  119. __declspec(thread) int THR_KEY_my_errno;
  120. int _my_errno(void)
  121. {
  122.   return THR_KEY_my_errno;
  123. }
  124. #endif
  125. /*****************************************************************************
  126. ** The test program
  127. *****************************************************************************/
  128. pthread_handler_decl(test_thread,arg)
  129. {
  130.   MYSQL mysql;
  131.   MYSQL_RES *res;
  132.   mysql_init(&mysql);
  133.   if (!mysql_real_connect(&mysql,NULL,0,0,NULL,0,NULL,0))
  134.   {
  135.     fprintf(stderr,"Couldn't connect to engine!n%snn",mysql_error(&mysql));
  136.     perror("");
  137.     goto end;
  138.   }
  139.   if (mysql_query(&mysql,"select 1") < 0)
  140.   {
  141.     fprintf(stderr,"Query failed (%s)n",mysql_error(&mysql));
  142.     goto end;
  143.   }
  144.   if (!(res=mysql_store_result(&mysql)))
  145.   {
  146.     fprintf(stderr,"Couldn't get result from query failedn",
  147.     mysql_error(&mysql));
  148.     goto end;
  149.   }
  150.   mysql_free_result(res);
  151. end:
  152.   Sleep(1000); /* Win32 sleep */
  153.   mysql_close(&mysql);
  154.   pthread_mutex_lock(&LOCK_thread_count);
  155.   thread_count--;
  156.   pthread_cond_signal(&COND_thread_count); /* Tell main we are ready */
  157.   pthread_mutex_unlock(&LOCK_thread_count);
  158.   pthread_exit(0);
  159.   return 0;
  160. }
  161. int main(int argc,char **argv)
  162. {
  163.   pthread_t tid;
  164.   pthread_attr_t thr_attr;
  165.   int i,error;
  166.   if ((error=pthread_cond_init(&COND_thread_count,NULL)))
  167.   {
  168.     fprintf(stderr,"Got error: %d from pthread_cond_init (errno: %d)",
  169.     error,errno);
  170.     exit(1);
  171.   }
  172.   pthread_mutex_init(&LOCK_thread_count,NULL);
  173.   if ((error=pthread_attr_init(&thr_attr)))
  174.   {
  175.     fprintf(stderr,"Got error: %d from pthread_attr_init (errno: %d)",
  176.     error,errno);
  177.     exit(1);
  178.   }
  179.   if ((error=pthread_attr_setstacksize(&thr_attr,65536L)))
  180.   {
  181.     fprintf(stderr,"Got error: %d from pthread_attr_setstacksize (errno: %d)",
  182.     error,errno);
  183.     exit(1);
  184.   }
  185.   printf("Init ok. Creating %d threadsn",TEST_COUNT);
  186.   for (i=1 ; i <= TEST_COUNT ; i++)
  187.   {
  188.     int *param= &i;
  189.     if ((error=pthread_mutex_lock(&LOCK_thread_count)))
  190.     {
  191.       fprintf(stderr,"nGot error: %d from pthread_mutex_lock (errno: %d)",
  192.       error,errno);
  193.       exit(1);
  194.     }
  195.     if ((error=pthread_create(&tid,&thr_attr,test_thread,(void*) param)))
  196.     {
  197.       fprintf(stderr,"nGot error: %d from pthread_create (errno: %d)n",
  198.       error,errno);
  199.       pthread_mutex_unlock(&LOCK_thread_count);
  200.       exit(1);
  201.     }
  202.     thread_count++;
  203.     pthread_mutex_unlock(&LOCK_thread_count);
  204.   }
  205.   if ((error=pthread_mutex_lock(&LOCK_thread_count)))
  206.     fprintf(stderr,"nGot error: %d from pthread_mutex_lockn",error);
  207.   while (thread_count)
  208.   {
  209.     if ((error=pthread_cond_wait(&COND_thread_count,&LOCK_thread_count)))
  210.       fprintf(stderr,"nGot error: %d from pthread_cond_waitn",error);
  211.   }
  212.   pthread_mutex_unlock(&LOCK_thread_count);
  213.   pthread_attr_destroy(&thr_attr);
  214.   printf("nendn");
  215.   return 0;
  216. }