jnet::jgroup::JNetGroupThread 클래스 참조

'JNetGroupServer' 인스턴스로부터 그룹 메시지 큐에 전달된 메시지를 싱글 스레드가 수신하여 메시지 처리 콜백을 호출
단일 세션에 대한 수신 직렬 처리를 보장하며, 세션 참조에 대한 유일성이 보장됨으로 수신 이벤트 처리 시 락 없는 로직 구현 가능
더 자세히 ...

#include <JNetCore.h>

클래스
struct	GroupTheradMessage
	그룹 스레드에 전달되는 메시지 구조체 더 자세히 ...

Public 멤버 함수
int	GetGroupThreadLoopFPS ()
void	Init (JNetGroupServer *server, GroupID groupID, bool threadPriorBoost=false, bool calcFps=false)
bool	Start ()
void	Stop ()
void	EnterSession (SessionID64 sessionID)
void	LeaveSession (SessionID64 sessionID)
void	PushSessionMessage (SessionID64 sessionID, JBuffer *msg)
void	PushGroupMessage (GroupID senderGroupID, JBuffer *msg)

Protected 멤버 함수
GroupID	GetGroupID ()
void	Disconnect (SessionID64 sessionID)
bool	SendPacket (SessionID64 sessionID, JBuffer *sendPktPtr, bool postToWorker=false, bool encoded=false)
bool	SendPacketBlocking (SessionID64 sessionID, JBuffer *sendPktPtr, bool encoded=false)
bool	BufferSendPacket (SessionID64 sessionID, JBuffer *sendPktPtr, bool encoded=false)
bool	SendBufferedPacket (SessionID64 sessionID, bool postToWorker=false)
void	CreateGroup (GroupID newGroupID, JNetGroupThread *groupThread, bool threadPriorBoost=false)
void	DeleteGroup (GroupID delGroupID)
void	ForwardSessionToGroup (SessionID64 sessionID, GroupID destGroup)
void	ForwardSessionMessage (SessionID64 sessionID, JBuffer *msg)
void	SendGroupMessage (GroupID groupID, JBuffer *msg)
DWORD	AllocTlsMemPool ()
JBuffer *	AllocSerialBuff ()
JBuffer *	AllocSerialSendBuff (uint16 len, bool LAN=false)
void	FreeSerialBuff (JBuffer *buff)
void	AddRefSerialBuff (JBuffer *buff)
virtual void	OnStart ()
virtual void	OnStop ()
virtual void	OnEnterClient (SessionID64 sessionID)=0
virtual void	OnLeaveClient (SessionID64 sessionID)=0
virtual void	OnMessage (SessionID64 sessionID, JBuffer &recvData)=0
virtual void	OnGroupMessage (GroupID groupID, JBuffer &msg)=0

Protected 속성
JNetGroupServer *	m_Server

Private 타입
enum	GroupTheradMessageType { enSessionEnter , enSessionLeave , enSessionMessage , enGroupMessage }

정적 Private 멤버 함수
static UINT __stdcall	SessionGroupThreadFunc (void *arg)

Private 속성
GroupID	m_GroupID
	그룹 스레드 인스턴스의 관리 대상인 그룹 ID
bool	m_PriorBoost
	그룹 스레드의 우선순위 부스팅 여부 플래그
bool	m_CalcFps
	그룹 스레드의 FPS(Framge per second) 측정 여부 플래그
HANDLE	m_GroupThreadHnd
	그룹 스레드 핸들
bool	m_GroupThreadStop
	그룹 스레드 중지 플래그
LockFreeQueue< GroupTheradMessage >	m_LockFreeMessageQueue
int	m_GroupThreadProcFPS

상세한 설명

'JNetGroupServer' 인스턴스로부터 그룹 메시지 큐에 전달된 메시지를 싱글 스레드가 수신하여 메시지 처리 콜백을 호출
단일 세션에 대한 수신 직렬 처리를 보장하며, 세션 참조에 대한 유일성이 보장됨으로 수신 이벤트 처리 시 락 없는 로직 구현 가능

멤버 열거형 문서화

GroupTheradMessageType

enum jnet::jgroup::JNetGroupThread::GroupTheradMessageType

private

열거형 멤버
enSessionEnter
enSessionLeave
enSessionMessage
enGroupMessage

                                        {
                enSessionEnter,
                enSessionLeave,
                enSessionMessage,
                enGroupMessage,
            };

멤버 함수 문서화

GetGroupThreadLoopFPS()

int jnet::jgroup::JNetGroupThread::GetGroupThreadLoopFPS ( )

inline

{ return m_GroupThreadProcFPS; }

Init()

void jnet::jgroup::JNetGroupThread::Init ( JNetGroupServer * server, GroupID groupID, bool threadPriorBoost = false, bool calcFps = false )

inline

                                                                                                                            {
                m_Server = server;
                m_GroupID = groupID;
                m_PriorBoost = threadPriorBoost;
                m_CalcFps = calcFps;
            }

Start()

bool jnet::jgroup::JNetGroupThread::Start ( )

