bugtest.c

用c++包装好的线程库,直接拿来使用,提高效率.

#include <thread.h>
#include <threads/exception.h>
#include <iostream>
#include <map>
#include <deque>
#include <string>

extern "C" {

#include <errno.h>

};

using namespace std;

class Var {
public:
  Var() { }
  virtual ~Var() { }
  virtual unsigned int sizeOf() const = 0;
};

class VarInt : public Var {
  int t;
public:
  VarInt() : Var(), t(0) { }
  VarInt(int newT) : Var(), t(newT) { }
  virtual ~VarInt() { }
  void set(int newT) { t = newT; }
  int get() const { return t; }
  virtual unsigned int sizeOf() const { return sizeof(int); }
};

class VarHolder {
  map<string,Var *> data;
  typedef map<string,Var *>::const_iterator dataConstIter;
public:
  VarHolder() { }
  ~VarHolder() { }
  // New copy constructor
  VarHolder(const VarHolder &newT) {
    string name;
    dataConstIter begin = newT.data.begin();
    dataConstIter end = newT.data.end();
    while(begin != end) {
      name = begin->first;
      set(name, newT.get(name));
      begin++;
    }
  }
  bool varExists(const string& name) const {
    dataConstIter iter = data.find(name);
    if(iter == data.end()) return false;
    return true;
  }
  void set(const string& name, int t) {
    if(varExists(name)) delete data[name];
    data[name] = new VarInt(t);
  }
  int get(const string& name) const {
    if(!varExists(name)) return 0;          
    dataConstIter iter = data.find(name);
    VarInt *dt = dynamic_cast<VarInt *>(iter->second);
    if(dt == 0) return 0;
    return dt->get();
  }
  void erase(const string& name) {
    if(varExists(name)) delete data[name];
  }
  void clear() {
    data.clear();
  }
};

class VarQueue {
  deque<VarHolder> q;
  cpp_threads::Mutex* q_mutex;

public:
  VarQueue() {
    q_mutex = new
      cpp_threads::Mutex(cpp_threads::attributes::process_private_e);
    q_mutex->kind(cpp_threads::Mutex::recursive_e);
  }
  ~VarQueue() {
    delete q_mutex;
  }
  
  void put(const VarHolder& t) {
    q_mutex->lock();
    q.push_front(t);
    q_mutex->unLock();
  }
  
  VarHolder get() {
    VarHolder t;
    
    // check the number of elements in the queue, return empty VarHolder if queue is empty
    if(!q.size()) return t;
    // Make the iterator, lock things up, pull the VarHolder from the queue
    deque<VarHolder>::iterator iter;
    q_mutex->lock();
    iter = q.end();
    iter--;                         // Move to last element
    t = *iter;
    q.pop_back();
    q_mutex->unLock();
    
    return t;
  }
} varqueue;
        
class worker : public cpp_threads::Pthread {
public:
  worker() : cpp_threads::Pthread() { }
protected:
  int thread(void*) {
    VarHolder t;
    for(int count = 0; count < 100000; count++) {
      cout << "WorkerThread: " << count << endl;
      t.clear();
      t.set("#: ", count);
      varqueue.put(t);
    }
    return 0;
  }
};

int main(int argc, char* argv[]) {
        
  cpp_threads::Pthread* workerThread = new worker;
  workerThread->run();
        
  VarHolder t;
  for(int count = 0; count < 100000; count++) {
    cout << "MainThread: " << count << endl;
    t.clear();
    t.set("#: ", count);
    varqueue.put(t);
  }

  cout << "MainThread done.\n";
  workerThread->join();
  cout << "WorkerThread done.\n";

  return 0;
}