我有以下代码，来自https://en.cppreference.com/w/cpp/thread/unique_lock。但是，在打印输出时，我看到了一些意外的结果，并且需要一些解释。

代码是：

#include <mutex>
#include <thread>
#include <chrono>
#include <iostream>
 
struct Box {
    explicit Box(int num) : num_things{num} {}
 
    int num_things;
    std::mutex m;
};
 
void transfer(Box &from,Box &to,int anotherNumber)
{
    // don't actually take the locks yet
    std::unique_lock<std::mutex> lock1(from.m,std::defer_lock);
    std::unique_lock<std::mutex> lock2(to.m,std::defer_lock);
 
    // lock both unique_locks without deadlock
    std::lock(lock1,lock2);
 
    from.num_things += anotherNumber;
    to.num_things += anotherNumber;
    
    std::cout<<std::this_thread::get_id()<<" "<<from.num_things<<"\n";
    std::cout<<std::this_thread::get_id()<<" "<<to.num_things<<"\n";
    // 'from.m' and 'to.m' mutexes unlocked in 'unique_lock' dtors
}
 
int main()
{
    Box acc1(100);   //initialized acc1.num_things = 100
    Box acc2(50);    //initialized acc2.num_things = 50
 
    std::thread t1(transfer,std::ref(acc1),std::ref(acc2),10);
    std::thread t2(transfer,5);
 
    t1.join();
    t2.join();
}

我的期望：

1. acc1将使用num_things = 100初始化，而acc2将使用num_things = 50初始化。
假设线程t1首先运行，它获取具有2个锁的互斥锁m。一旦锁被锁定，并且可以将num_things分配给num = 10
2. 完成后，将按顺序从from.num_things = 110和to.numthings = 60打印。 “从”开始，然后“到”。
3. thread1完成了代码的关键部分，包装器unique_lock调用了它的析构函数，该析构函数基本上解锁了互斥体。

这是我不理解的。

我希望lock1填充首先被解锁，然后lock2被解锁。 然后线程t2以相同的顺序获取互斥对象，并先锁定lock1，然后再锁定lock2。它还将按顺序运行关键代码直到cout。

线程t2将从t1开始使用全局acc1.num_things = 110和acc2.num_things = 60。

我希望t2将首先从.num_things = 115开始打印，然后从to.numthings = 65开始打印。

但是，经过无数次试用，我总是得到相反的命令。那就是我的困惑。