就像 boost::lock_guard 一样， boost::unique_lock 的析构函数也会相应地释放互斥量。此外，可以手动地用 unlock() 释放互斥量。也可以像上面的例子那样，通过调用 release() 解除boost::unique_lock 和互斥量之间的关联。然而在这种情况下，必须显式地调用 unlock() 方法来释放互斥量，因为 boost::unique_lock 的析构函数不再做这件事情。
boost::unique_lock 这个所谓的独占锁意味着一个互斥量同时只能被一个线程获取。其他线程必须等待，直到互斥体再次被释放。 除了独占锁，还有非独占锁。 Boost.Thread里有个 boost::shared_lock 的类提供了非独占锁。 正如下面的例子，这个类必须和 boost::shared_mutex 型的互斥量一起使用。
#include <boost/thread.hpp>
#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>
void wait(int seconds)
{
boost::this_thread::sleep(boost::posix_time::seconds(seconds));
}
boost::shared_mutex mutex;
std::vector<int> random_numbers;
void fill()
{
std::srand(static_cast<unsigned int>(std::time(0)));
for (int i = 0; i < 3; ++i)
{
boost::unique_lock<boost::shared_mutex> lock(mutex);
random_numbers.push_back(std::rand());
lock.unlock();
wait(1);
}
}
void print()
{
for (int i = 0; i < 3; ++i)
{
wait(1);
boost::shared_lock<boost::shared_mutex> lock(mutex);
std::cout << random_numbers.back() << std::endl;
}
}
int sum = 0;
void count()
{
for (int i = 0; i < 3; ++i)
{
wait(1);
boost::shared_lock<boost::shared_mutex> lock(mutex);
sum += random_numbers.back();
}
}
int main()
{
boost::thread t1(fill);
boost::thread t2(print);
boost::thread t3(count);
t1.join();
t2.join();
t3.join();
std::cout << "Sum: " << sum << std::endl;
}
boost::shared_lock 类型的非独占锁可以在线程只对某个资源读访问的情况下使用。一个线程修改的资源需要写访问，因此需要一个独占锁。 这样做也很明显：只需要读访问的线程不需要知道同一时间其他线程是否访问。 因此非独占锁可以共享一个互斥体。
在给定的例子里， print() 和 count() 都可以只读访问 random_numbers 。 虽然 print() 函数把 random_numbers 里的最后一个数写到标准输出，count() 函数把它统计到 sum 变量。 由于没有函数修改 random_numbers，所有的都可以在同一时间用 boost::shared_lock 类型的非独占锁访问它。
在 fill() 函数里，需要用一个 boost::unique_lock 类型的非独占锁，因为它插入了一个新的随机数到 random_numbers。在 unlock() 显式地调用 unlock() 来释放互斥量之后， fill() 等待了一秒。 相比于之前的那个样子，在 for 循环的尾部调用 wait() 以保证容器里至少存在一个随机数，可以被print() 或者 count() 访问。 对应地，这两个函数在 for 循环的开始调用了 wait() 。
考虑到在不同的地方每个单独地调用 wait() ，一个潜在的问题变得很明显:函数调用的顺序直接受CPU执行每个独立进程的顺序决定。 利用所谓的条件变量，可以同步哪些独立的线程，使数组的每个元素都被不同的线程立即添加到 random_numbers 。
#include <boost/thread.hpp>
#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>
boost::mutex mutex;
boost::condition_variable_any cond;
std::vector<int> random_numbers;
void fill()
{
std::srand(static_cast<unsigned int>(std::time(0)));
for (int i = 0; i < 3; ++i)
{
boost::unique_lock<boost::mutex> lock(mutex);
random_numbers.push_back(std::rand());
cond.notify_all();
cond.wait(mutex);
}
}
void print()
{
std::size_t next_size = 1;
for (int i = 0; i < 3; ++i)
{
boost::unique_lock<boost::mutex> lock(mutex);
while (random_numbers.size() != next_size)
cond.wait(mutex);
std::cout << random_numbers.back() << std::endl;
++next_size;
cond.notify_all();
}
}
int main()
{
boost::thread t1(fill);
boost::thread t2(print);
t1.join();
t2.join();
}
这个例子的程序删除了wait() 和count() 。线程不用在每个循环迭代中等待一秒，而是尽可能快地执行。此外，没有计算总额；数字完全写入标准输出流。
为确保正确地处理随机数，需要一个允许检查多个线程之间特定条件的条件变量来同步不每个独立的线程。
正如上面所说，fill() 函数用在每个迭代产生一个随机数，然后放在random_numbers 容器中。 为了防止其他线程同时访问这个容器，就要相应得使用一个排它锁。 不是等待一秒，实际上这个例子却用了一个条件变量。调用 notify_all() 会唤醒每个哪些正在分别通过调用wait() 等待此通知的线程。
通过查看 print() 函数里的 for 循环，可以看到相同的条件变量被 wait() 函数调用了。 如果这个线程被 notify_all() 唤醒，它就会试图这个互斥量，但只有在 fill() 函数完全释放之后才能成功。
这里的窍门就是调用 wait() 会释放相应的被参数传入的互斥量。 在调用 notify_all()后， fill() 函数会通过 wait() 相应地释放线程。 然后它会阻止和等待其他的线程调用 notify_all() ，一旦随机数已写入标准输出流，这就会在 print() 里发生。
注意到在 print() 函数里调用 wait() 事实上发生在一个单独 while 循环里。 这样做的目的是为了处理在 print() 函数里第一次调用 wait() 函数之前随机数已经放到容器里。 通过比较 random_numbers 里元素的数目与预期值，发现这成功地处理了把随机数写入到标准输出流。
四、线程本地存储
线程本地存储（TLS）是一个只能由一个线程访问的专门的存储区域。 TLS的变量可以被看作是一个只对某个特定线程而非整个程序可见的全局变量。 下面的例子显示了这些变量的好处。
#include <boost/thread.hpp>
#include <iostream>
#include <cstdlib>
#include <ctime>
void init_number_generator()
{
static bool done = false;
if (!done)
{
done = true;
std::srand(static_cast<unsigned int>(std::time(0)));
}
}
boost::mutex mutex;
void random_number_generator()
{
init_number_generator();
int i = std::rand();
boost::lock_guard<boost::mutex> lock(mutex);
std::cout << i << std::endl;
}
int main()
{
boost::thread t[3];
for (int i = 0; i < 3; ++i)
t[i] = boost::thread(random_number_generator);
for (int i = 0; i < 3; ++i)
t[i].join();
}
该示例创建三个线程，每个线程写一个随机数到标准输出流。 random_number_generator() 函数将会利用在C++标准里定义的 std::rand() 函数创建一个随机数。 但是用于 std::rand() 的随机数产生器必须先用 std::srand() 正确地初始化。 如果没做，程序始终打印同一个随机数。
随机数产生器，通过 std::time() 返回当前时间， 在 init_number_generator() 函数里完成初始化。 由于这个值每次都不同，可以保证产生器总是用不同的值初始化，从而产生不同的随机数。因为产生器只要初始化一次， init_number_generator() 用了一个静态变量 done 作为条件量。
如果程序运行了多次，写入的三分之二的随机数显然就会相同。事实上这个程序有个缺陷：std::rand所用的产生器必须被各个线程初始化。因此init_number_generator() 的实现实际上是不对的，因为它只调用了一次std::srand()。使用TLS，这一缺陷可以得到纠正。
#include <boost/thread.hpp>
#include <iostream>
#include <cstdlib>
#include <ctime>
void init_number_generator()
{
static boost::thread_specific_ptr<bool> tls;
if (!tls.get())
tls.reset(new bool(false));
if (!*tls)
{
*tls = true;
std::srand(static_cast<unsigned int>(std::time(0)));
}
}
boost::mutex mutex;
void random_number_generator()
{
init_number_generator();
int i = std::rand();
boost::lock_guard<boost::mutex> lock(mutex);
std::cout << i << std::endl;
}
int main()
{
boost::thread t[3];
for (int i = 0; i < 3; ++i)
t[i] = boost::thread(random_number_generator);
for (int i = 0; i < 3; ++i)
t[i].join();
}
用一个TLS变量 tls 代替静态变量 done，是基于用 bool 类型实例化的 boost::thread_specific_ptr 。原则上， tls 工作起来就像 done ：它可以作为一个条件指明随机数发生器是否被初始化。 但是关键的区别，就是 tls 存储的值只对相应的线程可见和可用。
一旦一个 boost::thread_specific_ptr 型的变量被创建，它可以相应地设置。 不过，它期望得到一个 bool 型变量的地址，而非它本身。使用reset()方法，可以把它的地址保存到 tls 里面。 在给出的例子中，会动态地分配一个bool型的变量，由new返回它的地址，并保存到 tls 里。为了避免每次调用init_number_generator()都设置tls ，它会通过get()函数检查是否已经保存了一个地址。
由于boost::thread_specific_ptr保存了一个地址，它的行为就像一个普通的指针。 因此，operator*()和operator->()都被被重载以方便使用。这个例子用*tls检查这个条件当前是true还是false。再根据当前的条件，随机数生成器决定是否初始化。
正如所见，boost::thread_specific_ptr允许为当前进程保存一个对象的地址，然后只允许当前进程获得这个地址。然而，当一个线程已经成功保存这个地址，其他的线程就会可能就失败。
如果程序正在执行时，它可能会令人感到奇怪：尽管有了TLS的变量，生成的随机数仍然相等。 这是因为，三个线程在同一时间被创建，从而造成随机数生成器在同一时间初始化。如果该程序执行了几次，随机数就会改变，这就表明生成器初始化正确了。