1. Sleep in the main thread before acquiring the mutex. I don’t think this is technically a guarantee that the child will win the
   race, and I’d like to avoid sleeping in either thread if I can.

On one hand, this indeed does not guarantee that the new thread wins the race, and on the other hand, it does make it likely that the main thread will be delayed much longer than it needs to be. sleep() is not a synchronization or IPC device.

2. Ditch mutexes and wait in a while loop for the child to update a signal variable. I wouldn’t want to waste precious cycles busy waiting
   if I don’t have to.

This is actually viable, provided that you use an atomic signal variable. C has those built-in since C99, but I’m uncertain whether C++03 has them.

3. Transfer mutex ownership from parent to child? I’m not sure if this is possible

It’s not possible.

What other options are there? The solution only needs to work with Linux and GCC.

Simplest would probably be to use a semaphore. The main thread initializes it with value 0. After starting the other thread, the main thread attempts to decrement the semaphore, which blocks until the child increments it (if it hasn’t done so already).

That requires setting up only one synchronization object rather than two (mutex + cv), and the usage idiom is simpler than that of mutex + cv.

Also, this is adaptible without change to starting multiple threads (as mutex + cv also could be), for after the initial thread regains control, the semaphore is already prepared for another cycle.

Example code:

sem_t thread_start_lock;

void *thread(void *arg) {
    // do something ...

    sem_post(&thread_start_lock);  // probably abort() if this fails

    // ...
}

int main(void) {
   sem_init(&thread_start_lock, 0, 0);  // probably terminate if this fails

   pthread_t thread_id;
   pthread_create(&thread_id, NULL, thread, NULL);
   sem_wait(&thread_start_lock);

   // ...
}

Of course, for robustness you need to check return codes and handle errors. The code contains a couple of notes about that, but all the function calls presented need to be checked, not just the annotated ones.

If you must use pthreads only, then pthreads offers a conditional variable API that you can use to make the parent wait on a signal from the child, eg:

#include <pthread.h>

struct sChildInit
{
    pthread_cond_t cv;
    pthread_mutex_t mtx;
    bool finished;
};

void* childProcess(void *arg)
{
    sChildInit *init = (sChildInit*) arg;

    pthread_mutex_lock(&init->mtx);
    // do important initialization
    init->finished = true;
    pthread_cond_signal(&init->cv);
    pthread_mutex_unlock(&init->mtx);

    // do some parallel processing

    return NULL;
}

int main()
{
    sChildInit init;
    pthread_cond_init(&init.cv, NULL);
    pthread_mutex_init(&init.mtx, NULL);
    init.finished = false;

    pthread_t childThread;
    pthread_create(&childThread, NULL, childProcess, &init);

    // wait here for child initialization

    pthread_mutex_lock(&init.mtx);
    while (!init.finished)
        pthread_cond_wait(&init.cv, &init.mtx);
    pthread_mutex_unlock(&init.mtx);

    // do some parallel processing

    pthread_join(childThread, 0);
    pthread_cond_destroy(&init.cv);
    pthread_mutex_destroy(&init.mtx);

    return 0;
}

If you can use C++11 or later, use std::condition_variable (and std::thread) instead, eg:

#include <condition_variable>
#include <mutex>
#include <thread>
        
struct sChildInit
{
    std::conditional_variable cv;
    std::mutex mtx;
    bool finished = false;
};

void childProcess(sChildInit &init)
{
    {
    std::lock_guard<std::mutex> lk(init.mtx);
    // do important initialization
    init.finished = true;
    init.cv.notify_one();
    }

    // do some parallel processing
}

int main()
{
    sChildInit init;
    std::thread childThread(&childProcess, std::ref(init));

    // wait here for child initialization
    {
    std::unique_lock<std::mutex> lk(init.mtx);
    init.cv.wait(lk, [&]{ return init.finished; });
    }

    // do some parallel processing

    childThread.join();
    return 0;
}