inline

                                {
                m_GroupThreadStop = false;
                m_GroupThreadHnd = (HANDLE)_beginthreadex(NULL, 0, SessionGroupThreadFunc, this, 0, NULL);
                return true;
            }

Stop()

void jnet::jgroup::JNetGroupThread::Stop ( )

inline

                               {
                m_GroupThreadStop = true;
            }

EnterSession()

void jnet::jgroup::JNetGroupThread::EnterSession ( SessionID64 sessionID )

inline

                                                            {
                m_LockFreeMessageQueue.Enqueue({ sessionID, enSessionEnter, NULL });
            }

LeaveSession()

void jnet::jgroup::JNetGroupThread::LeaveSession ( SessionID64 sessionID )

inline

                                                            {
                m_LockFreeMessageQueue.Enqueue({ sessionID, enSessionLeave, NULL });
            }

PushSessionMessage()

void jnet::jgroup::JNetGroupThread::PushSessionMessage ( SessionID64 sessionID, JBuffer * msg )

inline

                                                                                {
                m_LockFreeMessageQueue.Enqueue({ sessionID, enSessionMessage, msg });
            }

PushGroupMessage()

void jnet::jgroup::JNetGroupThread::PushGroupMessage ( GroupID senderGroupID, JBuffer * msg )

inline

                                                                              {
                m_LockFreeMessageQueue.Enqueue({ senderGroupID, enGroupMessage, msg });
            }

GetGroupID()

GroupID jnet::jgroup::JNetGroupThread::GetGroupID ( )

inlineprotected

{ return m_GroupID; }

Disconnect()

void jnet::jgroup::JNetGroupThread::Disconnect ( SessionID64 sessionID )

inlineprotected

{ m_Server->Disconnect(sessionID); }

SendPacket()

bool jnet::jgroup::JNetGroupThread::SendPacket ( SessionID64 sessionID, JBuffer * sendPktPtr, bool postToWorker = false, bool encoded = false )

inlineprotected

{ return m_Server->SendPacket(sessionID, sendPktPtr, postToWorker, encoded); }

SendPacketBlocking()

bool jnet::jgroup::JNetGroupThread::SendPacketBlocking ( SessionID64 sessionID, JBuffer * sendPktPtr, bool encoded = false )

inlineprotected

{ return m_Server->SendPacketBlocking(sessionID, sendPktPtr, encoded); }

BufferSendPacket()

bool jnet::jgroup::JNetGroupThread::BufferSendPacket ( SessionID64 sessionID, JBuffer * sendPktPtr, bool encoded = false )

inlineprotected

{ return m_Server->BufferSendPacket(sessionID, sendPktPtr, encoded); }

SendBufferedPacket()

bool jnet::jgroup::JNetGroupThread::SendBufferedPacket ( SessionID64 sessionID, bool postToWorker = false )

inlineprotected

{ return m_Server->SendBufferedPacket(sessionID, postToWorker); }

CreateGroup()

void jnet::jgroup::JNetGroupThread::CreateGroup ( GroupID newGroupID, JNetGroupThread * groupThread, bool threadPriorBoost = false )

inlineprotected

{ m_Server->CreateGroup(newGroupID, groupThread, threadPriorBoost); }

DeleteGroup()

void jnet::jgroup::JNetGroupThread::DeleteGroup ( GroupID delGroupID )

inlineprotected

{ m_Server->DeleteGroup(delGroupID); }

ForwardSessionToGroup()

void jnet::jgroup::JNetGroupThread::ForwardSessionToGroup ( SessionID64 sessionID, GroupID destGroup )

inlineprotected

{ m_Server->ForwardSessionGroup(sessionID, m_GroupID, destGroup); }

ForwardSessionMessage()

void jnet::jgroup::JNetGroupThread::ForwardSessionMessage ( SessionID64 sessionID, JBuffer * msg )

inlineprotected

{ m_Server->ForwardMessage(sessionID, msg); }

SendGroupMessage()

void jnet::jgroup::JNetGroupThread::SendGroupMessage ( GroupID groupID, JBuffer * msg )

inlineprotected

{ m_Server->SendGroupMessage(m_GroupID, groupID, msg); }

AllocTlsMemPool()

DWORD jnet::jgroup::JNetGroupThread::AllocTlsMemPool ( )

inlineprotected

{ return m_Server->AllocTlsMemPool(); }

AllocSerialBuff()

JBuffer * jnet::jgroup::JNetGroupThread::AllocSerialBuff ( )

inlineprotected

{ return m_Server->AllocSerialBuff(); }

AllocSerialSendBuff()

JBuffer * jnet::jgroup::JNetGroupThread::AllocSerialSendBuff ( uint16 len, bool LAN = false )

inlineprotected

{ return m_Server->AllocSerialSendBuff(len, LAN); }

FreeSerialBuff()

void jnet::jgroup::JNetGroupThread::FreeSerialBuff ( JBuffer * buff )

inlineprotected

{ m_Server->FreeSerialBuff(buff); }

AddRefSerialBuff()

void jnet::jgroup::JNetGroupThread::AddRefSerialBuff ( JBuffer * buff )

