#include <iostream> 
#include <unistd.h> 
#include <stdlib.h> 
#include <string.h> 
#include <stdio.h> 
#include <vector> 
 
using namespace std; 
 
pthread_mutex_t io_mutex = PTHREAD_MUTEX_INITIALIZER; 
pthread_cond_t io_sync  = PTHREAD_COND_INITIALIZER; 
 
template <typename T1> 
class Queue 
{ 
  private: 
    int MaxSize; 
    int DataIndex; 
    int QueueSize; 
    //T1  *Array; 
    vector<T1> Array; 
    int PushNum; 
  public: 
    // 생성자로써 디폴트 아규먼트로 
    // 큐의 사이즈를 지정했다. 
    // 아규먼트로 넘어온 크기만큼 Array 의 크기를 
    // 할당하고 기타 멤버변수들의 값을 적당히 초기화 한다. 
    Queue(int size=40) 
    { 
      MaxSize = size; 
      QueueSize = 0; 
      DataIndex = 0; 
      PushNum   = 0; 
      Array.resize(size); 
    } 
    // 소멸자 자원을 해제한다. 
    ~Queue() 
    { 
    } 
    // Array에 원소를 입력한다. 
    // 만약에 Array 의 크기를 초과해서 원소가 들어갈경우 
    // MaxSize*2 크기만큼 메모리의 크기를 재할당한다. 
    void push_back(T1 x) 
    { 
      pthread_mutex_lock(&io_mutex); 
      if (QueueSize == 0) 
        pthread_cond_signal(&io_sync); 
      if (QueueSize > MaxSize - 1) 
      { 
        MaxSize *= 2; 
        Array.resize(MaxSize); 
      } 
      Array[PushNum%MaxSize] = x; 
      PushNum++; 
      QueueSize++; 
      pthread_mutex_unlock(&io_mutex); 
    } 
    // 데이타를 꺼낸다. 
    T1 pop() 
    { 
      pthread_mutex_lock(&io_mutex); 
      if (QueueSize == 0) 
      { 
        pthread_cond_wait(&io_sync, &io_mutex); 
      } 
      QueueSize--; 
      DataIndex++; 
      pthread_mutex_unlock(&io_mutex); 
      return Array[(DataIndex-1)%MaxSize]; 
    } 
    // 큐에 있는 데이타의 갯수를 얻어온다. 
    int size() 
    { 
      return QueueSize; 
    } 
    // 큐의 크기를 얻어온다. 
    int capacity() 
    { 
      return MaxSize; 
    } 
    // 원소를 삭제한다. 
    // 실제 데이타를 free 시키지는 않고, Index 
    // 값들을 조정해서 삭제한것 처럼 보이게 한다. 
    void clear() 
    { 
      QueueSize = 0; 
      DataIndex = 0; 
      PushNum   = 0; 
    } 
}; 
 

#include <vector> 
#include <unistd.h> 
#include <signal.h> 
#include <queue.h> 
#include <stdio.h> 
 
#include <pthread.h> 
#include <string> 
 
using namespace std; 
 
Queue<string> MQueue(20); 
 
pthread_mutex_t sync_mutex = PTHREAD_MUTEX_INITIALIZER; 
pthread_cond_t sync_cond  = PTHREAD_COND_INITIALIZER; 
 
void *work_thread(void *rtsnum) 
{ 
  int signum = *((int *)rtsnum); 
 
  // Mutex 동기화 
  pthread_mutex_lock(&sync_mutex); 
  cout << "Sig Num is " << signum << endl; 
  pthread_cond_signal(&sync_cond); 
  pthread_mutex_unlock(&sync_mutex); 
  // -------------------- 
 
  while(1) 
  { 
    cout << MQueue.size() << " : "<< MQueue.pop(); 
    usleep(10); 
  } 
} 
 
int main(int argc, char **argv) 
{ 
  int thread_num = 5; 
 
  vector<void *(*)(void *)> thread_list; 
  vector<pthread_t> tident(thread_num); 
 
  thread_list.push_back(work_thread); 
 
  for (int i = 0, rtsnum = 1; i < thread_list.size(); i++, rtsnum++) 
  { 
    pthread_mutex_lock(&sync_mutex); 
    pthread_create(&tident[i], NULL, thread_list[i], (void *)&rtsnum); 
    pthread_cond_wait(&sync_cond, &sync_mutex); 
    pthread_mutex_unlock(&sync_mutex); 
  } 
 
  char buf[256]; 
 
  int i = 1; 
  while(1) 
  { 
    sprintf(buf, "My Data %d\n", i); 
    MQueue.push_back(buf); 
    // 5번 루프를 돈 후에 1000 msec를 쉬어준다.  
    if ((i % 5) == 0) 
      usleep(1000); 
 
    // 500번 루프를 돈 후에 3초를 쉬어준다.     
    if ((i % 500) == 1) 
      sleep(3); 
    i++; 
  } 
}