多线程C调用python api的陷阱

http://blog.csdn.net/networm3/article/details/42423393

众所周知，用脚本语言编写的服务（wsgi接口）都需要一个server容器，常见的如php的php-fpm, lightd等。python中一般是用的uwsgi，uwsgi是在wsgi的基础上的一种新的协议，可以用来部署python等脚本程序的运行。然而在不熟悉uwsgi的代码架构和c调用python的api情况下进行开发可能会遇到一些意想不到的问题。

我们先看一段代码，下面这段代码是用的Flask框架，每次请求的时候会把COUNT的值先减一再加一，最后再乘二。如果请求50次，其最终的结果应该是2的50次幂。

[python] view plain copy

1. from flask import Flask, request  
2.   
3. COUNT = 1   
4.   
5. app = Flask(__name__)  
6.  
7.  
8. @app.route('/test_uwsgi')  
9. def index():  
10.     global COUNT  
11.     COUNT=COUNT-1  
12.     COUNT=COUNT+1  
13.     COUNT=COUNT*2  
14.     print COUNT  
15.     return 'OK'  

[plain] view plain copy

1. 17179869184  
2. 34359738368  
3. 68719476736  
4. 137438953472  
5. 274877906944  
6. 549755813888  
7. 1099511627776  
8. 2199023255552  
9. 4398046511104  
10. 8796093022208  
11. 17592186044416  
12. 35184372088832  
13. 70368744177664  
14. 140737488355328  
15. 281474976710656  
16. 562949953421312  
17. 1125899906842624  

这是直接执行50次index函数得到的最后几行的结果，可得结果为2的50次幂。

[plain] view plain copy

1.  536870912  
2.  1073741824  
3. 2147483648  
4. 4294967296  
5. 8589934592  
6. 17179869184  
7. 34359738368  
8.  68719476736  
9. 137438953472  
10. 274877906944  
11. 549755813888  
12. 1099511627776  
13.  2199023255552  
14.  4398046511104  
15. 8796093022208  
16. 17592186044416  
17.  35184372088832  
18. 70368744177664  
19.  140737488355328  
20. 281474976710656  
21. 5629499534213121125899906842624  

这是通过ab测试，用多个并发访问/test_uwsgi接口50次得到的最后几行的结果。可以看出最终的结果肯定是个异常数字。为什么程序在uwsgi中运行时的运行结果会出现异常呢？

其实大家通过阅读这个简单的例子就可以发现，这种例子一般都是用来演示多线程共享数据同步问题的时候，如果不加锁会暴露问题的例子。下面的代码我们就在修改共享资源COUNT的时候加上互斥锁，看看有没有什么变化。

[python] view plain copy

1. from flask import Flask, request  
2. import threading  
3.   
4. mutex = threading.Lock()  
5. COUNT = 1   
6.   
7. app = Flask(__name__)  
8.  
9.  
10. @app.route('/test_uwsgi')  
11. def index():  
12.     global COUNT  
13.     global mutex  
14.     mutex.acquire()  
15.     COUNT=COUNT-1  
16.     COUNT=COUNT+1  
17.     COUNT=COUNT*2  
18.     print COUNT  
19.     mutex.release()  
20.     return 'OK'  

上面的代码也是放到uwsgi的容器里面运行，通过http接口多个并发访问50次，得到的结果是正确的。但是这是为什么呢？在我们原来的python代码中并没有写任何涉及多进程的操作，虽然uwsgi在配置文件中开启了多个线程可以并发的处理请求，但是按笔者原来的理解，不是应该每个线程执行自己独立的Python解释器吗？每个线程在运行python脚本的时候的数据不应该是隔离的吗？

为了弄明白上面的问题，我们不得不研究研究uwsgi及其server架构中的结构和设计。

UWSGI是在python中广泛使用的一个服务器应用容器，类似于php上常见的wsgi协议的服务器应用容器，如mod-php、php-fpm、lightd等。uwsgi协议是在原有的wsgi协议之上新增了一套uwsgi的协议。