inlineprotected

{ m_Server->AddRefSerialBuff(buff); }

OnStart()

virtual void jnet::jgroup::JNetGroupThread::OnStart ( )

inlineprotectedvirtual

{};

OnStop()

virtual void jnet::jgroup::JNetGroupThread::OnStop ( )

inlineprotectedvirtual

{};

OnEnterClient()

virtual void jnet::jgroup::JNetGroupThread::OnEnterClient ( SessionID64 sessionID )

protectedpure virtual

OnLeaveClient()

virtual void jnet::jgroup::JNetGroupThread::OnLeaveClient ( SessionID64 sessionID )

protectedpure virtual

OnMessage()

virtual void jnet::jgroup::JNetGroupThread::OnMessage ( SessionID64 sessionID, JBuffer & recvData )

protectedpure virtual

OnGroupMessage()

virtual void jnet::jgroup::JNetGroupThread::OnGroupMessage ( GroupID groupID, JBuffer & msg )

protectedpure virtual

SessionGroupThreadFunc()

UINT __stdcall JNetGroupThread::SessionGroupThreadFunc ( void * arg )

staticprivate

                                                                {
    JNetGroupThread* groupthread = reinterpret_cast<JNetGroupThread*>(arg);
 
    groupthread->AllocTlsMemPool();
 
    if (groupthread->m_PriorBoost) {
        SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST);
    }
 
    groupthread->OnStart();
 
    clock_t timestamp;
    int threadLoopCnt;
    if (groupthread->m_CalcFps) {
        groupthread->m_GroupThreadProcFPS = 0;
        threadLoopCnt = 0;
        timestamp = clock();
    }
 
    while (!groupthread->m_GroupThreadStop) {
        if (groupthread->m_CalcFps) {
            threadLoopCnt++;
            clock_t now = clock();
            clock_t interval = now - timestamp;
            if (interval >= CLOCKS_PER_SEC) {
                groupthread->m_GroupThreadProcFPS = threadLoopCnt / (interval / CLOCKS_PER_SEC);
                threadLoopCnt = 0;
                timestamp = now;
            }
        }
 
        GroupTheradMessage message;
        if (groupthread->m_LockFreeMessageQueue.GetSize() > 0) {        // 싱글 그룹 스레드에서의 디큐잉이 보장됨
            if (groupthread->m_LockFreeMessageQueue.Dequeue(message, true)) {
                
                switch (message.msgType) {
                case enSessionEnter:
                {
                    // 그룹 스레드에 클라이언트 Enter
                    groupthread->OnEnterClient(message.msgSenderID);
                }
                break;
                case enSessionLeave:
                {
                    // 그룹 스레드에 클라이언트 Leave
                    groupthread->OnLeaveClient(message.msgSenderID);
                }
                break;
                case enSessionMessage:
                {
                    JBuffer* recvMsg = message.msgPtr;
                    groupthread->OnMessage(message.msgSenderID, *recvMsg);
                    groupthread->FreeSerialBuff(recvMsg);
                }
                break;
                case enGroupMessage:
                {
                    JBuffer* recvMsg = message.msgPtr;
                    groupthread->OnGroupMessage(message.msgSenderID, *recvMsg);
                    groupthread->FreeSerialBuff(recvMsg);
                }
                break;
                default:
                {
                    DebugBreak();
                }
                break;
                }
            }
            else {
                // 싱글 스레드에서 groupthread->m_LockFreeMessageQueue.GetSize() > 0 조건을 확인하였음에도 락-프리 큐 디큐잉에 실패한 경우
                DebugBreak();
            }
        }
    }
 
    groupthread->OnStop();
 
    return 0;
}

멤버 데이터 문서화

m_Server

JNetGroupServer* jnet::jgroup::JNetGroupThread::m_Server

protected

m_GroupID

GroupID jnet::jgroup::JNetGroupThread::m_GroupID

private

그룹 스레드 인스턴스의 관리 대상인 그룹 ID

m_PriorBoost

bool jnet::jgroup::JNetGroupThread::m_PriorBoost

private

그룹 스레드의 우선순위 부스팅 여부 플래그

m_CalcFps

bool jnet::jgroup::JNetGroupThread::m_CalcFps

private

그룹 스레드의 FPS(Framge per second) 측정 여부 플래그

m_GroupThreadHnd

HANDLE jnet::jgroup::JNetGroupThread::m_GroupThreadHnd

private

그룹 스레드 핸들

m_GroupThreadStop

bool jnet::jgroup::JNetGroupThread::m_GroupThreadStop

private

그룹 스레드 중지 플래그

m_LockFreeMessageQueue

LockFreeQueue<GroupTheradMessage> jnet::jgroup::JNetGroupThread::m_LockFreeMessageQueue

private

m_GroupThreadProcFPS

int jnet::jgroup::JNetGroupThread::m_GroupThreadProcFPS

private

---

이 클래스에 대한 문서화 페이지는 다음의 파일들로부터 생성되었습니다.:

• include/JNetCore.h
• JNetCore/JNetGroup.cpp