C / C++ / MFC

TQTL wrote:

the killing process crashes the application when nultiple cores are used

TQTL wrote:

...how to kill this thread safely?

int omp_get_num_procs();

SYSTEM_INFO sysinfo;
GetSystemInfo(&sysinfo);
int countCPU = sysinfo.dwNumberOfProcessors;

#include <iostream>
#include <thread>
#include <mutex>

static const int num_threads = 10;

std::mutex mtx;

//This function will be called from a thread

void call_from_thread(int tid) {
	std::cout << "Launched by thread " << tid << std::endl;
}

void call_from_thread_with_mutex (int tid) {
	mtx.lock();
	std::cout << "Launched by thread " << tid << std::endl;
	mtx.unlock();
}


int main() {
    std::thread t[num_threads];

	//Launch a group of threads
	for (int i = 0; i < num_threads; ++i) {
		t[i] = std::thread(call_from_thread, i);
	}
	   
	std::cout << "Non mutex threads launched from the main\n";

	//Join the threads with the main thread
	for (int i = 0; i < num_threads; ++i) {
		t[i].join();
	}


	//Launch a group of threads
	for (int i = 0; i < num_threads; ++i) {
		t[i] = std::thread(call_from_thread_with_mutex, i);
	}

	mtx.lock();
	std::cout << "Mutex threads launched from the main\n";
	mtx.unlock();

	//Join the threads with the main thread
	for (int i = 0; i < num_threads; ++i) {
		t[i].join();
	}

	getchar();

	return 0;
}

Quote:

use a std:map, and a mutex over all map operation

Quote:

use a C array. and assign an ID(0-10239) for each client if connected,If disconnected,the Id would be recycled.

struct CLIENT_DATA
{
std::string m_strIp;
int m_nOnlineTime;
int m_nCredits;
};

bool Connect(std::string strIp)
{
   boost::lock_guard<boost::mutex> lock(m_lock);

  CLIENT_DATA* pData = new CLIENT_DATA;
  pData->m_nOnlineTime = 0;
  pData->m_strIp = strIp;
  m_mapClients.push_back(strIp,pData);
  
  return true;
}

void Disconnect(std::string strIp);
{
 	boost::lock_guard<boost::mutex> lock(m_lock);

        std::map<std::string,CLIENT_DATA*>::iterator iter = m_mapClients.find(strIp);
	if(iter != m_mapClients.end())
		return;

	CLIENT_DATA* pClientData = m_mapClients[strIp];
	if(pClientData != NULL)
        {
           delete pClientData;
           pClientData = NULL;
        }
        m_mapClients.erase(iter);
}

bool UpdateOnlineTime(std::string strIp)
{
 	boost::lock_guard<boost::mutex> lock(m_lock);
	
        std::map<std::string,CLIENT_DATA*>::iterator iter = m_mapClients.find(strIp);
  	if(iter != m_mapClients.end())
		return false;

	CLIENT_DATA* pClientData = m_mapClients[strIp];
	if(pClientData == NULL)
               return false;
	pClientData->m_nOnlineTime += 10;
	
	return true;
}

void PrepareIds()
{
	for(int i=0;i<10240;i++)
	   m_vecAvailableIds.push_back(i);
	
}

int FetchId()
{
	boost::lock_guard<boost::mutex> lock(m_lock);
	if(m_vecAvailableIds.size()<=0)
            return -1;

	int nId =  m_vecAvailableIds.back();
	m_vecAvailableIds.pop_front();
        return nId;
}

int ReturnId(int nId)
{
      boost::lock_guard<boost::mutex> lock(m_lock);
      m_vecAvailableIds.push_back(nId);
}

bool Connected(std::string strIp)
{
	int nNewId = FetchId();
	if(nNewId == -1)
             return false;

	CLIENT_DATA* pData = m_arrClients[nNewId];
        boost::lock_guard<boost::mutex> lock(pData->m_mutex_lock);
        pData->m_bInUse = true;
	pData->m_nOnlineTime = 0;	
	pData->m_strIP = strIp;
}

bool Disconnected(int nClientId)
{
	Assert(nClientId>=0 && nClientId<10240);
	
        CLIENT_DATA* pData = m_arrClients[nClientId];
        boost::lock_guard<boost::mutex> lock(pData->m_mutex_lock);
        pData->m_bInUse = false;

        ReturnId(nClientId);

	return true;
}

struct CLIENT_DATA
{
std::string m_strIp;
int m_nOnlineTime;
int m_nCredits;
bool m_bInUse;
boost::mutex m_mutex_data;
};

bool UpdateOnlineTime(int nClientId)
{
	Assert(nClientId>=0 && nClientId<10240);
	
	CLIENT_DATA* pData = m_arrClients[nClientId];
	
 	boost::lock_guard<boost::mutex> lock(pData->m_mutex_lock);
	if(! pClientData->m_bIsInUse)
             return false;
	
	pClientData->m_nOnlineTime += 10;
	
	return true;
}

UpdateClients()
{
    boost::lock_guard<boost::mutex> lock(m_lock);
   for(int i=0;i<m_mapClients.size();i++)
   {

      Update();
    }
}

UpdateClients()
{
    //there is no need to lock
    for(int i=0;i<m_arrClients.size();i++)
   {

    Update();
    }
}