fix proc num

Author: chanchann

build.sh renamed to build_debug.sh

@@ -1,5 +1,6 @@
 #include "burger/base/Atomic.h"
 #include <cassert>
+#include <iostream>
 
 int main()
 {
@@ -34,4 +35,18 @@ int main()
         assert(a1.getAndSet(100) == 2);
         assert(a1.get() == 100);
     }
+    {
+        burger::AtomicInt32 a2;
+        if(a2.get()) {
+            std::cout << "a2 is true" << std::endl; 
+        } else {
+            std::cout << "a2 is false" << std::endl;
+        }
+        a2.increment();
+        if(a2.get()) {
+            std::cout << "a2 increment is true" << std::endl; 
+        } else {
+            std::cout << "a2 increment is false" << std::endl;
+        }
+    }
 }

burger/base/tests/Atomic_unittest.cc

@@ -2,7 +2,7 @@
 # add_executable(timestamp_unittest Timestamp_unittest.cc)
 # target_link_libraries(timestamp_unittest burger_base)
 
-# add_executable(atomic_unittest Atomic_unittest.cc)
+add_executable(atomic_unittest Atomic_unittest.cc)
 
 # add_executable(exception_unittest Exception_unittest.cc)
 # target_link_libraries(exception_unittest burger_base)

burger/base/tests/CMakeLists.txt

@@ -44,7 +44,7 @@ CoTcpServer::~CoTcpServer() {
 
 void CoTcpServer::setThreadNum(size_t threadNum) {
     assert(threadNum > 0);
-    sched_->setThreadNum(threadNum);
+    sched_->setWorkProcNum(threadNum);
 }
 
 // 多次调用无害
@@ -61,7 +61,7 @@ void CoTcpServer::setConnectionHandler(const ConnectionHandler& handler) {
 }
 
 void CoTcpServer::startAccept() {
-    while(true) {
+    while(started_.get()) {
         InetAddress peerAddr;
         int connfd = listenSock_->accept(peerAddr);
         if(connfd > 0) {
@@ -75,10 +75,11 @@ void CoTcpServer::startAccept() {
             // 此处跨线程调用
             proc->addTask(std::bind(connHandler_, conn), "connHandler");
         } else {
-            ERROR("in Acceptor::handleRead");
+            ERROR("accept error");
             // 当fd达到上限，先占住一个空的fd,然后当fd满了，就用这个接受然后关闭
             // 这样避免一直水平电平一直触发，先去读走他
             if(errno == EMFILE) {   
+                ERROR("Exceed the maximum fd nums");
                 sockets::close(idleFd_);
                 idleFd_ = ::accept(listenSock_->getFd(), nullptr, nullptr);
                 sockets::close(idleFd_);

burger/net/CoTcpServer.cc

@@ -36,8 +36,12 @@ Scheduler::~Scheduler() {
 }
 
 // before start to call 
-void Scheduler::setThreadNum(size_t threadNum)  {
-    threadNum_ = threadNum;
+void Scheduler::setWorkProcNum(size_t workProcNum) {
+    if(workProcNum > 100) {
+        ERROR("set too many processors");
+        workProcNum_ = 0;
+    }
+    workProcNum_ = workProcNum;
 }
 
 void Scheduler::start() {
@@ -46,10 +50,10 @@ void Scheduler::start() {
     std::unique_ptr<Processor> mainProc = util::make_unique<Processor>(this);
     mainProc_ = mainProc.get();
 
-    for(size_t i = 0; i < threadNum_ - 1; i++) {
-        auto procThrd = std::make_shared<ProcessThread>(this);
-        workThreadVec_.push_back(procThrd);
+    for(size_t i = 0; i < workProcNum_; i++) {
+        auto procThrd = util::make_unique<ProcessThread>(this);
         workProcVec_.push_back(procThrd->startProcess());
+        workThreadVec_.push_back(std::move(procThrd));
     }
     running_ = true;
     cv_.notify_one();  // todo : 无其他线程，有影响吗
@@ -148,7 +152,7 @@ void Scheduler::cancel(TimerId timerId) {
 
 size_t Scheduler::getWorkProcNum() {
     if(workProcVec_.empty()) return 1;
-    return threadNum_ - 1;
+    return workProcNum_;
 }
 
 // 如果只有一个线程，那么返回mainProc, 否则返回工作Proc
@@ -171,7 +175,7 @@ Processor* Scheduler::pickOneWorkProcessor() {
 
 void Scheduler::joinThread() {
     if(thread_.joinable()) thread_.join();
-    for(auto thrd : workThreadVec_) {
+    for(auto& thrd : workThreadVec_) {
         thrd->join();
     }
     quit_ = true;

burger/net/Scheduler.cc

@@ -28,7 +28,7 @@ class Scheduler : boost::noncopyable {
     Scheduler();
     ~Scheduler();
 
-    void setThreadNum(size_t threadNum);
+    void setWorkProcNum(size_t workProcNum);
     void startAsync();
     void wait();
     void stop();
@@ -46,26 +46,22 @@ class Scheduler : boost::noncopyable {
     TimerId runAfter(double delay, TimerCallback cb, const std::string& name = "timer");
     TimerId runEvery(double interval, TimerCallback cb, const std::string& name = "timer");
     void cancel(TimerId timerId);
-    
-// protected:
-    
+
     Processor* getMainProcessor() { return mainProc_; }
     std::vector<Processor *> getWorkProcList() { return workProcVec_; }
     size_t getWorkProcNum();
     Processor* pickOneWorkProcessor();
-    
-    size_t getThreadNum() { return threadNum_; }
 
 private:
     void start();
     void joinThread();
 private:
     bool running_ = false;
     bool quit_ = false;
-    size_t threadNum_ = 1;
+    size_t workProcNum_ = 0;
     Processor* mainProc_;
     std::vector<Processor *> workProcVec_;  // todo : 优先队列
-    std::vector<std::shared_ptr<ProcessThread> > workThreadVec_;
+    std::vector<std::unique_ptr<ProcessThread> > workThreadVec_;
     std::thread thread_;
     std::mutex mutex_;
     std::condition_variable cv_;

burger/net/Scheduler.h

@@ -0,0 +1,15 @@
+#include <vector>
+#include <memory>
+#include <iostream>
+
+
+// g++ std=c++14
+int main() {
+    std::vector<std::unique_ptr<int> > vec;
+    vec.push_back(std::make_unique<int>(1));
+    vec.push_back(std::make_unique<int>(2));
+    vec.push_back(std::make_unique<int>(3));
+    for(auto& v : vec) {
+        std::cout << *v << std::endl;
+    }
+}