wordpress旧版本下载app关键词优化

如果可能，避免错误共享

当在不同处理器上运行的多个并发任务写入位于同一高速缓存行上的变量时，会发生错误共享。 当一个任务写入一个变量时，这两个变量的缓存行将会失效。 每当缓存行失效时，每个处理器必须重新加载缓存行。 因此，错误共享会导致应用程序中的性能降低。

以下基本示例介绍了两个并发任务，每个任务都增加了共享的计数器变量。

volatile long count = 0L;
concurrency::parallel_invoke([&count] {for(int i = 0; i < 100000000; ++i)InterlockedIncrement(&count);},[&count] {for(int i = 0; i < 100000000; ++i)InterlockedIncrement(&count);}
);

若要消除两个任务间的数据共享，可修改该示例以使用两个计数器变量。 任务完成后，此示例将计算最终的计数器值。 但此示例还说明了错误共享，因为变量 count1 和 count2 可能位于同一缓存行。

long count1 = 0L;
long count2 = 0L;
concurrency::parallel_invoke([&count1] {for(int i = 0; i < 100000000; ++i)++count1;},[&count2] {for(int i = 0; i < 100000000; ++i)++count2;}
);
long count = count1 + count2;

消除错误共享的一种方法是确保计数器变量位于不同的缓存行。 下面的示例将对齐 64 字节边界上的 count1 和 count2 变量。 

__declspec(align(64)) long count1 = 0L;      
__declspec(align(64)) long count2 = 0L;      
concurrency::parallel_invoke([&count1] {for(int i = 0; i < 100000000; ++i)++count1;},[&count2] {for(int i = 0; i < 100000000; ++i)++count2;}
);
long count = count1 + count2;

此示例假定内存缓存的大小为 64 个或更少的字节。

当必须在任务之间共享数据时，我们建议使用 concurrency::combinable 类。 combinable 类以不太可能发生错误共享的方式创建线程本地变量。

确保变量在任务的整个生存期内有效

如果向任务组或并行算法提供 Lambda 表达式，capture 子句将指定 Lambda 表达式的主体是否通过值或引用访问封闭范围中的变量。 通过引用将变量传递到 Lambda 表达式时，必须保证该变量的生存期在任务完成之前一直保持。

请看下面的示例，该示例定义了 object 类和 perform_action 函数。 perform_action 函数创建 object 变量，并在该变量中以异步方式执行某项操作。 由于不能保证在 perform_action 函数返回前完成任务，因此，如果 object 变量在任务运行时被销毁，则程序将崩溃或发生未指定的行为。

// lambda-lifetime.cpp
// compile with: /c /EHsc
#include <ppl.h>using namespace concurrency;// A type that performs an action.
class object
{
public:void action() const{// TODO: Details omitted for brevity.}
};// Performs an action asynchronously.
void perform_action(task_group& tasks)
{// Create an object variable and perform some action on // that variable asynchronously.object obj;tasks.run([&obj] {obj.action();});// NOTE: The object variable is destroyed here. The program// will crash or exhibit unspecified behavior if the task// is still running when this function returns.
}

具体取决于应用程序的要求，可使用以下方法之一来保证变量在每项任务的整个生存期保持有效。

下面的示例通过值将 object 变量传入任务。 因此，任务可在自己的变量副本上进行操作。

// Performs an action asynchronously.
void perform_action(task_group& tasks)
{// Create an object variable and perform some action on // that variable asynchronously.object obj;tasks.run([obj] {obj.action();});
}

由于 object 变量通过值进行传递，因此，此变量发生的任何状态更改不会出现在原始副本。

以下示例使用 concurrency::task_group::wait 方法确保在 perform_action 函数返回以前完成任务。

// Performs an action.
void perform_action(task_group& tasks)
{// Create an object variable and perform some action on // that variable.object obj;tasks.run([&obj] {obj.action();});// Wait for the task to finish. tasks.wait();
}

由于函数返回前任务现在完成了，因此，perform_action 函数不再以异步方式进行。

下面的示例修改 perform_action 函数以获取对 object 变量的引用。 调用方必须保证 object 变量的生存期在任务完成前是有效的。

// Performs an action asynchronously.
void perform_action(object& obj, task_group& tasks)
{// Perform some action on the object variable.tasks.run([&obj] {obj.action();});
}

也可使用指针来控制传入任务组或并行算法的对象的生存期。