服务器开发笔记

1 使用boost asio网络库 可参照boost asio的文档示例 (异步 同步) 可参考 boost asio 一个聊天的基本框架 asio的网络通讯代码练手

2 使用智能指针  bind  function 简化编程 提升效率 参考本博客其他文章 可参考虚函数与bind 实现设计模式的练习  

c++11 stl 学习之 shared_ptr c++智能指针(1) c++智能指针(2)

3 设计模式  工厂模式创建通讯包 boost factory  可参考  设计模式 工厂模式 使用shared_ptr

4 避免粘包 包头标记包长度 再发送包  可参考 网络传输 buf 封装 示例代码

5 线程池  io_service_pool调度算法可参考c++11 线程池学习笔记 (二) 线程池

6 消息队列 发送接收与处理解耦

#pragma once

#include <boost/bind.hpp>
#include <boost/function.hpp>
#include <boost/thread.hpp>
#include "job_queue.h"
#include <iostream>

using namespace std;

template<typename Queue>
class worker {
public:
    typedef Queue queue_type;
    typedef typename Queue::job_type job_type;
    typedef boost::function<bool(job_type&)> func_type;
public:
    template<typename Func>
    worker(queue_type& q, Func func, int n = 1);

    worker(queue_type& q, int n = 1);

    template<typename Func>
    void set_workerFunc(Func func) {
        m_func = func;
    }
public:
    void start();
    void run();
    void stop();
private:
    void do_work();
    queue_type & m_queue;
    func_type m_func;
    int m_nThreadNum;
    boost::thread_group m_threads;
};

template<typename Queue>
template<typename Func>
worker<Queue>::worker(typename worker<Queue>::queue_type& q,
    Func func, int n ) : m_queue(q), m_func(fuunc), m_nThreadNum(n) {
    if (m_nThreadNum < 1) {
        m_nThreadNum = 1;
    }
}

template<typename Queue>
void worker<Queue>::do_work() {
    while (true) {
        job_type job = m_queue.pop();
        if (!m_func) {
            break;
        }
        else {
            m_func(job);
        }
    }
}

template<typename Queue>
void worker<Queue>::start() {
    if (!m_func) {
        return;
    }

    if (m_threads.size() > 0) {
        return;
    }

    for (int i = 0; i < m_nThreadNum; ++i) {
        m_nThreads.create_thread(boost::bind(&worker::do_work, this));
    }
}

template<typename Queue>
void worker<Queue>::run() {
    start();
    m_threads.join_all();
}

template<typename Queue>
void worker<Queue>::stop() {
    m_func = nullptr;
    m_queue.stop();
}

#pragma once

#include <queue>
#include <boost/noncopyable.hpp>
#include <boost/utility/value_init.hpp>
#include <boost/thread.hpp>
#include <boost/concept_check.hpp>

template<typename Job>
class job_queue :boost::noncopyable {
public:
    typedef Job Job_type;
    typedef std::queue<Job_type> queue_type;
    typedef boost::mutex mutex_type;
    typedef typename mutex_type::scoped_lock lock_type;
    typedef boost::condition_variable_any condition_type;

    BOOST_CONCEPT_ASSERT((boost::SGIAssignable<Job_type>));
    BOOST_CONCEPT_ASSERT((boost::DefaultConstructible<Job_type>));
public:
    job_queue();
    void push(const Job_type& x);
    Job_type pop();
    void stop();
private:
    queue_type  m_queue;
    mutex_type m_mutex;
    condition_type m_hasJob;
    bool m_stop_flag;
};

template<typename Job>
job_queue<Job>::job_queue() :m_stop_flag(false) {

}

template<typename Job>
void job_queue<Job>::push(const Job_type& x) {
    lock_type lock(m_mutex);
    m_queue.push_back(x);
    m_hasJob.notify_one();
}

template<typename Job>
typename job_queue<Job>::Job_type job_queue<Job>::pop() {
    lock_type lock(m_mutex);
    while (m_queue.empty() && !m_stop_flag) {
        m_hasJob.wait(m_mutex);
    }

    if (m_stop_flag) {
        return boost::initialized_value;
    }

    if (m_queue.empty()) {
        return boost::initialized_value;
    }

    Job_type tmp = m_queue.front();
    m_queue.pop_front();
    return tmp;
}


