有时对于类里面某些处理函数，我们希望它可以使用多线程技术以加速其执行速度（当我做力扣, 发现提交超时时，我就超想通过多线程的方法用以解决超时的问题，但通常该超还是超，毕竟不知道力扣背后的平台是什么，哈哈哈哈）。对于Python来说，十分的简单。先举一道力扣上的题：

560. 和为K的子数组

给定一个整数数组和一个整数 k，你需要找到该数组中和为 k 的连续的子数组的个数。

示例 1 :

输入:nums = [1,1,1], k = 2

输出: 2 , [1,1] 与 [1,1] 为两种不同的情况。

说明 :

数组的长度为 [1, 20,000]。

数组中元素的范围是 [-1000, 1000] ，且整数 k 的范围是 [-1e7, 1e7]。

来源：力扣（LeetCode）

链接：https://leetcode-cn.com/problems/subarray-sum-equals-k

著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

以下是我的Python使用多线程的解法

  1. class Solution:
  2.     from threading import Lock
  4.     start = 0
  5.     ret = 0
  7.     lock1 = Lock()
  8.     lock2 = Lock()
  10.     def threadSum(self, nums, k):
  11.         while self.start < len(nums):
  12.             i = 0
  13.             tmp = 0
  14.             with self.lock1:
  15.                 i = self.start
  16.                 self.start = self.start + 1
  17.             while i < len(nums):
  18.                 tmp = tmp + nums[i]
  19.                 if tmp == k:
  20.                     with self.lock2:
  21.                         self.ret = self.ret + 1
  22.                 i = i + 1
  24.     def subarraySum(self, nums: List[int], k: int) -> int:
  25.         from threading import Thread
  27.         self.start = 0
  28.         self.ret = 0
  30.         t1 = Thread(target=self.threadSum, args=(nums, k,))
  31.         t2 = Thread(target=self.threadSum, args=(nums, k,))
  32.         t3 = Thread(target=self.threadSum, args=(nums, k,))
  33.         t4 = Thread(target=self.threadSum, args=(nums, k,))
  35.         t1.start()
  36.         t2.start()
  37.         t3.start()
  38.         t4.start()
  40.         t1.join()
  41.         t2.join()
  42.         t3.join()
  43.         t4.join()
  45.         return self.ret

程序运行没有任何问题，解题的答案也正确，不过毫无疑问，最终提交还是超时了，哈哈哈

但是当我用C++的多线程去解答这道题时，居然编译都没有通过。（多线程什么的，我以后还是用Python了）

  1. #include <iostream>
  2. #include <thread>
  3. #include <mutex>
  4. #include <vector>
  6. using namespace std;
  8. class Solution {
  9.     mutex mtx1;
  10.     mutex mtx2;
  12.     int start;
  13.     int ret;
  15.     vector<int>threadnums;
  17.     void multiSum(int k)
  18.     {
  19.         while(start < threadnums.size())
  20.         {
  21.             int i = 0;
  23.             mtx1.lock();
  24.             i = start;
  25.             start++;
  26.             mtx1.unlock();
  28.             int tmp = 0;
  29.             while(i < threadnums.size())
  30.             {
  31.                 tmp += threadnums[i];
  33.                 if(tmp == k)
  34.                 {
  35.                     mtx2.lock();
  36.                     ret++;
  37.                     mtx2.unlock();
  38.                 }
  40.                 i++;
  41.             }
  42.         }
  43.     }
  45.     public:
  47.     int subarraySum(vector<int>& nums, int k)
  48.     {
  49.         start = 0;
  50.         ret = 0;
  51.         threadnums = nums;
  53.         thread t1(multiSum, k);
  54.         thread t2(multiSum, k);
  55.         thread t3(multiSum, k);
  56.         thread t4(multiSum, k);
  58.         t1.join();
  59.         t2.join();
  60.         t3.join();
  61.         t4.join();
  63.         return ret;
  64.     }
  65. };
  67. int main()
  68. {
  69.     vector<int>testcase1{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,3,3,3,1,1,1,5};
  70.     int k = 5;
  71.     Solution *mysolution = new Solution();
  72.     cout << "test case result is: " << mysolution->subarraySum(testcase1, k) << endl;
  74.     return 0;
  75. }

那么为什么C++会出现这种情况呢？

C++之所以不能直接像Python的代码一样直接使用多线程技术，是因为C++类的成员函数的函数指针不能直接做为参数传到thread当中, 因为C++成员函数指针带有类命名空间，同时成员函数末尾是会被C++编译器加上可以接收对象地址的this指针参数，因此需要将成员函数做一定的转化，将其转化成不被编译器加上this指针，而由我们自己来为该函数维护”this”指针即可，其中一个办法就是在函数之前添加this指针，令类的成员函数变成静态成员函数。需要注意的是，因为静态成员函数不允许访问类中的非静态成员变量（因为没有this指针），所以在线程函数中，在参数中传入this指针。

修改后的代码如下

  1. #include <iostream>
  2. #include <thread>
  3. #include <mutex>
  4. #include <vector>
  6. using namespace std;
  8. class Solution {
  9.     mutex mtx1;
  10.     mutex mtx2;
  12.     int start;
  13.     int ret;
  15.     vector<int>threadnums;
  17.     static void multiSum(void* _this, int k)
  18.     {
  19.         //this指针是当前对象的首地址，可以通过类型转换来使用
  20.         Solution *obj = (Solution *)_this;
  21.         while(obj->start < obj->threadnums.size())
  22.         {
  23.             int i = 0;
  25.             obj->mtx1.lock();
  26.             i = obj->start;
  27.             obj->start++;
  28.             obj->mtx1.unlock();
  30.             int tmp = 0;
  31.             while(i < obj->threadnums.size())
  32.             {
  33.                 tmp += obj->threadnums[i];
  35.                 if(tmp == k)
  36.                 {
  37.                     obj->mtx2.lock();
  38.                     obj->ret++;
  39.                     obj->mtx2.unlock();
  40.                 }
  42.                 i++;
  43.             }
  44.         }
  45.     }
  47.     public:
  49.     int subarraySum(vector<int>& nums, int k)
  50.     {
  51.         start = 0;
  52.         ret = 0;
  53.         threadnums = nums;
  55.         thread t1(multiSum, (void*)this, k);
  56.         thread t2(multiSum, (void*)this, k);
  57.         thread t3(multiSum, (void*)this, k);
  58.         thread t4(multiSum, (void*)this, k);
  60.         t1.join();
  61.         t2.join();
  62.         t3.join();
  63.         t4.join();
  65.         return ret;
  66.     }
  67. };
  69. int main()
  70. {
  71.     vector<int>testcase1{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,3,3,3,1,1,1,5};
  72.     int k = 5;
  73.     Solution *mysolution = new Solution();
  74.     cout << "test case result is: " << mysolution->subarraySum(testcase1, k) << endl;
  76.     return 0;
  77. }

现在可以编译通过，也是可以得到正确的结果，不过最后的提交依旧还是超时。

所以在C++的类内开发多线程函数时，需要注意以下几点

  • 将线程函数声明为静态函数
  • 创建线程时传递this指针进去（静态成员函数时不存在this指针的）
  • 在线程函数中使用传进来的this指针调用类的成员，特别注意调用类的成员函数时要避免segmantation fault错误。

除了转换成static成员函数的方法外，采用友元函数也是可以的。通过定义线程函数为类的友元函数，令线程函数可以像类自己的成员函数一样访问其成员变量和成员函数。（类的友元函数是定义在类外部，但有权访问类的所有私有成员和保护成员）

参考资料
https://www.cnblogs.com/chay/p/10587490.html