3

（第一个问题如下）

终于如我所愿！好头疼^^

不使用池是答案；）

所以，这是我的代码，输出如下！

正如您在输出中看到的那样，我的工作在工人 1 和 2 之间平均分配，而工人 0 正在运行一项长时间的工作！

<?php
class ChildThread extends Threaded {
  public $workerId;
  protected $complete;

  public function __construct($workerId){
    // init some properties
    $this->workerId = $workerId;
    $this->complete = false;
  }
  public function run(){
    // do some work
    echo "    STARTING " . $this->workerId . "\r\n";
    if($this->workerId == 0){
        sleep(10);
      } else {
        sleep(1);
      }
    echo "        ENDING " . $this->workerId . "\r\n";
    $this->complete = true;
  }
  public function isComplete() { 
      return $this->complete; 
  }
}

$WORKER_COUNT = 3;

$workers = array();
for ($i=0; $i<$WORKER_COUNT; $i++) {
  $worker = new Worker();
  $worker->start();
  $workers[] = $worker;
}

$tasks = array();
//Create 9 jobs
for ($i=0; $i < 9; $i++) { 
  $tasks[] = new ChildThread($i);
}

$cptTasks = 0;
//References for running jobs
$taskss = array();

while(count($tasks) > 0){
  foreach ($workers as $key => $worker) {
    if($worker->isShutdown()){
      echo "Shutdowned worker ".$key.", restarting it !"."\r\n";
      $worker->start();
    }
    //If worker is free of charge
    if($worker->isWorking() === false ){
      //Check if task not null
      if(isset($tasks[$cptTasks])){
        echo ("Stacking job ".$cptTasks." on worker ".$key."\r\n");
        $worker->stack($tasks[$cptTasks]);
        $taskss[] = $tasks[$cptTasks];
        //Clear job from jobs list
        unset($tasks[$cptTasks]);
        $cptTasks++;
      }
    }
  }
  usleep(2000);
}

//Clear workers
foreach ($workers as $key => $worker) {
  echo "Shutdown worker : " .$key."\r\n";
  $worker->shutdown();
}

?>

输出： 在工人 0 上堆叠作业 0 在工人
1 上堆叠作业 1 在工人
2 上堆叠作业 2
STARTING 1
STARTING 0
STARTING 2
ENDING 1
ENDING 2
在工人 1 上
堆叠作业 3 在工人 2 上堆叠作业 4
STARTING 3
STARTING 4
ENDING 3
ENDING 4
将作业 5 堆叠在工人 1 上 将
作业 6 堆叠在工人 2 上
STARTING 5
STARTING 6
ENDING 5
ENDING 6
将作业 7 堆叠在工人 1
上 将作业 8 堆叠在工人 2 上
STARTING 7
STARTING 8
关闭工人：0
ENDING 8
ENDING 7
ENDING 0
关闭工人：1
关闭工人：2

我正在开发一个 pthread 系统，并且我正在尝试实现一种池系统。

目前，我正在创建一个由 3 个工作人员组成的池，然后使用 pool->submit() 发送我的工作。

然后，pool->collect()

和 pool->shutdown()

但是，我对结果很失望。

工作似乎平均分配给所有工人

工人 1：工作 1、4、7

工人 2：工作 2、5、8

工人 3：工作 3、6、9

然后，假设我的工作 1 很长，而其他所有工作都不长，我的工作将像这样完成：

2、5、3、6、8、9、1、4、7

但是，我想要实现的应该更像：2、3、5、4、6、8、7、9、1

就像将工作分配给最近的不工作的工人一样，所以我的繁重工作在工人 1 上运行，而所有其他工作都交给工人 2 和 3

这是可行的吗？

我在这里错过了什么？

代码示例：

    <?php

class ChildThread extends Threaded {
  public $jobId;
  protected $complete;

  public function __construct($jobId){
    // init some properties
    $this->jobId = $jobId;
    $this->complete = false;
  }
  public function run(){
    echo "STARTING " . $this->jobId . "\r\n";
    //Job ID 1 == heavy waiting
    if($this->jobId == 1){
      sleep(10);
    } else {
      sleep(1);
    }
    echo "ENDING " . $this->jobId . "\r\n";

    $this->complete = true;
  }
  public function isComplete() { 
      return $this->complete; 
  }
}


$pool = new Pool(3);
$tasks = array();

// Add tasks to pool queue
for ($i=1; $i<=9; $i++) {
  $task = new ChildThread($i);
  $pool->submit($task);
  $tasks[] = $task;
}

$pool->collect(function($work){
  return $work->isComplete();
});
$pool->shutdown();

?>

结果：
开始 1
开始 2
开始 3
结束 2
开始 5
结束 3
开始 6
结束 5
开始 8
结束 6
开始 9
结束 8
结束 9
结束 1
开始 4
结束 4
开始 7
结束 7

4

0 回答 0