template<typename job>
void job_queue<job>::stop() {
    m_stop_flag = true;
    m_hasJob.notify_all();
}

 可参考c++11 线程池学习笔记 (一) 任务队列

一个简单的多线程互斥设置变量类 

#pragma once
#include <mutex>
#include <shared_mutex>


template<typename T>
class safe_atom {
public:
    typedef std::shared_mutex mutex_t;
    safe_atom(T v);
    void setValue(const T& v);
    void getValue(T& v);
private:
    mutex_t m_mu;
    T value;
};

template<typename T>
safe_atom<T>::safe_atom::safe_atom(T v) :
    value(v) {}

template<typename T>
void safe_atom<T>::setValue(const T& v) {
    std::unique_lock<std::shared_mutex> lck(m_mu);
    value = v;
}

template<typename T>
void safe_atom<T>::getValue(T& v) {
    std::shared_lock<std::shared_mutex> lck(m_mu);
    v = value;
}

7 线程调度 

8 序列化(目前基本不用自己实现 可以考虑使用 protobuf与json 或者XML) 

可参考google protobuf VC下的使用笔记  rapidjson 的封装学习  rapidjson 的练习

boost 序列化 例子

#pragma once

typedef enum empakcet_type {
    PACKET_TEST = 0x0800,
}packet_type;

#pragma once

#include <iostream>
#include <strstream>
#include <sstream>

#include <boost/serialization/serialization.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/export.hpp>
#include <boost/iostreams/stream.hpp>

#include "packet_type.h"

using namespace boost::archive;

#define _SERIALIZATION_PACKET()    
public:    
virtual void serial(text_oarchive& oa) {    
    oa << *this;                            
}                                            
virtual void unserial(text_iarchive& ia) {    
    ia >> *this;                            
}                                            
int get_packet_type() {                        
    return static_cast<int>(m_packet_type);    
}                                            
protected:                                    
friend boost::serialization::access;        




class serial_packet {
    _SERIALIZATION_PACKET()
protected:
    
    template<typename Archive>
    void serialize(Archive& ar, const unsigned int version) {
        ar& m_packet_type;
    }


    serial_packet(packet_type pkt_type) :m_packet_type(pkt_type) {

    }
    packet_type m_packet_type;
};

#pragma once

#include "serial_packet.h"


class test_packet :public serial_packet {
    _SERIALIZATION_PACKET()
public:
    test_packet() :serial_packet(PACKET_TEST) {}
private:
    template<typename Archive>
    void serialize(Archive& ar, const unsigned int version) {
        ar& m_nTestNo & m_strName & m_strPwd & m_vStr;
    }
public:
    int m_nTestNo;
    std::string m_strName;
    std::string m_strPwd;
    std::vector<std::string> m_vStr;
};

void print(const test_packet& packet) {
    std::cout << packet.m_strName << std::endl;
    std::cout << packet.m_strPwd << std::endl;
    std::cout << packet.m_nTestNo << std::endl;

    for (int i = 0; i < (int)packet.m_vStr.size(); ++i) {
        std::cout << packet.m_vStr[i] << std::endl;
    }
}

void test_mypacket() {
    test_packet set;
    set.m_strName = "hello";
    set.m_strPwd = "world!";
    set.m_nTestNo = 9999;

    set.m_vStr.push_back("a");
    set.m_vStr.push_back("b");
    set.m_vStr.push_back("c");
    set.m_vStr.push_back("c");
    set.m_vStr.push_back("d");
    const int SEND_BUFFER = 100;
    char buf[SEND_BUFFER];
    memset(buf, 0, SEND_BUFFER);

    std::ostrstream sa(buf, SEND_BUFFER);
    boost::archive::text_oarchive oa(sa);
    set.serial(oa);

    test_packet get;
    std::stringstream ss(buf);
    text_iarchive ia(ss);

    get.unserial(ia);
    print(get);
}

#include "test_packet.h"

int main()
{
test_mypacket();
return 0;
}

//===============================================================

9 计时器  可参考 boost timer代码学习笔记