Created ProducerConsumerQueue

ProducerConsumerQueue.cpp

@@ -3,3 +3,45 @@
 //
 
 #include "ProducerConsumerQueue.h"
+
+template <class T>
+void ProducerConsumerQueue<T>::Push(T obj)
+{
+    pthread_mutex_lock(&m);
+
+    queue.push(obj);
+
+    if(queue.size() == 1)
+    {
+        pthread_cond_signal(&consumer_cv);
+    }
+
+    pthread_mutex_unlock(&m);
+}
+
+template <class T>
+T ProducerConsumerQueue<T>::Pop()
+{
+    pthread_mutex_lock(&m);
+
+    while(queue.empty() == true)
+    {
+        pthread_cond_wait(&consumer_cv, &m);
+    }
+
+    T front = queue.front();
+    queue.pop();
+
+    pthread_mutex_unlock(&m);
+
+    return front;
+}
+
+template <class T>
+size_t ProducerConsumerQueue<T>::Size()
+{
+    pthread_mutex_lock(&m);
+    size_t size = queue.size();
+    pthread_mutex_unlock(&m);
+    return size;
+}
\ No newline at end of file

ProducerConsumerQueue.h

@@ -5,8 +5,27 @@
 #ifndef EECS398_SEARCH_PRODUCERCONSUMERQUEUE_H
 #define EECS398_SEARCH_PRODUCERCONSUMERQUEUE_H
 
+#include <queue>
+#include <pthread.h>
 
-class ProducerConsumerQueue {
+//for now use STL queue, create better one later
+
+
+template <class T> class ProducerConsumerQueue {
+private:
+    std::queue<T> queue;
+    pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;
+    pthread_cond_t consumer_cv = PTHREAD_COND_INITIALIZER;
+
+public:
+
+    ProducerConsumerQueue() {}
+    void Push(T obj);
+    T Pop();
+    size_t Size();
+
+    //Right now these pass objects by value but
+    // probably should pass pointers in future
 
 };
 

ProducerConsumerQueue_test.cpp

-//
+///
 // Created by Ben Bergkamp on 1/25/18.
 //
 
+#include <iostream>
+#include <stdlib.h>
+#include <pthread.h>
+#include "ProducerConsumerQueue.h"
+#include "ProducerConsumerQueue.cpp" // needed here because class is a template
+
+pthread_mutex_t cout_lock = PTHREAD_MUTEX_INITIALIZER;
+
+void* Producer(void* p)
+{
+    ProducerConsumerQueue<int> * queue = (ProducerConsumerQueue<int>*)p;
+
+    for(int i = 0; i < 10; i++)
+    {
+        if(queue->Size()){
+            pthread_yield_np(); // let the consumer thread run
+        }
+
+        queue->Push(i);
+
+        pthread_mutex_lock(&cout_lock);
+        std::cout << "Pushed: " << i << "\n";
+        pthread_mutex_unlock(&cout_lock);
+    }
+
+    return p;
+}
+
+void* Consumer(void* p)
+{
+    ProducerConsumerQueue<int> * queue = (ProducerConsumerQueue<int>*)p;
+
+    for(int i = 0; i < 10; i++)
+    {
+        int r = queue->Pop();
+
+        pthread_mutex_lock(&cout_lock);
+        std::cout << "Popped: " << r << "\n";
+        pthread_mutex_unlock(&cout_lock);
+    }
+
+    return p;
+}
+
+
+
+int main(int argc, const char * argv[])
+{
+    ProducerConsumerQueue<int>* queue = new(ProducerConsumerQueue<int>);
+
+    pthread_t producer, consumer;
+
+    pthread_mutex_lock(&cout_lock);
+    std::cout << "Creating Consumer\n";
+    pthread_mutex_unlock(&cout_lock);
+    pthread_create(&consumer, NULL, Consumer, queue);
+
+    pthread_mutex_lock(&cout_lock);
+    std::cout << "Creating Producer\n";
+    pthread_mutex_unlock(&cout_lock);
+    pthread_create(&producer, NULL, Producer, queue);
+
+    pthread_mutex_lock(&cout_lock);
+    std::cout << "Waiting for Producer and Consumer\n";
+    pthread_mutex_unlock(&cout_lock);
+    pthread_join(producer, NULL);
+    pthread_join(consumer, NULL);
+
+    delete queue;
+
+    return 0;
+}
\ No newline at end of file