threading包比thread提供的功能更全面,所以这里使用threading为例
不过本文不想过多讨论基础操作, 我比较好奇的是Python的GIL和线程安全问题(Java写多了)
import threading
def say(name):
for i in range(5):
print("from thread "+str(name));
t1 = threading.Thread(target=say,args=("1"));
t2 = threading.Thread(target=say,args=("2"));
t1.start();
t2.start();
上面这个例子会交替打印 message1 和message2
我们稍微做一下改变,让这两个线程一直循环下去好观察cpu的占用率
import threading
def say(name):
while(True):
print("from thread "+str(name));
t1 = threading.Thread(target=say,args=("1"));
t2 = threading.Thread(target=say,args=("2"));
t1.start();
t2.start();
因为window7本身是内核级进程(也是大多数Linux现在的默认设置),所以可以很清楚的观察到两个线程被平均分配到了4个内核中(我的环境是i7 4内核)
程序启动以后,4个核心的占用率直接飙升
即使使用一个线程进行while(true)循环你也会看到4个内核占用率同时提高,因为操作系统使用的线程实际上是一种轻量级进程
我们来测试一下使用python多线程执行密集型运算
import threading;
import sys;
import math;
import time;
from decimal import *;
def bellard(n):
pi=Decimal(0)
k=0
while k < n:
pi+=(Decimal(-1)**k/(1024**k))*( Decimal(256)/(10*k+1)+Decimal(1)/(10*k+9)-Decimal(64)/(10*k+3)-Decimal(32)/(4*k+1)-Decimal(4)/(10*k+5)-Decimal(4)/(10*k+7)-Decimal(1)/(4*k+3))
k+=1
pi=pi*1/(2**6)
return pi
def say(name):
start = time.clock();
for i in range(100):
p = bellard(1000);
# print("running..."+str(p));
end = time.clock();
print ("read: %f s" % (end - start));
t1 = threading.Thread(target=say,args=("1"));
t2 = threading.Thread(target=say,args=("2"));
t1.start();
t2.start();
双线程运行pi计算上面的代码会给出
read: 51.493309 s
read: 51.516034 s
改成单线程之后会得到如下结果
read: 24.826255 s
你会惊喜的发现时间缩短一倍, 那我们猜测如果3个线程的话会得到3倍左右的运算时间
read: 75.466136 s
read: 75.925743 s
read: 76.911878 s
Python使用一种叫做GIL ( 全局解释器锁 ) 的机制来调度线程
在主轮询中(这里鄙视一下某些书的翻译,把轮询翻译成循环) 同时只能有一个线程执行
有点像单核cpu执行多线程的模式,然后而又有点区别, java在单核cpu多线程时也需要考虑线程安全,因为有些变量是多线程之间共享的
Python这种一刀切的方式,干脆相当于在所有方法前都加上了 synchronized 同步
这里还有一个问题要强调一下, java 中 volatile 并不能保证变量是线程安全的
volatile 只是告诉虚拟机在每次使用这个变量时,去堆内存中重新读一下, 如果主内存变量发生修改之后，线程工作内存中的值由于已经加载，不会产生对应的变化
这里我们用java的多线程模型做对比
java没有GIL, 是真实的多线程,也就是说一个线程在4内核上需要10秒钟的运算,两个线程在4内核上也需要10秒,因为java可以真正同时使用两个内核进行运算(两个内核各运行10秒)
这里需要注意以下几点
1. 不要在循环中使用System.out.print输出任何字符,因为会造成IO消耗,等待时间大部分都是IO造成的,测试不准确
2. 不要使用惯用的sleep方法来测试,sleep方法只是计时器,不能造成cpu密集型运算
public class Test {
static Runnable r = new Runnable(){
@Override
public void run() {
long startTime=System.currentTimeMillis();
for(int i=0;i<10000000;i++){
cut(20L);
}
System.out.println("running...");
long endTime=System.currentTimeMillis();
System.out.println("程序运行时间： "+(endTime-startTime)+"ms");
}
};
public static void main(String args[]) throws InterruptedException{
Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
t1.start();
t2.start();
}
static void cut(Long n){
double y=1.0;
for(Long i=0L;i<=n;i++){
double π=3*Math.pow(2, i)*y;
// System.out.println("第"+i+"次切割,为正"+(6+6*i)+"边形，圆周率π≈"+π);
y=Math.sqrt(2-Math.sqrt(4-y*y));
}
}
}
上面的程序在调用两个线程时会给出下面的结果
running...
程序运行时间： 14933ms
running...
程序运行时间： 14937ms
在调用三个线程时会给出
running...
程序运行时间： 15639ms
running...
程序运行时间： 15654ms
running...
程序运行时间： 15689ms
调用四个线程
running...
程序运行时间： 16069ms
running...
程序运行时间： 16099ms
running...
程序运行时间： 16154ms
running...
程序运行时间： 16197ms
这个时候我的4内核cpu应该已经处于饱和状态了,最后我们尝试调用8个线程
running...
程序运行时间： 31569ms
running...
程序运行时间： 32132ms
running...
程序运行时间： 32156ms
running...
程序运行时间： 32166ms
running...
程序运行时间： 32132ms
running...
程序运行时间： 32208ms
running...
程序运行时间： 32370ms
running...
程序运行时间： 32321ms
正如所料,消耗了差不多4线程的两倍时间,因为我的cpu已经饱和了
java的jvm实际上只有一个进程,但是由于使用了内核级线程(轻量级进程),操作系统会把运算工作分发给4个内核同时运行,是真正的多线程
