你这种工作逻辑类似于流水线；
可以开N个消费者，通过队列来实现你要的功能；
工作流：1队列 --->>> 2队列 --->>> 3队列 --->>> 4队列 --->>> 5队列 --->>> 6队列

以TaskProcess 类为例，这个类只做2个事情

1. 构造方法传入任务类型或者处理的队列名
2. onWorkerStart运行后，添加每秒执行的定时器，去处理当前任务队列；

按你的流水线，在进程配置内新增进程配置（一定要设置构造函数 参数）
完毕。

进程配置

'pipeline_1' => [
    'count' => 1,
    'handler' => \process\TaskProcess::class,
    'constructor' => [
        'type' => '任务类型1',
        'queue' => '队列1'
    ],
],
'pipeline_2' => [
    'count' => 5,
    // 根据任务繁重情况设置进程数
    'handler' => \process\TaskProcess::class,
    'constructor' => [
        'type' => '任务类型2',
        'queue' => '队列2'
    ],
],
'pipeline_3' => [
    'count' => 3,
    // 根据任务繁重情况设置进程数
    'handler' => \process\TaskProcess::class,
    'constructor' => [
        'type' => '任务类型3',
        'queue' => '队列3'
    ],
],

<?php

namespace process;

use support\Redis;
use Workerman\Timer;

class TaskProcess
{
    /**
     * @var string
     */
    protected string $type;
    /**
     * @var string
     */
    protected string $queue;

    /**
     * 构造函数
     * @param string $type
     * @param string $queue
     */
    public function __construct(string $type, string $queue)
    {
        $this->type = $type;
        $this->queue = $queue;
    }

    /**
     * 根据类型，得到下一个工作流队列名称
     * @return string
     */
    public function getNextQueue(): string
    {
        //todo...
        switch ($this->type) {
            case '':
                return '';
            default:
                return '';
        }
    }

    /**
     * 进程启动时执行
     * @return void
     */
    public function onWorkerStart(): void
    {
        Timer::add(1, function () {
            //当前工作流队列内有任务
            if (Redis::lLen($this->queue)) {
                $data = Redis::lPop($this->queue);
                //todo... 完成当前流程，得到结果
                $result = call_user_func([$this, $this->type], $data);
                //todo... 投递到下个工作流队列
                Redis::rPush($this->getNextQueue(), $result);
            }
        });
    }

    /**
     * step1
     * @param $data
     * @return void
     */
    protected function step1($data): void
    {
        //todo... 业务逻辑
    }

    /**
     * step2
     * @param $data
     * @return void
     */
    protected function step2($data): void
    {
        //todo... 业务逻辑
    }

    /**
     * step3
     * @param $data
     * @return void
     */
    protected function step3($data): void
    {
        //todo... 业务逻辑
    }

    /**
     * step4
     * @param $data
     * @return void
     */
    protected function step4($data): void
    {
        //todo... 业务逻辑
    }
}

需要阻塞，数据来了立马执行立马传给下一个进程，分散到多个进程的目的就是为了最大化减少运行时间。

子进程A：--> 运行10秒计算任务 --> 等待数据1，收到后马上处理数据然后返回数据2 --> 运行10秒计算任务 --> 和主进程通信 -->……
子进程B：--> 运行10秒计算任务 --> 等待数据2，处理成数据3返回 --> 运行10秒计算任务 --> 和主进程通信 -->……
子进程C：--> 运行10秒计算任务 --> 等待数据3，处理成数据4返回 --> 运行10秒计算任务 --> 和主进程通信 -->……

最终的目的是要分散到64个进程同时计算

为什么非要强行用拖拉机干挂车的事?

主进程，子进程。
你应该是没看完手册，
webman，workerman 你知道主进程是干嘛用的吗，
你开的每一个进程都是平级的，workerman,webman的主进程用来

for ($process_sub>= 你设置的进程数){
创建一个子进程
}

workerman，webman的主进程主要是用来supervise用的，你还想主进程做啥呢。

你要是希望一个一个顺序处理，应该用到队列

你这样的想法，实际上是线程模型的思想，线程模型的思想主要是让主线程分配，子线程执行，主线程回收数据；
进程模型一般不会有这样的思路，通常来说不会通过主进程来进行任务的分配，而是通过一些共同特征，让子进程自己通过特征来获取自己应该获取的任务，而主进程只负责一件事情，就是子进程的正常运行和整体服务的正常运行；
如果你想要强行实现主进程分配任务让固定子进程进行处理，我建议每一个子进程都与主进程分别建立一条专属的channel，然后通过发布订阅的方式进行业务处理

我觉得你这个需要用go channel实现很简单