[C++ Win32] CRITICAL SECTION in server multi-thread

[gianvituzzi]

ho provato ad implementarle...ma ottengo degli unhandle exception (writing location)...a questo punto non so più che fare...

/*
 *
 * Streaming Server v1.1 by THEARTOFWEB Software
 *
 */

#include <iostream>
#include <string>
#include <map>
#include <algorithm>
#include <process.h>
#include <cstdlib>
#include <ctime>
#include "socket.h"
#include <boost/circular_buffer.hpp>
using namespace std;
using namespace boost;

const string CRLF = "\r\n";
const int numbuff = 3;

unsigned int __stdcall Consumer(void* sock);
unsigned int __stdcall Producer(void*);

void getDateTime(char * szTime);

enum buffer_status
{
    BUFF_DONE  = 1,
    BUFF_EMPTY = 0
};

struct buffer
{
    unsigned char data[1024];
    int bytesRecorded;
    int flag;
    buffer(const unsigned char * data_, const int bytesRecorded_, const int flag_) :
        bytesRecorded(bytesRecorded_), flag(flag_)
        {
            copy(data_, data_ + bytesRecorded_, data);
        }
};

struct circular
{
    circular_buffer<buffer> cb;
};

// Global maps

map<int, circular> users;
map<int, circular>::iterator uit;
map<int, HANDLE> eventi;
map<int, HANDLE>::iterator eit;

// Declare Procuder && Cosumer CS

CRITICAL_SECTION csProducer;
CRITICAL_SECTION csConsumer;

int main()
{
    // Initialize the critical section
    InitializeCriticalSection(&csProducer);

    // Launch Producer Thread
    unsigned int prodRet;
    _beginthreadex(0,0,Producer,NULL,0,&prodRet);
    if(prodRet)
        cout << "Launched Producer Thread!" << endl;

    // Release resources used by the critical section object.
    DeleteCriticalSection(&csProducer);

    // Server.
    // Set up server (port: 8000, maxconn: 10)
    //
    SocketServer sockIn(8000, 10);

    while(1)
    {
        // ...wait for incoming connections...
        Socket* s = sockIn.Accept();

        // Initialize the critical section
        InitializeCriticalSection(&csConsumer);

        // Spawn a new Consumr Thread each
        // time a client connects.
        unsigned int sockRet;
        _beginthreadex(0,0,Consumer,s,0,&sockRet);
        if(sockRet)
            cout << "Spawned a new thread!" << endl;

        // Release resources used by the critical section object.
        DeleteCriticalSection(&csConsumer);
    }

    sockIn.Close();

    return EXIT_SUCCESS;
}

// Consumer Thread
unsigned int __stdcall Consumer(void* sock)
{
    Socket* s = (Socket*) sock;

    s->SendBytes("Hello World!" + CRLF);

    int threadid = (int)GetCurrentThreadId();

    // Create Event && Push it in the event map
    HANDLE hevent = CreateEvent(NULL,FALSE,FALSE,NULL);
    eventi.insert(make_pair(threadid,hevent));

    // Prepare && Add circular buffer to the map
    circular c;
    c.cb.set_capacity(numbuff);

    for(int i = 0; i<numbuff; i++)
    {
        c.cb.push_back(buffer(NULL,0,BUFF_EMPTY));
    }

    users.insert(make_pair(threadid, c));

    //
    // Read data from the buffer
    // and send it to the client
    //
    // When using push_back the oldest
    // element in the circular buffer
    // will be in the index 0
    //

    Sleep(500);

    while(1)
    {
        // CALLBACK EVENT
        WaitForSingleObject(eventi[threadid], INFINITE);

        if(users[threadid].cb.at(0).flag == BUFF_DONE)
        {
            string line = (char*)users[threadid].cb.at(0).data;
            int ret = s->SendBytes(line + CRLF);
            if(SOCKET_ERROR == ret)
                break;
        }
    }

    // Close & remove event from event map
    CloseHandle(eventi[threadid]);

    // Request ownership of the critical section.
    EnterCriticalSection(&csConsumer);

    eventi.erase(threadid);

    // Release ownership of the critical section.
    LeaveCriticalSection(&csConsumer);

    // Remove buffer from the map
    users.erase(threadid);

    // Say bye to the client
    s->SendBytes("Bye bye!" + CRLF);

    // Disconnect client
    cout << "Closing thread..." << endl;
    s->Close();
    delete s;
    return 0;
}

// Producer Thread
unsigned int __stdcall Producer(void*)
{
    while(1)
    {
        Sleep(1000);
        char szTime[30]; getDateTime(szTime);

        for(uit=users.begin(); uit!=users.end(); ++uit)
        {
            // Request ownership of the critical section.
            EnterCriticalSection(&csProducer);

            users[uit->first].cb.push_back(buffer((unsigned char*)szTime, 30, BUFF_DONE));

            if(eventi[uit->first])
                SetEvent(eventi[uit->first]);

            // Release ownership of the critical section.
            LeaveCriticalSection(&csProducer);

            cout << "Producer is writing to: " << uit->first << endl;
        }

    }
    return 0;
}

void getDateTime(char * szTime)
{
    time_t rawtime = time(NULL);
    struct tm timeinfo;
    gmtime_s(&timeinfo, &rawtime);
    strftime(szTime, 30, "%a, %d %b %Y %X GMT", &timeinfo);
}