///
/// @file Lock.h
/// @brief
/// @author guozhiming
/// @date 2007-04-11
///
#ifndef __LOCK__
#define __LOCK__
#include "def.h"
//定义了信号量锁，还有读写锁；话说我用qt开发，这些锁qt里面都有。可以直接拿来用了
/// @brief 锁的基本操作 1：读操作的时候读锁可以并发 2：写操作的时候，独占操作
class G_Lock
{
public:
/// @brief 构造函数初始化互斥锁 , 条件变量
G_Lock();
/// @brief 析构函数释放互斥锁，和条件变量
~G_Lock();
/// @brief 读锁 readCounter++ , 锁住readCounter
void rLock();
/// @brief 解锁 readCounter-- , 如果readCounter = 0 , pthread_cond_signal通知
void unrLock();
/// @brief 写锁 如果readCounter不为0一直 pthread_cond_wait等待下去
void wLock();
/// @brief 解锁
void unwLock();
private:
pthread_mutex_t r_Mutex; ///读锁 ，锁住readCounter
pthread_mutex_t w_Mutex; ///锁住同步资源
unsigned long readCounter; ///条件变量如果为0通知(pthread_cond_signal)
pthread_cond_t condReadCounter;
};
#endif
///
/// @file Lock.cpp
/// @brief
/// @author guozhiming
/// @date 2007-04-11
//现在是2013年，这家伙07年就写得这代码，我现在看，是否落后呢？
///
#include "Lock.h"
G_Lock::G_Lock()
{
pthread_mutex_init(&r_Mutex , NULL);
pthread_mutex_init(&w_Mutex , NULL);
pthread_cond_init(&condReadCounter , NULL);
readCounter = 0;
}
G_Lock::~G_Lock()
{
pthread_mutex_destroy(&r_Mutex);
pthread_mutex_destroy(&w_Mutex);
pthread_cond_destroy(&condReadCounter);
}
void G_Lock::rLock()
{
//读写都是配套出现的，没有现成的c库吗？要自己写。读的时候不许写，读靠一个信号量，最大允许多少人同时读。。。
pthread_mutex_lock(&w_Mutex); //防止于写操作冲突
pthread_mutex_lock(&r_Mutex); //防止readCounter 冲突
readCounter++; //只是为了++这个，上面2句下面2句
pthread_mutex_unlock(&w_Mutex); ///写解锁
pthread_mutex_unlock(&r_Mutex); ///读解锁
//先上锁一遍，再解锁？？记得有个try_lock!!!???
}
//什么意思都是先加锁，再解锁。。。
void G_Lock::unrLock()
{
pthread_mutex_lock(&r_Mutex); ///读加锁
readCounter--;
if(0 == readCounter)
{
//pthread_cond_t condReadCounter;这样定义的，这也叫信号。。。这个机制还不清楚，一般都用封装好的c++类。。
pthread_cond_signal(&condReadCounter); //如果readCounter为0 , 表示已经没有读了，可以写
}
pthread_mutex_unlock(&r_Mutex); ///读解锁
}
//又是先加锁再解锁。。。
void G_Lock::wLock()
{
pthread_mutex_lock(&w_Mutex); ///写加锁
pthread_mutex_lock(&r_Mutex); ///读加锁
if(0 == readCounter) ///防止readCounter = 0而且没有调用过rLock()和unrLock()
{
pthread_mutex_unlock(&r_Mutex); ///读解锁
return ;
}
//这是对应上面的那个signal吗？
pthread_cond_wait(&condReadCounter , &r_Mutex); //等待readCounter = 0 , 等待期间r_Mutex被解锁，有信号再加锁
pthread_mutex_unlock(&r_Mutex); ///读解锁
}
//这个直接解锁，终于明白了
void G_Lock::unwLock()
{
pthread_mutex_unlock(&w_Mutex); //写解锁
}
///
/// @file def.h
/// @brief
/// @author guozhiming
/// @date 2007-04-11
///
#ifndef __DEF__
#define __DEF__
#include <iostream>
#include <errno.h>
#include <pthread.h>
#include <time.h>
#include <sys/time.h>
#include <unistd.h>
#include <sys/types.h>
#include <deque> //哦。有标准的queue，竟然还自己写个。
#include <signal.h>
#include <sys/epoll.h>
#include <fcntl.h>
#include <stdarg.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <map> //标准c++
using namespace std;
typedef unsigned long ULONG;
/// @brief 为了服务器接收到client的信息把数据和client的套接字连接到一起
struct G_DataSocket
{
int nSocket;
void *pStr;
};
#endif
///
/// @file ListenThread.h
/// @brief 服务器监听线程
/// @author guozhiming
/// @date 2007-05-16
///
#ifndef __G_LISTENTHREAD__
#define __G_LISTENTHREAD__
#include "Thread.h"
#include "Socket.h"
#include "ThreadPool.h"
class G_ThreadPool; //线程池。。
class G_ListenThread : public G_Thread //还有个基类
{
public:
/// @brief 构造函数
G_ListenThread(G_ThreadPool *pool);
/// @brief 析构函数
virtual ~G_ListenThread();
/// @brief
void Run(); //哦。都是一个run，和qt的线程模式一样。
/// @brief 服务器帮定端口
///
/// @param nPort 帮定端口
///
/// @return true表示成功 , false表示失败
bool Bind(unsigned int nPort);
private:
///套接口操作的对象
G_Socket *g_socket;
G_ThreadPool *g_threadPool;
};
#endif
#include "ListenThread.h"
#include "Log.h"
G_ListenThread::G_ListenThread(G_ThreadPool *pool) : g_threadPool(pool)
{
g_socket = new G_Socket();
}
G_ListenThread::~G_ListenThread()
{
if(g_socket)
{
delete g_socket;
g_socket = NULL;
}
}
void G_ListenThread::Run()
{
pause();//看不懂，暂停，，什么时候开始。？有信号时，会中断此函数。什么信号，什么时候来？
debug_output("Listen thread is starting ....\n");
int nSocket;
while(1)
{
if(g_socket->Listen(nSocket))
{
debug_output("new client is connecting ....\n");//新的连接？那socket是客户端的socket？？
g_threadPool->pushSocket(nSocket); ///填加到套接口队列//这里放的是server的socket啊？？
g_threadPool->continues(); ///通知线程池，运行起来，到套接口队列中取套接口
}
}
}
bool G_ListenThread::Bind(unsigned int nPort)
{
if(!g_socket->Bind(nPort))
{
debug_output("Bind port %d is faild\n" , nPort);
return false;
}
debug_output("Bind port %d is Successful\n" , nPort);
continues();
return true;
}
