如果先决条件尚未完成处理，如何让线程等待，并在先决条件完成后恢复？

#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;
bool ready = false;

void worker_thread() {
    std::unique_lock<std::mutex> lock(mtx);
    while (!ready) {
        lock.unlock();
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        lock.lock();
    }
    // 先决条件已满足，继续执行
    std::cout << "Worker thread is processing data...\n";
}

void main_thread() {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;
    }
    std::cout << "Main thread signals data ready.\n";
}

int main() {
    std::thread worker(worker_thread);
    main_thread();
    worker.join();
    return 0;
}

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void worker_thread() {
    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, []{ return ready; });
    // 先决条件已满足，继续执行
    std::cout << "Worker thread is processing data...\n";
}

void main_thread() {
    std::this_thread::sleep_for(std::chrono::seconds(1));
    {
        std::lock_guard<std::mutex> lock(mtx);
        ready = true;
    }
    cv.notify_one();
    std::cout << "Main thread signals data ready.\n";
}

int main() {
    std::thread worker(worker_thread);
    main_thread();
    worker.join();
    return 0;
}

import threading
import time

semaphore = threading.Semaphore(0)
ready = False

def worker():
    semaphore.acquire()
    print("Worker thread is processing data...")

def main():
    global ready
    time.sleep(1)
    ready = True
    print("Main thread signals data ready.")
    semaphore.release()

t = threading.Thread(target=worker)
t.start()
main()
t.join()

import java.util.concurrent.*;

public class AsyncExample {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<String> future = executor.submit(() -> {
            Thread.sleep(1000);
            return "Data is ready";
        });

        System.out.println("Main thread waiting for data...");
        String result = future.get();
        System.out.println(result);
        executor.shutdown();
    }
}