C＋＋实现并行计算

介绍

在现代计算机中，由于多核处理器的日益普及和横空出世，程序员们必须要考虑如何利用多核心的CPU来进行并行计算，以充分利用计算机的性能。C++是一门基础性较强的编程语言，由于相应的STL和BOOST库的强大支持，使其具备了很好的并行计算能力。本文将从以下几个方面介绍如何使用C++进行并行计算：

1. 如何使用STL实现并行计算；
2. 如何使用BOOST实现并行计算;
3. 如何使用OpenMP进行并行计算。

使用STL实现并行计算

C++中的STL库提供了并行计算标准库，即execution。该标准库能够通过并行执行诸如transform、reduce、for_each和sort等操作，以提高程序的运行效率。

1. transform操作

   std::vector<int> vec {1, 2, 3, 4, 5};
   std::vector<int> result (vec.size ());
   std::transform (std::execution::par, vec.begin (), vec.end (),
                   result.begin (),
                   [] (int i) {return i * i;});
   

   在上面这个例子中，使用了transform算法，实现并行计算vector容器中每个元素的平方，并将结果存储在result容器中。

2. reduce操作

   std::vector<int> vec {1, 2, 3, 4, 5};
   auto sum = std::reduce (std::execution::par, vec.begin (), vec.end ());
   

   在上面这个例子中，使用了reduce算法，实现并行计算vector容器中所有元素的和。

3. for_each操作

   std::vector<int> vec {1, 2, 3, 4, 5};
   std::for_each (std::execution::par, vec.begin (), vec.end (),
                   [] (int& i) {i = i * i;});
   

   在上面这个例子中，使用了for_each算法，实现并行地对vector容器中的每个元素求平方。

4. sort操作

   std::vector<int> vec {3, 5, 2, 4, 6, 1};
   std::sort (std::execution::par, vec.begin (), vec.end ());
   

   在上面这个例子中，使用了sort算法，实现并行地对vector容器中的元素排序。

使用BOOST实现并行计算

BOOST是一个优秀、现代和高效的C++库，为开发人员提供了一种使用各种复杂操作的方法，具有很强的通用性和可移植性。在使用BOOST进行并行计算时，需要使用BOOST.Thread库提供的线程、互斥锁、条件变量等机制来控制并行执行的行为。

1. 线程机制

   #include <boost/thread.hpp>
   void my_thread_func (int id)
   {
       for (int i = 0; i < 10; i++)
       {
           std::cout << "Hello from thread " << id << std::endl;
           boost::this_thread::sleep_for (boost::chrono::milliseconds (500));
       }
   }
   int main ()
   {
       boost::thread my_thread (my_thread_func, 1);
       my_thread.join ();
       return 0;
   }
   

   上面这个例子中，首先我们定义了一个函数my_thread_func，用来在线程中执行任务。然后，在主函数中创建线程my_thread，并在创建时传入my_thread_func函数作为线程的执行任务。最后使用join函数等待线程my_thread执行完毕再退出程序。

2. 互斥锁机制

   #include <boost/thread.hpp>
   boost::mutex mut;
   void my_thread_func (int id)
   {
       mut.lock ();
       std::cout << "Thread " << id << " started" << std::endl;
       mut.unlock ();
       boost::this_thread::sleep_for (boost::chrono::milliseconds (500));
       mut.lock ();
       std::cout << "Thread " << id << " finished" << std::endl;
       mut.unlock ();
   }
   int main ()
   {
       const int num_threads = 5;
       boost::thread my_thread [num_threads];
       for (int i = 0; i < num_threads; i++)
           my_thread [i] = boost::thread (my_thread_func, i);
       for (int i = 0; i < num_threads; i++)
           my_thread [i].join ();
       return 0;
   }
   

   上面这个例子中，我们使用了互斥锁机制，在my_thread_func函数中加入了对共享变量的互斥保护，以防止多个线程同时访问该变量而引起的数据异常问题。

3. 条件变量机制

   #include <boost/thread.hpp>
   boost::mutex mut;
   boost::condition_variable cond_var;
   void my_thread_func (int id)
   {
       mut.lock (); //加锁
       std::cout << "Thread " << id << " started" << std::endl;
       //等待条件变量发生
       while (id != 1)
           cond_var.wait (mut);
       std::cout << "Thread " << id << " resumed" << std::endl;
       mut.unlock (); //解锁
   }
   int main ()
   {
       const int num_threads = 5;
       boost::thread my_thread [num_threads];
       for (int i = 0; i < num_threads; i++)
           my_thread [i] = boost::thread (my_thread_func, i);
       boost::this_thread::sleep_for (boost::chrono::milliseconds (1000));
       cond_var.notify_all ();
       for (int i = 0; i < num_threads; i++)
           my_thread [i].join ();
       return 0;
   }
   

   在上面这个例子中，我们使用了条件变量机制，以实现多个线程之间的同步和等待。在线程my_thread_fun中，当id不等于1时，该线程会等待条件变量的发生；当条件变量被notify_all函数激活时，所有等待该条件变量的线程会被唤醒并继续执行。

使用OpenMP进行并行计算

OpenMP是一种创建多线程程序的API，它可在共享存储系统中运行，以对称多处理器之类的硬件进行加速。它支持C、C++和Fortran，并适用于不同的计算机架构（包括Mac、Windows和Linux等）。OpenMP负责线程管理和共享内存的管理，利用这些机制，可以实现并行计算任务的高效执行。

1. 并行循环

   #include <omp.h>
   #include <iostream>
   #include <string>
   int main()
   {
       const int n = 100;
       int sum = 0;
       #pragma omp parallel for reduction(+:sum)
       for (int i = 0; i < n; ++i)
       {
           sum += i;
       }
       std::cout << "sum = " << sum << std::endl;
       return 0;
   }
   

   在上面这个例子中，我们使用了OpenMP库中的#pragma omp parallel for指令，以并行执行循环。在执行过程中，使用变量sum存储循环过程中的计算结果，并在循环结束后将结果累加。同时，在循环线程执行期间，使用指令#pragma omp parallel for reduction(+:sum)来将线程私有的sum变量归约为公共变量，以确保计算结果正确性。

2. 并行任务

   #include <omp.h>
   #include <iostream>
   #include <string>
   void my_task(int id)
   {
       std::cout << "Task " << id << " started." << std::endl;
       sleep(1);
       std::cout << "Task " << id << " finished." << std::endl;
   }
   int main()
   {
       const int n = 10;
       #pragma omp parallel for
       for (int i = 0; i < n; ++i)
       {
           my_task(i);
       }
       return 0;
   }
   

   在上面这个例子中，我们使用了OpenMP库中的#pragma omp parallel for指令，以并行执行多任务。在执行过程中，使用my_task函数来完成每个任务的计算。同时，在主函数中，使用指令#pragma omp parallel for来控制线程数。

3. 并行区块

   #include <omp.h>
   #include <iostream>
   #include <string>
   int main()
   {
       std::cout << "Main thread starts." << std::endl;
       #pragma omp parallel
       {
           std::cout << "Parallel thread starts." << std::endl;
           sleep(1);
           std::cout << "Parallel thread ends." << std::endl;
       }
       std::cout << "Main thread ends." << std::endl;
       return 0;
   }
   

   在上面这个例子中，我们使用了OpenMP库中的#pragma omp parallel指令，以在并行区块中并行执行多个任务。在执行过程中，主线程首先输出"Main thread starts."后，开始并行区块的执行，等待所有线程执行结束后再输出"Main thread ends."。在并行区块的执行过程中，每个线程输出"Parallel thread starts."，然后等待1秒钟后输出"Parallel thread ends."。