C++ Worker类代码示例

	void runnableTest()
	{
		Worker worker;
		Thread thread(&worker);

		thread.start();
		worker.start();

		CPPUNIT_ASSERT(worker.isQuit() == false);
		worker.quit();
		const unsigned int result = thread.join();
		CPPUNIT_ASSERT(result == 1);


		CPPUNIT_ASSERT(worker.isQuit() == true);
		worker.join();
	}

int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
  try
    {
      CORBA::ORB_var orb =
        CORBA::ORB_init (argc, argv);

      if (parse_args (argc, argv) != 0)
        return 1;

      Worker worker (orb.in ());

      if (worker.activate (THR_NEW_LWP | THR_JOINABLE,
                           nthreads) != 0)
        ACE_ERROR_RETURN ((LM_ERROR,
                           "(%P|%t) Cannot activate worker threads\n"),
                          1);

      int timeout = 30;
      int now = 0;
      while (now < timeout
        && ((expect_ex_kind != TAO::FOE_NON
             && worker.received_ex_kind () != expect_ex_kind
             && worker.num_received_ex () != expect_num_ex)
            || expect_ex_kind == TAO::FOE_NON))
      {
        std::cout << ".";
        now += 1;
        ACE_Time_Value tv (1, 0);
        orb->run (tv);
      }
      std::cout << std::endl;

      worker.done ();

      if (do_shutdown)
        {
          CORBA::Object_var object =
            orb->string_to_object (ior);

          Simple_Server_var server =
            Simple_Server::_narrow (object.in ());

          server->shutdown ();
        }

      ACE_OS::sleep (1);

      orb->destroy ();

      worker.thr_mgr ()->wait ();

      if (worker.received_ex_kind () != expect_ex_kind
        || worker.num_received_ex () != expect_num_ex)
      {
        ACE_ERROR_RETURN ((LM_ERROR,
          ("(%P|%t)client: test failed - expected is different from received. "
          "expected %d/%d received %d/%d.\n"),
          expect_ex_kind, expect_num_ex, worker.received_ex_kind (), worker.num_received_ex()),
                          1);
      }

      ACE_DEBUG ((LM_DEBUG, "(%P|%t)client: test passed.\n"));
    }
  catch (const CORBA::Exception& ex)
    {
      ex._tao_print_exception ("Exception caught in main:");
      return 1;
    }

  return 0;
}

//
// Shows the selected item's disk starting sector, size, and queue depth.
//
void CPageDisk::ShowSettings()
{
	Manager *manager;
	Worker	*worker;
	int disk_size;
	int disk_start;
	int queue_depth;

	// Get the values for the disk settings from memory.
	switch ( theApp.pView->m_pWorkerView->GetSelectedType() )
	{
	case WORKER:
		worker = theApp.pView->m_pWorkerView->GetSelectedWorker();
		disk_size = worker->GetDiskSize( GenericDiskType );
		disk_start = worker->GetDiskStart( GenericDiskType );
		queue_depth = worker->GetQueueDepth( GenericDiskType );
		break;
	case MANAGER:
		manager = theApp.pView->m_pWorkerView->GetSelectedManager();
		disk_size = manager->GetDiskSize( GenericDiskType );
		disk_start = manager->GetDiskStart( GenericDiskType );
		queue_depth = manager->GetQueueDepth( GenericDiskType );
		break;
	default:
		disk_size = theApp.manager_list.GetDiskSize( GenericDiskType );
		disk_start = theApp.manager_list.GetDiskStart( GenericDiskType );
		queue_depth = theApp.manager_list.GetQueueDepth( GenericDiskType );
	}
	// If there is a displayable value, display it.  Otherwise, hide the content
	// of the edit box.
	if ( disk_size == AMBIGUOUS_VALUE )
	{
		m_EDiskSize.SetPasswordChar( 32 );
		m_EDiskSize.Invalidate();
	}
	else
	{
		m_EDiskSize.SetPasswordChar( 0 );
		SetDlgItemInt( EDiskSize, disk_size );
	}

	if ( disk_start == AMBIGUOUS_VALUE )
	{
		m_EDiskStart.SetPasswordChar( 32 );
		m_EDiskStart.Invalidate();
	}
	else
	{
		m_EDiskStart.SetPasswordChar( 0 );
		SetDlgItemInt( EDiskStart, disk_start );
	}
	
	if ( queue_depth == AMBIGUOUS_VALUE )
	{
		m_EQueueDepth.SetPasswordChar( 32 );
		m_EQueueDepth.Invalidate();
	}
	else
	{
		m_EQueueDepth.SetPasswordChar( 0 );
		SetDlgItemInt( EQueueDepth, queue_depth );
	}
}

