python多线程和多进程（一）

一、多线程

1. Python的标准库提供了两个模块：_thread和threading，_thread是低级模块，threading是高级模块，对_thread进行了封装。绝大多数情况下，只需要使用threading这个模块。

   import threading
   from time import ctime,sleep
   def func1(func):
       print u" 我是函数%s.此刻打印时间： %s" %(func,ctime())
       sleep(5)
       print u'%s再次打印时间%s' % (func,ctime())
   def func2(func):
       print u"我是函数 %s此刻打印时间： %s" %(func,ctime())
       sleep(5)
       print u'%s再次打印时间%s'%(func,ctime())
   
   threads = []
   t1 = threading.Thread(target=func1,args=('func1',)) #创建线程，args传参必须以元组方式传入
   threads.append(t1)
   t2 = threading.Thread(target=func2,args=('func2',))#创建线程，args传参必须以元组方式传入
   threads.append(t2)
   if __name__ == '__main__': 
        for t in threads: 
          # t.setDaemon(True) #设置守护线程（主线程退出，子线程也会退出，不会挂起占用资源）
            t.start() #启动线程
        print u'脚本结束时间%s'%ctime()

   运行结果：（注意setDaemon（））

   我是函数func1.此刻打印时间： Fri Sep 07 15:43:15 2018
   我是函数 func2此刻打印时间： Fri Sep 07 15:43:15 2018
   脚本结束时间Fri Sep 07 15:43:15 2018  #（三个都是同一时间打印）
    
   func1再次打印时间Fri Sep 07 15:43:20 2018
   func2再次打印时间Fri Sep 07 15:43:20 2018 #（两个都为等待5秒后同事打印）

   说明;func1,func2都是同时一时间执行任务了，但是为什么脚本结束时间先打印了，原因是主线程被分成两个子线程同时运行，但是子线程有等待5秒但主线程没有等待就直接执行了打印了；

2. 我们稍作改进：

   import threading
   from time import ctime,sleep
   def func1(func):
       print u" 我是函数%s.此刻打印时间： %s" %(func,ctime())
       sleep(5)
       print u'%s再次打印时间%s' % (func,ctime())
   def func2(func):
    
       print u"我是函数 %s此刻打印时间： %s" %(func,ctime())
       sleep(5)
       print u'%s再次打印时间%s'%(func,ctime())
   threads = []
   t1 = threading.Thread(target=func1,args=('func1',))
   threads.append(t1)
   t2 = threading.Thread(target=func2,args=('func2',))
   threads.append(t2)
    
   if __name__ == '__main__':
       for t in threads:
           # t.setDaemon(True) #设置守护线程（主线程退出，子线程也会退出，不会挂起占用资源）
           t.start()
       for t in threads:
           t.join()  # 等待线程执行结束
   print u'脚本结束时间%s'%ctime()

   我是函数func1.此刻打印时间： Fri Sep 07 16:09:29 2018
   我是函数 func2此刻打印时间： Fri Sep 07 16:09:29 2018
   func1再次打印时间Fri Sep 07 16:09:34 2018
   func2再次打印时间Fri Sep 07 16:09:34 2018
   脚本结束时间Fri Sep 07 16:09:34 2018

   　　主线程执行到，然后等待子线程；

3. 上个第一次使用线程写东西的项目吧，去年刚开始写爬虫因为数量多所以网上到处找资料，东拼西凑总算给我搞出来了

   #encoding:utf-8
   import requests
   import threading
   from lxml import etree
   import codecs,csv
    
   def return_link():
       Link = []
       for  i in range(2000):
           url="http://www.xzgsj.gov.cn/baweb/show/shiju/gg.jsp?fenceid=95000000&total=45192&queryType=6&pagenum="+str(i)+"&action=gg.jsp?ssid=ZxSlh1DBkGGpV2hnWMSt5PG7f8FPjTbvH78vJ1nFcwYyMhWzGBzy!1470507879!1500631589968&findWenhao=&findName="
           Link.append(url)
       return  Link
    
   def get_href():
       while True:
           lock.acquire()
           if len(Link) == 0:
               lock.release()
               break
           else:
               url = Link.pop(0)
               lock.release()
               r = requests.get(url, headers=headers).content
               print url
               pages = etree.HTML(r.decode('utf-8'))
               a = pages.xpath(u"//table[@width='700']/tr[position()>1]/td/a/@onclick")
               for i in a:
                   a = i.replace('javaScript:window.open(\'', '').replace('\',\'a\',\'width=550 height=350\')', '')
                   url = 'http://www.xzgsj.gov.cn/baweb/show/shiju/' + a
                   with codecs.open('url.csv','ab') as f:
                       w = csv.writer(f)
                       w.writerow([url])
    
   if __name__ == '__main__':
       headers = {
           "User-Agent": "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/59.0.3071.115 Safari/537.36"
       }
       lock = threading.Lock()#线程锁
       Link = return_link()
       tasks = []  # 任务列表
       for x in range(5):
           t = threading.Thread(target=get_href)  # 准备线程函数及参数
           t.setDaemon(True)  # 设置守护线程（主线程退出，子线程也会退出，不会挂起占用资源）
           tasks.append(t)
       for t in tasks:
           t.start()  # 启动多线程（任务列表有多少个值，就会启动多少个线程）
       for t in tasks:
           t.join()  # 等待线程执行结束

4. 使用Threading模块创建线程，直接从threading.Thread继承，然后重写__init__方法和run方法：（和第一个例子一样只是基于类的使用）

   import threading
   from time import ctime,sleep
    
   class myThread(threading.Thread):  # 继承父类threading.Thread
       def __init__(self, threadID, name, counter):
           threading.Thread.__init__(self)
           self.threadID = threadID
           self.name = name
           self.counter = counter
       def run(self):  # 把要执行的代码写到run函数里面 线程在创建后会直接运行run函数
           print "Starting " + self.name,u'时间{}'.format(ctime())
           sleep(5)
           print "Exiting " + self.name,u'时间{}'.format(ctime())
    
   # 创建新线程
   thread1 = myThread(1, "Thread-1", 1)
   thread2 = myThread(2, "Thread-2", 2)
    
   # 开启线程
   tasks = []
   tasks.append(thread1)
   tasks.append(thread2)
   if __name__ == '__main__':
       for t in tasks:
           # t.setDaemon(True) #设置守护线程（主线程退出，子线程也会退出，不会挂起占用资源）
           t.start()
       for t in tasks:
           t.join()  # 等待线程执行结束
       print u'脚本结束时间%s'%ctime()
   结果：

   Starting Thread-1 时间Fri Sep 07 17:13:53 2018
   Starting Thread-2 时间Fri Sep 07 17:13:53 2018

   Exiting Thread-1 时间Fri Sep 07 17:13:58 2018
   Exiting Thread-2 时间Fri Sep 07 17:13:58 2018

   脚本结束时间Fri Sep 07 17:13:58 201

    

5. 第一篇over,以后想到再加吧