05-09补 线程

for 循环打印原理与顺序：

1、验证实例：

for i in range(1,11)
    print(i)
print('我是主进程')

应：循环遍历完i后再执行主进程语句 ；

prime number 素数
判断1~100之间的素数：

方法1：
def isprime(m):
for i in range(2,m):
if m%i==0:
print(‘m 不是素数’) #这里return ‘mbu是素数’ 也可以
#如果遍历完小于m的除数，还无一个满足余数为0的除数，表明m是素数，直接返回
print(‘m是素数’)

#再将1-100之间的数遍历放进去判断是否满足条件
if name == ‘main’:
print filter(isprime,range(2,101))

方法二： 用线程

import threading
rs = []
lock = threading.Lock()
class Isprime(threading.Thread):
    def __init__(self,num,name=None):
        threading.Thread.__init__(self)
            self.num=num
       self.isstop = False
    def run(self):
        global rs,lock
        isprime = False
        m=self.num
        for i in range(2,m):
            if m % i ==0:
                isprime = True
                break
        lock.acquire()
        if not isprime:
                rs.append(m)
        lock.rlease()

def main():
    global rs
threads = []
    for i in range(2,101):
        threads.append(Isprime(i))
    for x in threads:
        x.start()
    for s in threads:
        s.join()

    print rs
    print len(rs)

if __name__ == '__main__':
   main()

线程实例2：
class Thread(threading.Thread): #实现多线程代码的可复用性，封装成类 class ，继承threading模块的thread类

```go
  def __init__(self,num)
        threading.Thread.__init__(self) # 父类属性
        self._num=num
        self.setDaemon(True)  #设置子线程为守护线程，必须再 start() 之前运行，作用：即使子线程没有结束，只要主进程运行

                                                    #完毕，子线程也会被kill； 防止程序被永久挂起
                                                    python 3.0版本好像没有了
    def run(self):
        global total,multex    
        print threading.currentThread().getName()
        for x in range(0,int(self.num)):
            multex.acquire()         #并发（排队执行）运算各线程之间通信需要非常小心，尤其写入文件，操作全局变量；
            total +=1                         #锁机制保证各线程之间正常运转
            if total==3000:           
                print  'now',total
                raw_input('> 暂停一会，按任意键继续:')
              mlutex.release()
if __name__ =="__main__":
    global total,multex
    total=0
    multex=threading.Lock()
    threads=[]                     #创建线程池，批量管理子线程
    for x in range(0,40):
        threads.append(Thread(100))  初始化Thread类并添加进线程池；
    for t in threads:
        t.start()
        t.join()          #join()  子线程完成之前主进程处于闭塞状态，待全部子线程完成后再运行
    print(total)

注释：

1、GIL：（interperter）将并发 运行变成 串行，（同一时刻同一进程内只有一个线程被执行）控制同一时间内共享数据只能被一个任务所修改，保证数据安全；

2、python的每个进程内有主线程、主线程开启的其他线程，解释器开启的垃圾回收等级别的线程，所有

  线程运行再同一各进程内，所有数据都是共享的；

3