//
// Stores the targets that have been selected by the user with the appropriate
// worker.
//
void CPageDisk::StoreTargetSelection()
{
	HTREEITEM hdisk;
	Manager *manager;
	Worker	*worker;
	int		target = 0;
	int		next_worker;
	
	// Get the selected manager and worker.
	manager = theApp.pView->m_pWorkerView->GetSelectedManager();
	worker = theApp.pView->m_pWorkerView->GetSelectedWorker();

	// Make sure we have a selected manager (or worker).
	if ( !manager )
	{
		ErrorMessage( "Unexpectedly found no selected manager in "
			"CPageDisk::StoreTargetSelection." );
		return;
	}

	if ( worker )
	{
		// Assign the targets to the selected worker in the order that they
		// appear in the GUI.
		worker->RemoveTargets( GenericDiskType );
		for ( hdisk = m_TTargets.GetRootItem(); hdisk; hdisk = 
			m_TTargets.GetNextSiblingItem( hdisk ) )
		{
			if ( GetSelectionCheck( hdisk ) == TargetChecked )
				worker->AddTarget( manager->GetInterface( target, GenericDiskType ) );
			target++;
		}
	}
	else
	{
		// Clear the assigned targets from all the manager's workers.
		manager->RemoveTargets( GenericDiskType );

		// Set the first worker to receive targets.
		worker = manager->GetWorker( 0, GenericDiskType );
		next_worker = 0;

		// Assign the targets to the workers of the selected manager.
		for ( hdisk = m_TTargets.GetRootItem(); hdisk; hdisk = 
			m_TTargets.GetNextSiblingItem( hdisk ) )
		{
			// If the disk is selected in the GUI, assign it to the expected
			// worker.
			if ( GetSelectionCheck( hdisk ) == TargetChecked )
			{
				worker->AddTarget( manager->GetInterface( target, GenericDiskType ));

				// Update who the next worker to receive a target is.
				if ( ++next_worker >= manager->WorkerCount( GenericDiskType ) )
					next_worker = 0;
				worker = manager->GetWorker( next_worker, GenericDiskType );
			}
			target++;
		}
	}
	ShowTargetSelection();
}

int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
  int priority =
    (ACE_Sched_Params::priority_min (ACE_SCHED_FIFO)
     + ACE_Sched_Params::priority_max (ACE_SCHED_FIFO)) / 2;

  priority = ACE_Sched_Params::next_priority (ACE_SCHED_FIFO,
                                              priority);

  priority = ACE_Sched_Params::next_priority (ACE_SCHED_FIFO,
                                              priority);

  // Enable FIFO scheduling, e.g., RT scheduling class on Solaris.
  if (ACE_OS::sched_params (ACE_Sched_Params (ACE_SCHED_FIFO,
                                              priority,
                                              ACE_SCOPE_PROCESS)) != 0)
    {
      if (ACE_OS::last_error () == EPERM)
        {
          ACE_DEBUG ((LM_DEBUG,
                      "server (%P|%t): user is not superuser, "
                      "test runs in time-shared class\n"));
        }
      else
        ACE_ERROR ((LM_ERROR,
                    "server (%P|%t): sched_params failed\n"));
    }

  try
    {
      CORBA::ORB_var orb =
        CORBA::ORB_init (argc, argv);

      CORBA::Object_var poa_object =
        orb->resolve_initial_references("RootPOA");

      if (CORBA::is_nil (poa_object.in ()))
        ACE_ERROR_RETURN ((LM_ERROR,
                           " (%P|%t) Unable to initialize the POA.\n"),
                          1);

      PortableServer::POA_var root_poa =
        PortableServer::POA::_narrow (poa_object.in ());

      PortableServer::POAManager_var poa_manager =
        root_poa->the_POAManager ();

      poa_manager->activate ();

      if (parse_args (argc, argv) != 0)
        return 1;

      CORBA::Object_var progress_object =
        orb->string_to_object (ior);

      Progress_var progress =
        Progress::_narrow (progress_object.in ());

      ACE_Time_Value delay (0, interval);

      Peer_i peer;
      peer.init (orb.in (),
                 progress.in (),
                 delay);

      Worker worker (orb.in ());
      if (worker.activate (THR_NEW_LWP | THR_JOINABLE,
                           nthreads) != 0)
        ACE_ERROR_RETURN ((LM_ERROR,
                           "Cannot activate client threads\n"),
                          1);

      worker.thr_mgr ()->wait ();

      ACE_DEBUG ((LM_DEBUG, "event loop finished\n"));
    }
  catch (const CORBA::Exception& ex)
    {
      ex._tao_print_exception ("Caught exception:");
      return 1;
    }

  return 0;
}

