DWORD WINAPI Server::ClientThread(LPVOID lpParam) //(insert to DEQUE) use MUTEX
{
	Singleton* log = Singleton::Instance();
	log->Add("Thread: Client runing");

	SOCKET sock = (SOCKET)lpParam; //Get socket

	while(f)
	{
		//recv DATA, create STRUCTURE and (insert to DEQUE)MUTEX
		//Send will be in APPLY THREAD
		if ( recv(sock,rdata.ch,sizeof(DWORD),0) != -1 ) //Wait data //save data to union
		{
			Message tmp;
			tmp.s = sock;
			tmp.data = rdata.i;

			WaitForSingleObject(hMutex,INFINITE);
			deque_data.push_back(tmp);
			ReleaseMutex(hMutex);
		}
		else
		{
			break;
		}
	}
	
	log->Add("Thread: Client stoped");
	return 0;
}

int main(void)
{
	HANDLE hE = CreateEvent(NULL,false,true,L"{@0001_Start_Program_Event}");
	if ( GetLastError() == ERROR_ALREADY_EXISTS ) 
	{	//program running
		return 0;
	}

	Singleton* log = Singleton::Instance();
	
	Server server;
	if ( server.Activate() )
	{
		cout << "ok" << endl;
	}

	int k = 10; 
	while (k)
	{
		system("cls");
		log->Show();
		system("@pause");
		k--;
		if (k == 1)
		{
			server.Deactivate(); //END THREADS
		}
	}
	system("@Pause");
	return 0;
}

int main(int argc , char *argv [])
{
	Singleton *singletonObj = Singleton ::GetInstance();
	cout<<singletonObj->GetTest()<<endl;

	return 0;
}

AnalitikaArtikliLista::~AnalitikaArtikliLista()
{
    disconnect(sm, SIGNAL(currentRowChanged(QModelIndex,QModelIndex)), this, SLOT(selectionChanged(QModelIndex,QModelIndex)));
    disconnect(header, SIGNAL(sectionResized(int, int, int)), this, SLOT(procSectionResized(int, int, int)));
    disconnect(header_2, SIGNAL(sectionResized(int, int, int)), this, SLOT(procSectionResizedDetail(int, int, int)));


    Singleton *s = Singleton::Instance();
    QStringList tempVals = s->saveWidthList(colWidth);
    s->Set_Faktura_HeaderState(tempVals);
    QStringList tempdetailVals = s->saveWidthList(colDetailWidth);
    s->Set_FakturaDetail_HeaderState(tempdetailVals);


    delete ui;
    delete model;
    delete header;
    delete model_2;
    delete header_2;
    delete b;
    b = 0;
    delete bc;
    bc = 0;
    delete bd;
    bd = 0;
}

int main()
{
	Singleton* instance = Singleton::get();
	std::cout << instance->showData() << std::endl;

	return 0;
}

void setExecutor(
    std::shared_ptr<Exe> executor,
    Singleton<std::weak_ptr<Exe>>& sExecutor,
    Singleton<RWSpinLock, LockTag>& sExecutorLock) {
  RWSpinLock::WriteHolder guard(sExecutorLock.get());
  *sExecutor.get() = std::move(executor);
}

int main()
{
  Singleton *singleton = Singleton::getInstance();
  singleton->singletonOperation();

  return 0;
}

std::shared_ptr<Exe> getExecutor(
    Singleton<std::weak_ptr<Exe>>& sExecutor,
    Singleton<std::shared_ptr<DefaultExe>>& sDefaultExecutor,
    Singleton<RWSpinLock, LockTag>& sExecutorLock) {
  std::shared_ptr<Exe> executor;
  auto singleton = sExecutor.try_get();
  auto lock = sExecutorLock.try_get();

  {
    RWSpinLock::ReadHolder guard(lock.get());
    if ((executor = sExecutor.try_get()->lock())) {
      return executor;
    }
  }


  RWSpinLock::WriteHolder guard(lock.get());
  executor = singleton->lock();
  if (!executor) {
    std::weak_ptr<Exe> defaultExecutor = *sDefaultExecutor.try_get().get();
    executor = defaultExecutor.lock();
    sExecutor.try_get().get()->swap(defaultExecutor);
  }
  return executor;
}

