//userdataworker.h
#ifndef USERDATAWORKER_H_
#define USERDATAWORKER_H_

#pragma once /* Защита от двойного подключения заголовочного файла */
#include <string>

class UserDataWorker{

  private:
    char* ClientCode;
    int Port;
    int Num;
    double LLevel;

  public:
    UserDataWorker(/*char*/const char* ClientCode, int Port, int Num, double LLevel);
    ~UserDataWorker();

    void getStateUserData(char* _ClientCode, int* _Port, int* _Num, double* _LLevel);
    void printStateUserData();
    int runner();
    int serviceCallback();
};
#endif /* USERDATAWORKER_H_ */

// userdataworker.cpp
#include "userdataworker.h"
#include <string>
#include <iostream>
#include <stdio.h>
#include <string.h>

using namespace std;

UserDataWorker::UserDataWorker(/*char*/const char* _ClientCode, int _Port, int _Num, double _LLevel)
{
  //cout << "UserData_CONSTRUCTOR in param _ClientCode:" << _ClientCode << " port: " << _Port << " num: " << _Num << " l: " << _LLevel << endl;

  ClientCode = new char[sizeof(_ClientCode)];
  strcpy(ClientCode, _ClientCode);
  Port = _Port;
  Num = _Num;
  LLevel = _LLevel;
  std::cout << "UserData_CONSTRUCTOR_ClientCode: " << ClientCode << " Port: "
         << Port << " Num: " << Num << " LLevel: " << LLevel << std::endl;
}

UserDataWorker::~UserDataWorker()
{
    cout << "UserData_destructor. ClientCode:" << ClientCode << endl;
    //delete []ClientCode; //надо освобождать память?
}

void UserDataWorker::getStateUserData(char* _ClientCode, int* _Port, int* _Num, double* _LLevel)
{
  strcpy(_ClientCode, ClientCode);
  _Port = &Port;
  _Num = &Num;
  _LLevel = &LLevel;
}

void UserDataWorker::printStateUserData()
{
  std::cout << "printStateUserData ClientCode: " << ClientCode << " Port: "
         << Port << " Num: " << Num << " LLevel: "
         << LLevel << std::endl;
}

int UserDataWorker::runner()
{
  //что-то делаем в потоке.
  return 0;
}

int UserDataWorker::serviceCallback()
{
    //вызов из вне
}

int main(int argc, char* argv[])
{
	for ( int idx = 0; idx < 10; ++idx )
	{
		std::stringstream ss;
		ss << "thread_" << idx;

		UserDataWorker userDataWorker(ss.str().c_str(), 3000 + idx, 10 * idx, 0.5 + idx);

		std::thread myThread(userDataWorker.runner );
		myThread.detach();
		//std::thread(userDataWorker.runner ).detach();
	} 
  return 0;
}

#include <thread>
#include <string>
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <ctime>
#include <chrono>
#include <sstream>

long any_var = 1234;
double any_ln = 1001.01010111;

class MyThread{ 
private:
  char* ClientCode;
  int id;
  long userID;
  volatile bool stopThread;
  double *LnValue;
  long *var;
  long counter;
  volatile long c2;
  //static long s = 0;
  
public:
  MyThread(const char* _ClientCode, int param_id, long param_userID, double *_LnValue, long *_var) 
  : id(param_id)
  , userID(param_userID)
  , LnValue(_LnValue)
  , var(_var)
  , counter(0)
  , c2(0)
  , stopThread(false)
  {
    ClientCode = new char[sizeof(_ClientCode) + 1];
    strcpy(ClientCode, _ClientCode); 
  }

  ~MyThread()
  {
    //delete []ClientCode;
    //delete ClientCode;
    //delete &ClientCode;
    //delete *ClientCode;
  } 
  
  void run_thread() //volatile
  {
    counter = (id+1) * 1000000000;
  	while(!stopThread && *var != -1)
  	{
	  counter++;
  	std::cout << "THREAD : " << id << " userID: " << userID << " T_ID: " << std::this_thread::get_id() << " ClientCode: " << ClientCode << " stopThread: " << stopThread << " var: " << *var << " LnValue: " << *LnValue << " c= " << counter << " c2= " << c2  << std::endl;
		//DO ANY LOGIC IN THREAD
  		std::this_thread::yield();
		std::this_thread::sleep_for(std::chrono::microseconds(700));
		c2++;
  	}
  }
  
  void stop_thread()
  {
  	stopThread = true;
	std::cout << "stop_thread_THREAD : " << id << " userID: " << userID << " T_ID: " << std::this_thread::get_id() << " ClientCode: " << ClientCode << " stopThread: " << stopThread << " c2= " << c2 << std::endl;
  } 
    
};
 
int main(int argc, char* argv[]){
 
std::vector<MyThread> threads;
int treads_num = 5;

for ( int num = 0; num < treads_num; num++ )
{
	std::stringstream ss;
	ss << "thread_" << num;
		
	MyThread t(ss.str().c_str(), num, num * 1000, &any_ln, &any_var);

	std::thread my_thread(&MyThread::run_thread, t);
		
	my_thread.detach();
		
	threads.push_back( t );
}

    std::this_thread::sleep_for(std::chrono::milliseconds(50));

for (int m=0; m<threads.size(); m++)
{
  threads.at(m).stop_thread();
}  
 
any_var = -1; 
 
std::this_thread::sleep_for(std::chrono::milliseconds(50));
std::cout << "MAIN_THREAD FINISH" << std::endl;

return 0;
}