void* Worker::dispatch(void *arg) {
    Worker *worker = (Worker *) arg;
    worker->handleTasks();
    //delete worker;
    return 0;
}

Worker* PeopleGenerator::GenerateWorker()
{
	std::string spriteName = "Worker";
	Worker* result = new Worker();
	result->Speed = 1.5f;
	result->Happiness = 0.5f;
	result->Age = 30;
	if (rand() % 2)
	{
		result->PersonGender = Person::Gender::Male;
		spriteName += "_Male";

		int blarand = rand() % 7;

		if (blarand == 0)
		{
			spriteName += "_Asian";
			result->CleaningOffsets[0] = sf::Vector2f(153, 38);
			result->CleaningOffsets[1] = sf::Vector2f(-163, 48);
			result->CleaningOffsets[2] = sf::Vector2f(-49, -86);
			result->CleaningOffsets[3] = sf::Vector2f(33, -87);
		}
		if (blarand == 1)
		{
			spriteName += "_Black";
			result->CleaningOffsets[0] = sf::Vector2f(230, -40);
			result->CleaningOffsets[1] = sf::Vector2f(-246, -30);
			result->CleaningOffsets[2] = sf::Vector2f(-110, -243);
			result->CleaningOffsets[3] = sf::Vector2f(23, -243);
		}
		if (blarand == 2)
		{
			spriteName += "_Grandpa";
		}
		if (blarand == 3)
		{
			spriteName += "_Indian";
			result->CleaningOffsets[0] = sf::Vector2f(39, 40);
			result->CleaningOffsets[1] = sf::Vector2f(-54, 50);
			result->CleaningOffsets[2] = sf::Vector2f(-63, -40);
			result->CleaningOffsets[3] = sf::Vector2f(0, -41);
		}
		if (blarand == 4)
		{
			spriteName += "_Intern";
		}
		if (blarand == 5)
		{
			spriteName += "_Mexican";
			result->CleaningOffsets[0] = sf::Vector2f(111, 39);
			result->CleaningOffsets[1] = sf::Vector2f(-126, 49);
			result->CleaningOffsets[2] = sf::Vector2f(-16, -47);
			result->CleaningOffsets[3] = sf::Vector2f(3, -46);
		}
		if (blarand == 6)
		{
			spriteName += "_Russian";
		}
	}
	else
	{
		result->PersonGender = Person::Gender::Female;
		spriteName += "_Female";

		int blarand = rand() % 2;

		if (blarand == 0)
		{
			spriteName += "_Bitch";
		}
		if (blarand == 1)
		{
			spriteName += "_Intern";
			result->CleaningOffsets[0] = sf::Vector2f(16, -90);
			result->CleaningOffsets[1] = sf::Vector2f(-2, -80);
			result->CleaningOffsets[2] = sf::Vector2f(-40, -143);
			result->CleaningOffsets[3] = sf::Vector2f(73, -161);
		}
	}

	std::wstring name = L"";
	if (result->PersonGender == Person::Gender::Male)
	{
		name += this->FirstNamesMale[rand() % this->FirstNamesMale.size()] + L" ";
	}
	else
	{
		name += this->FirstNamesFemale[rand() % this->FirstNamesFemale.size()] + L" ";
	}
	if (rand() % 100 < 5)
	{
		if (result->PersonGender == Person::Gender::Male)
		{
			name += this->FirstNamesMale[rand() % this->FirstNamesMale.size()] + L" ";
		}
		else
		{
			name += this->FirstNamesFemale[rand() % this->FirstNamesFemale.size()] + L" ";
		}

//.........这里部分代码省略.........

 int Worker::main(void* _worker)
 {
   Worker* worker = static_cast<Worker*>(_worker);
   worker->loop();
   return 0;
 }

int main(int argc, char const *argv[]) {
    Worker john;
    john.greeting();
    exiter();
    return 0;
}

void
Controller::restore(QString filename)
{
    Worker *worker = new Worker(this, Controller::RESTORE, filename);
    worker->start();
}

 Tbb_Folder(Worker & w)
 :w_(w)
 {
     out_ = w.neutral_(nt2::meta::as_<result_type>());
 }

static void *worker_run(void *arg)
{
    Worker *worker = (Worker *)arg;
    worker->run();
    return NULL;
}

int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
  try
    {
      CORBA::ORB_var orb =
        CORBA::ORB_init (argc, argv);

      if (parse_args (argc, argv) != 0)
        return 1;

      Worker worker (orb.in ());

      if (worker.activate (THR_NEW_LWP | THR_JOINABLE,
                           nthreads) != 0)
        ACE_ERROR_RETURN ((LM_ERROR,
                           "(%P|%t) Cannot activate worker threads\n"),
                          1);

      int timeout = 30;
      int now = 0;
      while (now < timeout &&
             ((expect_ex_kind == 0 && !worker.invocation_completed ()) ||
              (expect_ex_kind != 0 && expect_ex_kind != worker.received_ex_kind ()))
             )
        {
          std::cout << "." << std::flush;
          now += 1;
          ACE_Time_Value tv (1, 0);
          orb->run (tv);
        }
      ACE_ASSERT (now != 0);


      std::cout << std::endl;

      worker.done ();

      CORBA::Object_var object =
        orb->string_to_object (ior);

      Simple_Server_var server =
        Simple_Server::_narrow (object.in ());

      server->shutdown ();

      ACE_OS::sleep (1);

      orb->destroy ();

      worker.thr_mgr ()->wait ();


      bool expect_no_ex =
        expect_ex_kind == TAO::FOE_NON && worker.num_received_ex () == 0 && worker.invocation_completed ();
      bool expect_ex_received =
        expect_ex_kind == worker.received_ex_kind () && worker.num_received_ex () > 0 && !worker.invocation_completed ();
      if (expect_no_ex || expect_ex_received)
        {
          ACE_DEBUG ((LM_DEBUG, "(%P|%t)client: test passed.\n"));
          return 0;
        }
      else
        {
          ACE_DEBUG ((LM_ERROR, "(%P|%t)client: test failed.\n"));
          return 1;
        }
    }

  catch (const CORBA::Exception& ex)
    {
      ex._tao_print_exception ("Exception caught in main:");
      return 1;
    }

  return 0;
}

int main(int argc, char** argv){
    MPI_Init(&argc, &argv);
    Worker worker;
    worker.run();
    MPI_Finalize();
}

  void TntnetImpl::run()
  {
    log_debug("worker-process");

    _stop = false;

    if (_listeners.empty())
      throwRuntimeError("no listeners defined");

    log_debug(_listeners.size() << " listeners");

    if (_listeners.size() >= _minthreads)
    {
      log_warn("at least one more worker than listeners needed - set MinThreads to "
        << _listeners.size() + 1);
      _minthreads = _listeners.size() + 1;
    }

    if (_maxthreads < _minthreads)
    {
      log_warn("MaxThreads < MinThreads - set MaxThreads = MinThreads = " << _minthreads);
      _maxthreads = _minthreads;
    }

    // initialize worker-process

    // SIGPIPE must be ignored
    ::signal(SIGPIPE, SIG_IGN);

    // create worker-threads
    log_info("create " << _minthreads << " worker threads");
    for (unsigned i = 0; i < _minthreads; ++i)
    {
      log_debug("create worker " << i);
      Worker* s = new Worker(*this);
      s->create();
    }

    // create poller-thread
    log_debug("start poller thread");
    _pollerthread.start();

    log_debug("start timer thread");
    cxxtools::AttachedThread timerThread(cxxtools::callable(*this, &TntnetImpl::timerTask));
    timerThread.start();

    {
      cxxtools::MutexLock lock(allTntnetInstancesMutex);
      allRunningTntnetInstances.insert(this);
    }

    // mainloop
    cxxtools::Mutex mutex;
    while (!_stop)
    {
      {
        cxxtools::MutexLock lock(mutex);
        _queue.noWaitThreads.wait(lock);
      }

      if (_stop)
        break;

      if (Worker::getCountThreads() < _maxthreads)
      {
        log_info("create workerthread");
        Worker* s = new Worker(*this);
        s->create();
      }
      else
        log_info("max worker-threadcount " << _maxthreads << " reached");

      if (TntConfig::it().threadStartDelay > 0)
        usleep(TntConfig::it().threadStartDelay.totalUSecs());
    }

    log_info("stopping TntnetImpl");

    {
      cxxtools::MutexLock lock(allTntnetInstancesMutex);
      allRunningTntnetInstances.erase(this);
    }

    log_info("stop listener");
    for (listeners_type::iterator it = _listeners.begin(); it != _listeners.end(); ++it)
      (*it)->terminate();

    log_info("stop poller thread");
    _poller.doStop();
    _pollerthread.join();

    log_info("stop timer thread");
    timerThread.join();

    if (Worker::getCountThreads() > 0)
    {
      log_info("wait for " << Worker::getCountThreads() << " worker threads to stop");
      while (Worker::getCountThreads() > 0)
      {
        log_debug("wait for worker threads to stop; " << Worker::getCountThreads() << " left");
//.........这里部分代码省略.........