int main()
{
	Singleton *s = Singleton::getInstance();
	s->printInfo();	

	Singleton *s2 = Singleton::getInstance();
	s2->printInfo();	

	Singleton *s3 = Singleton::getInstance();
	s3->printInfo();	

//	Singleton *s4 = new Singleton();

//	Singleton s5;


	/* 创建线程,在线程里也去调用Singleton::getInstance */
	pthread_t thread1ID;
	pthread_t thread2ID;

	pthread_create(&thread1ID, NULL, start_routine_thread1, NULL);
	pthread_create(&thread2ID, NULL, start_routine_thread2, NULL);

	sleep(3);

	return 0;
}

void* thread_routine(void* arg)
{
	std::cout << pthread_self() << std::endl;
	Singleton* pInstance = Singleton::GetInstance();
	pInstance->Print();
	// 多线程下无法释放内存，否则会导致程序宕掉，最终导致内存泄漏
	return NULL;
}

int main(void){
	Singleton *instance = Singleton::getInstance();
	instance->setValue(35);
	cout << instance->getValue() << endl;
	Singleton *object = Singleton::getInstance();
	cout << object->getValue() << endl; 

}

int main() {
    Singleton *s = Singleton::getInstance();
    s->pulse();
    cout << "main: global_ptr is " << GlobalClass::instance()->get_value() << '\n';
    foo();
    bar();
    return 0;
}

void		Game::_broadcastPacket(PacketContainer* p, bool tcp)
{
	Singleton<NetworkManager>	*network = NULL;

	for (auto it = this->_clients.begin(); it != this->_clients.end(); ++it)
	{
		network->getInstance()->sendPacket(p->getPacketSerialised(), (*it)->getConnexion(), tcp);
	}
}

void setExecutor(
    std::shared_ptr<Exe> executor,
    Singleton<std::weak_ptr<Exe>>& sExecutor,
    Singleton<RWSpinLock, LockTag>& sExecutorLock) {
  auto lock = sExecutorLock.try_get();
  RWSpinLock::WriteHolder guard(*lock);
  std::weak_ptr<Exe> executor_weak = executor;
  sExecutor.try_get().get()->swap(executor_weak);
}

void *start_routine_thread2(void *arg)
{
	cout<<"this is thread 2 ..."<<endl;

	Singleton *s = Singleton::getInstance();
	s->printInfo();	
	
	return NULL;
}

int main(){
	//Singleton * trysingleton = new Singleton(10);   //wrong
	Singleton * singleton = Singleton::createInstance(10);
	Singleton * singleton2 = Singleton::createInstance(12);
	singleton->print();		
	singleton2->print();
	singleton->deleteInstance();
	singleton2->deleteInstance();
	return 0;
}

static void changeLevelChooser(const void *self)
{
	Singleton<LevelLoader> gLevelLoader;
	
	const SpinEdit *spinedit = (const SpinEdit *) self;

	gLevelLoader->loadLevelByID(spinedit->value);
	
	sgLevel.lastPlayerIndex = MAX_SCORE_COLS;
}

 void run()
 {
     const int kCount = 2;
     for(int ix = 0; ix != kCount; ++ix)
     {
         Singleton * temp;
         temp = Singleton::getInstance();
         temp->print();
      
     }
 }

int
main() {
  Singleton *p = Singleton::CreateInstance();
  Singleton a(*p); // -- 복제 생성자 호출

  a.SetData(20);

  cout << "p->data = " << p->GetData() << endl; // -- p->data = 10
  cout << "a.data = " << a.GetData() << endl;   // -- a.data = 20

  return 0;
}

// myThreadCode ///////////////////////////////////////////////////////////////
void * myThreadCode (void * param) {
    
    Singleton * theInstance;
    
    theInstance = Singleton::Instance();
    
    
    sleep(1);
    theInstance->increaseShared();
    
    return NULL;
}