通过研读uwsgi的源码（core/uwsgi.c core/loop.c core/init.c core/master_util.c core/util.c），可以知道uwsgi的server设计，采用的是UNX书中介绍归纳的服务器程序设计范式8，暨TCP预先创建线程服务器程序，每个线程各自accept。

[python] view plain copy

1. int main(int argc, char *argv[], char *envp[]) {  
2.     uwsgi_setup(argc, argv, envp);  
3.     return uwsgi_run();  
4. }  
5.   
6. void uwsgi_setup(int argc, char *argv[], char *envp[]) {  
7.   
8.     int i;  
9.   
10.     struct utsname uuts;  
11.   
12.     ......  
13.   
14.     ...设置和初始化各种资源，这里就省略了，有兴趣的自己看看  
15.       
16.     ......  
17.   
18.     //最主要的是这行  
19.     uwsgi_start((void *) uwsgi.argv);  
20. }  
21.   
22. int uwsgi_start(void *v_argv) {  
23.   
24.     ......  
25.   
26.     简化摘要一些主要的代码  
27.   
28.     ......  
29.   
30.     ... 题外话，这里是创建一个多线程的共享内存空间，后面uwsgi_setup_workers的时候会用到。  
31.         因为uwsgi有一个master进程，可以监测各个子进程的状态，所以需要一块匿名共享内存  
32.     // initialize sharedareas  
33.     uwsgi_sharedareas_init();  
34.   
35.     // setup queue  
36.     if (uwsgi.queue_size > 0) {  
37.         uwsgi_init_queue();  
38.     }  
39.   
40.     ... 这里很重要，uwsgi.p是一个接口，uwsgi中部署的app在这里初始化（在uwsgi中，部署的APP需要所对应语言的插件，如python就用python插件）  
41.         后面也会看到，实际上uwsgi所执行的python代码，其所有模块的import都在这里执行  
42.     // initialize request plugin only if workers or master are available  
43.     if (uwsgi.sockets || uwsgi.master_process || uwsgi.no_server || uwsgi.command_mode || uwsgi.loop) {  
44.         for (i = 0; i < 256; i++) {  
45.             if (uwsgi.p[i]->init) {  
46.                 uwsgi.p[i]->init();  
47.             }  
48.         }  
49.     }  
50.   
51.     // again check for workers/sockets...  
52.     if (uwsgi.sockets || uwsgi.master_process || uwsgi.no_server || uwsgi.command_mode || uwsgi.loop) {  
53.         for (i = 0; i < 256; i++) {  
54.             if (uwsgi.p[i]->post_init) {  
55.                 uwsgi.p[i]->post_init();  
56.             }  
57.         }  
58.     }  
59.   
60.     。。。这里主要是设置各个worker的共享内存空间  
61.     // initialize workers/master shared memory segments  
62.     uwsgi_setup_workers();  
63.   
64.     // here we spawn the workers...  
65.     if (!uwsgi.status.is_cheap) {  
66.         if (uwsgi.cheaper && uwsgi.cheaper_count) {  
67.             int nproc = uwsgi.cheaper_initial;  
68.             if (!nproc)  
69.                 nproc = uwsgi.cheaper_count;  
70.             for (i = 1; i <= uwsgi.numproc; i++) {  
71.                 if (i <= nproc) {  
72.                     if (uwsgi_respawn_worker(i))  
73.                         break;  
74.                     uwsgi.respawn_delta = uwsgi_now();  
75.                 }  
76.                 else {  
77.                     uwsgi.workers[i].cheaped = 1;  
78.                 }  
79.             }  
80.         }  
81.         else {  
82.             for (i = 2 - uwsgi.master_process; i < uwsgi.numproc + 1; i++) {  
83.                 。。。这里就是根据我们设置的进程数，去fork子进程  
84.                 if (uwsgi_respawn_worker(i))  
85.                     break;  
86.                 uwsgi.respawn_delta = uwsgi_now();  
87.             }  
88.         }  
89.     }  
90.   
91.   
92.     // END OF INITIALIZATION  
93.     return 0;  
94.   
95. }  
96.   
97. int uwsgi_respawn_worker(int wid) {  
98.   
99.     。。。主要是这行代码，fork子进程，里面就不跟了  
100.     pid_t pid = uwsgi_fork(uwsgi.workers[wid].name);  
101.   
102.     if (pid == 0) {  
103.         signal(SIGWINCH, worker_wakeup);  
104.         signal(SIGTSTP, worker_wakeup);  
105.         uwsgi.mywid = wid;  
106.         uwsgi.mypid = getpid();  
107.         // pid is updated by the master  
108.         //uwsgi.workers[uwsgi.mywid].pid = uwsgi.mypid;  
109.         // OVERENGINEERING (just to be safe)  
110.         uwsgi.workers[uwsgi.mywid].id = uwsgi.mywid;  
111.         /*  
112.            uwsgi.workers[uwsgi.mywid].harakiri = 0;  
113.            uwsgi.workers[uwsgi.mywid].user_harakiri = 0;  
114.            uwsgi.workers[uwsgi.mywid].rss_size = 0;  
115.            uwsgi.workers[uwsgi.mywid].vsz_size = 0;  
116.          */  
117.         // do not reset worker counters on reload !!!  
118.         //uwsgi.workers[uwsgi.mywid].requests = 0;  
119.         // ...but maintain a delta counter (yes this is racy in multithread)  
120.         //uwsgi.workers[uwsgi.mywid].delta_requests = 0;  
121.         //uwsgi.workers[uwsgi.mywid].failed_requests = 0;  
122.         //uwsgi.workers[uwsgi.mywid].respawn_count++;  
123.         //uwsgi.workers[uwsgi.mywid].last_spawn = uwsgi.current_time;  
124.   
125.     }  
126.     else if (pid < 1) {  
127.         uwsgi_error("fork()");  
128.     }  
129.     else {  
130.         // the pid is set only in the master, as the worker should never use it  
131.         uwsgi.workers[wid].pid = pid;  
132.   
133.         if (respawns > 0) {  
134.             uwsgi_log("Respawned uWSGI worker %d (new pid: %d)\n", wid, (int) pid);  
135.         }  
136.         else {  
137.             uwsgi_log("spawned uWSGI worker %d (pid: %d, cores: %d)\n", wid, pid, uwsgi.cores);  
138.         }  
139.     }  
140.   
141.     return 0;  
142. }  
143.   
144. int uwsgi_run() {  
145.   
146.     。。。也是捡重要的摘抄一些  
147.         如果pid是master，就执行master_loop  
148.         如果pid是worker，就执行uwsgi_worker_run  
149.   
150.     // !!! from now on, we could be in the master or in a worker !!!  
151.     if (getpid() == masterpid && uwsgi.master_process == 1) {  
152.         (void) master_loop(uwsgi.argv, uwsgi.environ);  
153.     }  
154.   
155.     //from now on the process is a real worker  
156.     uwsgi_worker_run();  
157.     // never here  
158.     _exit(0);  
159.   
160. }  
161.   
162. void uwsgi_worker_run() {  
163.   
164.     int i;  
165.   
166.     if (uwsgi.lazy || uwsgi.lazy_apps) {  
167.         uwsgi_init_all_apps();  
168.     }  
169.   
170.     uwsgi_ignition();  
171.   
172.     // never here  
173.     exit(0);  
174.   
175. }  
176.   
177. void uwsgi_ignition() {  
178.   
179.     if (uwsgi.loop) {  
180.         void (*u_loop) (void) = uwsgi_get_loop(uwsgi.loop);  
181.         if (!u_loop) {  
182.             uwsgi_log("unavailable loop engine !!!\n");  
183.             exit(1);  
184.         }  
185.         if (uwsgi.mywid == 1) {  
186.             uwsgi_log("*** running %s loop engine [addr:%p] ***\n", uwsgi.loop, u_loop);  
187.         }  
188.         u_loop();  
189.         uwsgi_log("your loop engine died. R.I.P.\n");  
190.     }  
191.     else {  
192.         。。。子进程的循环体，一般是用simple_loop  
193.         if (uwsgi.async < 1) {  
194.             simple_loop();  
195.         }  
196.         else {  
197.             async_loop();  
198.         }  
199.     }  
200.   
201.     // end of the process...  
202.     end_me(0);  
203. }  
204.   
205.   
206. 。。。一直到这里，在子进程的loop里面才开始创建接收处理request请求的线程  
207.     线程的执行函数simple_loop_run也是一个循环，基本上都是常规步奏，accept，receive, response...，后面就不继续追下去了  
208.     在reciev接到请求的数据后，会通过python_call的方法调用python脚本的wsgi函数，处理这个请求  
209. void simple_loop() {  
210.     uwsgi_loop_cores_run(simple_loop_run);  
211. }  
212.   
213. void uwsgi_loop_cores_run(void *(*func) (void *)) {  
214.     int i;  
215.     for (i = 1; i < uwsgi.threads; i++) {  
216.         long j = i;  
217.         pthread_create(&uwsgi.workers[uwsgi.mywid].cores[i].thread_id, &uwsgi.threads_attr, func, (void *) j);  
218.     }  
219.     long y = 0;  
220.     func((void *) y);  
221. }  

