pid_t afork(int (*start_routine)(void *), void *arg);
pid_t aforkx(int flags /* FORK_NOSIGCHLD и/или FORK_WAITPID */, int (*fn)(void *), void *arg);

int emulated_afork(int (*start_routine)(void *), void *arg, void (*cb)(pid_t) /* может быть NULL */);

// Это работает, только если vfork() останавливает только один поток в родительском процессе, который вызвал vfork(), а не все потоки. Например, как в Linux.
// В противном случае это не сработает, и возможности реализовать avfork() нет. Конечно, в Linux можно просто использовать clone(2).
static struct avfork_taskq_s { /* опущено */ ... } *avfork_taskq;
static void
avfork_taskq_init(void)
{
    // Опущено, оставлено как упражнение для читателя
    ...
}
// Другие taskq функции, указанные ниже, также опущены
// taskq поток создает подпрограмму запуска
static void *
worker_start_routine(void *arg)
{
    struct worker_s *me = arg;
    struct job_s *job;
    
    // Регистрируем воркера и pthread_cond_signal() на до одного потока, который может ждать воркера.
    avfork_taskq_add_worker(avfork_taskq, me);
    do {
        if ((job = calloc(1, sizeof(*job))) == NULL ||
            pipe2(job->dispatch_pipe, O_CLOEXEC) == -1 ||
            pipe2(job->ready_pipe, O_CLOEXEC) == -1 ||
            (pid = vfork()) == -1) {
            avfork_taskq_remove(avfork_taskq, me, errno);  // Вышли!
            break;
        }
        if (pid != 0) {
            // Дочерний процесс завершился выполнил exit или exec
            if (job->errno)
                // Дочерний процесс не смог получить задание
                reap_child(pid);
            else
                // Дочерний процесс получил задание; запишите его, чтобы мы могли избавиться от него позже позже.
                // Это также помечает этот воркер как доступный и сигнализирует до одного потока, который может ожидать его.
                avfork_taskq_record_child(avfork_taskq, me, job, pid);
                
            if (avfork_taskq_too_big_p(avfork_taskq))
                break;  // Динамическое сжатие taskq
            continue;
        }
        
        // Это ребенок
      
        // Обратите внимание, что здесь вызываются только read(2), write(2), _exit(2) и start_routine из вызова avfork(). avfork() start_routine() должна вызывать только функции, безопасные для асинхронных сигналов, и не должна вызывать ничего, что небезопасно на дочерней стороне vfork(). В зависимости от ОС или библиотеки C может оказаться невозможным использовать что-либо или все из перечисленного: блокировки, условные переменные, аллокаторы, RTLD и т.д. По крайней мере, dup2(2), close(2), sigaction(2), Функции маскирования сигналов, exec(2) и _exit(2) можно безопасно вызывать в start_routine(), и этого достаточно для реализации posix_spawn(), более совершенного popen(), улучшенного system () и т.д.
        // Также обратите внимание, что дочерний процесс вообще не ссылается на taskq.
        // Получаем задачу
        if (net_read(me->dispatch_pipe[0], &job->descr, sizeof(job->descr)) != sizeof(job->descr)) {
            job->errno = errno ? errno : EINVAL;
            _exit(1);
        }
        job->descr->pid = getpid();  // Сохраняем pid, где поток в родительском процессе может видеть его
        if(net_write(me->ready_pipe[1], "", sizeof("")) != sizeof(""))  {
            job->errno = errno;
            _exit(1);
        }
        //Выполняем задачу
        _exit(job->descr->start_routine(job->descr->arg));
    } while(!avfork_taskq->terminated); // Возможно, это устанавливается через atexit()
    return NULL;
}
pid_t
avfork(int (*start_routine)(void *), void *arg)
{
    static pthread_once_t once = PTHREAD_ONCE_INIT;
    struct worker_s *worker;
    struct job_descr_s job;
    struct job_descr_s *jobp = &job;
    char c;
    // avfork_taskq_init() здесь опущен, но можно представить, как он выглядит. Он может вырасти до N рабочих потоков, и после этого, если нет доступных воркеров, тогда taskq.get_worker() блокируется в pthread_cond_wait(), пока воркер не будет готов.
    pthread_once(&once, avfork_taskq_init);
    // Описание задачи
    memset(&job, 0, sizeof(job));
    job.start_routine = start_routine;
    job.arg = arg;
    worker = avfork_taskq_get_worker(avfork_taskq); // Без блокировки, когда это возможно; при необходимости запускает воркера
    // Отправляем воркеру нашу задачу. Если нам повезет, мы только ждем, пока pre-vfork() ребенок прочитает нашу задачу и укажет на готовность. Если нам не повезло, то наш воркер занят обработкой vfork(). Однако рабочие потоки на самом деле мало что делают, поэтому обычно нам должно везти.
    //
    // Размер taskq должен быть таким, чтобы не было слишком много конфликтов для воркеров, и динамически расти, чтобы изначально не было воркеров.
    // Возможно, он может неограниченно расти, когда спрос велик, а затем сокращаться, когда спрос низкий (смотрите worker_start_routine()).
    if (net_write(worker->dispatch_pipe[1], &jobp, sizeof(jobp)) != sizeof(jobp) ||
        net_read(worker->ready_pipe[0], &c, sizeof(c)) != sizeof(c))
        job.errno = errno ? errno : EINVAL;
    // Очистка
    (void) close(worker->dispatch_pipe[0]);
    (void) close(worker->dispatch_pipe[1]);
    (void) close(worker->ready_pipe[0]);
    (void) close(worker->ready_pipe[1]);
    if (job.errno)
        return -1;
    return job.pid; // когда чтение заканчивается, PID находится в pid
}