fn write_first_in_line(msg: Message) {
    let msg_str: &str = msg.str();
    
    if let Err(err) = utils::try_write(&msg_str, msg.output_kind()) {
        let mut queue_guard = QUEUE.lock();
        queue_guard.insert(0, Message::error(format!(
            "comfy_print::blocking_write_first_in_line(): Failed to print first message in queue, it was pushed to the front again.\n\
            Error: {err}\n\
            Message: {msg_str}")));
        
        queue_guard.insert(1, msg);
    }
}

在这里，我们尝试写入目标输出。如果失败，我们将错误信息插入队列前面，然后是原始信息。

再次尝试不太可能产生结果，所以我们不应该做任何事情。

下次调用 comfy_print! 时我们会再次尝试。

fn check_thread() {
    let Some(mut thread_guard) = ACTIVE_THREAD.try_lock()
        else { return; };
    
    let is_printing = thread_guard.as_ref().is_some_and(|handle| !handle.is_finished());
    if is_printing { // We already pushed our msg to the queue and there's already a thread printing it, so we can return.
        return;
    }
    
    match thread::Builder::new().spawn(print_until_empty) {
        Ok(ok) => {
            *thread_guard = Some(ok);
            drop(thread_guard);
        },
        Err(err) => { // We couldn't create a thread, we'll have to block this one
            drop(thread_guard);
            
            let mut queue_guard = QUEUE.lock();
            queue_guard.insert(0, Message::error(format!(
                "comfy_print::queue_then_check_thread(): Failed to create a thread to print the queue.\n\
                Error: {err}.")));
            
            drop(queue_guard);
            print_until_empty();
        }
    }
}

这里有很多事情在进行，所以让我们将其分解为更小的步骤

let Some(mut thread_guard) = ACTIVE_THREAD.try_lock()
    else { return; };

let is_printing = thread_guard.as_ref().is_some_and(|handle| !handle.is_finished());
if is_printing { // We already pushed our msg to the queue and there's already a thread printing it, so we can return.
    return;
}

首先，通过尝试获取锁，我们执行一个非阻塞操作，这会告诉我们是否已有其他线程正在使用它。如果是这样，我们可以假设其他线程也即将开始打印队列。我们可以在这里停止。

如果我们成功获取了锁，我们可以检查那里是否有东西，并且如果里面的处理器属于已经完成的线程。

如果处理器存在且未完成，这意味着其他线程正在积极打印队列，因此我们可以返回。

match thread::Builder::new().spawn(print_until_empty) {

在这里，我们尝试创建一个新的线程，请求它执行函数 fn print_until_empty().

Ok(handle) => {
    *thread_guard = Some(handle);
    drop(thread_guard);
},

如果创建线程成功，我们将处理器插入我们的静态 Mutex 中，其他线程将检查它以确定它们是否可以承担打印责任。

像往常一样，我们立即释放我们持有的锁。

Err(err) => {
    drop(thread_guard);
    
    let mut queue_guard = QUEUE.lock();
    queue_guard.insert(0, Message::error(format!(
        "comfy_print::queue_then_check_thread(): Failed to create a thread to print the queue.\n\
        Error: {err}.")));
    
    drop(queue_guard);
}

如果由于任何原因创建线程失败，我们有一个新的错误信息要打印。

再次提醒，在获取队列的锁之前，我们释放引用处理器的锁，然后将在队列前面插入错误信息。

现在我们返回，希望用户再次调用打印，这将读取队列并尝试打印所有存储的消息。

fn print_until_empty() {
    const MAX_RETRIES: u8 = 50;
    let mut retries = 0;
    
    loop {
        let mut queue_guard = QUEUE.lock();
        
        if queue_guard.len() <= 0 {
            drop(queue_guard);
            break;
        }
        
        let msg = queue_guard.remove(0);
        let msg_str: &str = msg.str();
        let output_kind = msg.output_kind();
        drop(queue_guard); // unlock the queue before blocking stdout/err

        let write_result = utils::try_write(&msg_str, output_kind);
        
        if let Err(err) = write_result {
            let mut queue_guard = QUEUE.lock();
            queue_guard.insert(0, Message::error(format!(
                "comfy_print::write_until_empty(): Failed to print first message in queue.\n\
                Error: {err}\n\
                Message: {msg_str}\n\
                Target output: {output_kind:?}")));
            
            queue_guard.insert(1, msg);
            drop(queue_guard);
            
            retries += 1;
            if retries >= MAX_RETRIES {
                break;
            }
        }

        thread::yield_now();
    }
}

这是实际打印队列的函数，让我们将其分解为更小的步骤。

const MAX_RETRIES: u8 = 50;
let mut retries = 0;

首先，我们有一个任意整数定义了在打印操作失败时最大重试次数，以及用于计数尝试的局部整数 retries。

let mut queue_guard = QUEUE.lock();

if queue_guard.len() <= 0 {
    drop(queue_guard);
    break;
}

在循环内部，我们锁定队列，然后如果队列为空则停止，因为这表示我们的任务已完成。

let msg = queue_guard.remove(0);
let msg_str: &str = msg.str();
let output_kind = msg.output_kind();
drop(queue_guard); // unlock the queue before blocking stdout/err

我们从队列中弹出前端的元素，然后立即释放锁。

在这里释放锁也确保我们不会同时持有两个锁，因为我们即将锁定输出流。

let write_result = utils::try_write(&msg_str, output_kind);

if let Err(err) = write_result {
    let mut queue_guard = QUEUE.lock();
    queue_guard.insert(0, Message::error(format!(
        "comfy_print::write_until_empty(): Failed to print first message in queue.\n\
        Error: {err}\n\
        Message: {msg_str}\n\
        Target output: {output_kind:?}")));
    
    queue_guard.insert(1, msg);
    drop(queue_guard);
    
    retries += 1;
    if retries >= MAX_RETRIES {
        break;
    }
}

thread::yield_now();

如果写入输出失败，我们将在队列前插入错误消息，然后是原始消息。

然而，由于我们保证不在主线程中，我们可以稍微延长打印责任，我们将尝试打印最多 MAX_RETRIES 次。

无论打印结果如何，在每个迭代结束时，我们都调用 thread::yield_now(); 这将给其他线程一个机会，希望它们能够解决输出流的错误，同时允许更多消息加入队列。