简单来说，就是uwsgi中执行python脚本和直接运行python脚本是不同的。uwsgi执行python脚本是通过调用python c api的方法，首先通过调用api载入python脚本中的module，这时候，像最开始的实例代码一样module import中的相关代码会被执行，所有的全局变量在进程中被创建和初始化。然后uwsgi创建线程，开始处理请求调用python api（python_call），执行python脚本中处理请求的函数（wsgi接口），因为module import在线程创建之前已经执行了，所以之前在进程中的共享数据在线程中是可以访问的。这里就是需要我们着重注意的，在访问这些线程间共享数据的时候需要加锁，或者在编写python脚本的时候尽量少用全局变量而多用单例模式，避免不必要的采坑。

其实上面所述只是对我遇到问题的一个简化，为了帮助大家弄明白uwsgi多线程执行python wsgi接口的相关问题。我所遇到的问题是在处理请求的函数中，调用了一个在全局中创建的gearman client，这个client库不是线程安全的，使用中也没有加锁。当请求的并发比较大的时候，gearman client这个库就会报出一些连接的异常。

由于GIL的存在，Python的多线程并不能充分的利用多核的优势。在实际项目中，我们常常使用多进程来取代多线程的方法，来实现一些需要并发的业务。然而，进程的开销毕竟比较大，并且设计进程间的数据同步，进程间通信等操作相对线程来说十分的复杂，也是开发中的一个痛点，我们经常为了性能而放弃使用python转而使用c多线程的方案，但是确实降低了代码的可维护性，增加了代码的成本。

在了解了uwsgi的多线程结构之后，其实我们也可以学习其通过多线程调用python c api的方法，使用c的线程调用python的业务代码，将需要共享的数据放在c线程创建之前进行module import。将c多线程的部分提取出来成为一个框架，工程师只需要书写python的业务代码并在注意在使用共享数据的时候加锁。框架部分交由专业的有经验的c/python工程师进行维护，这样在不牺牲代码生产效率的前提下，提升了程序的性能。

后记：其实这个问题并不是十分的复杂，暴露的问题是对于uwsgi的代码结构，和python c api以及c调用python的方法和相关概念等不是非常的熟练，暴露了自己知识体系中的短板。由于那几天同时在开发几个需求，没有对问题进行详细的测试，没有仔细的分析和查找Trackback中的错误，反而是一直在怀疑被调用方的接口性能问题。其实这个团队在交流上确实也存在一些问题，争论基本上靠喊，靠抢话，不是就是论事而是经常人身攻击。每当有工程师的方案确实在理，确实证明是可用的时候，反对的人也宁死不妥协。。。这大概就是像新浪这样臃肿老旧缺少活力的大公司的通病吧（一点吐槽，熟人请无视）。