python day10

Threading用于提供线程相关的操作，线程是应用程序中工作的最小单元。

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import threading
import time
  
def show(arg):
    time.sleep(1)
    print 'thread'+str(arg)
  
for i in range(10):
    t = threading.Thread(target=show, args=(i,))
    t.start()
  
print 'main thread stop'

　　

上述代码创建了10个“前台”线程，然后控制器就交给了CPU，CPU根据指定算法进行调度，分片执行指令。

更多方法：

• start            线程准备就绪，等待CPU调度
• setName      为线程设置名称
• getName      获取线程名称
• setDaemon   设置为后台线程或前台线程（默认）
                     如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，均停止
                      如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止
• join              逐个执行每个线程，执行完毕后继续往下执行，该方法使得多线程变得无意义
• run              线程被cpu调度后自动执行线程对象的run方法

• 复制代码
  import threading
  import time
   
   
  class MyThread(threading.Thread):
      def __init__(self,num):
          threading.Thread.__init__(self)
          self.num = num
   
      def run(self):#定义每个线程要运行的函数
   
          print("running on number:%s" %self.num)
   
          time.sleep(3)
   
  if __name__ == '__main__':
   
      t1 = MyThread(1)
      t2 = MyThread(2)
      t1.start()
      t2.start()

  线程锁（Lock、RLock）

  由于线程之间是进行随机调度，并且每个线程可能只执行n条执行之后，当多个线程同时修改同一条数据时可能会出现脏数据，所以，出现了线程锁 - 同一时刻允许一个线程执行操作。

• 复制代码
  #!/usr/bin/env python
  # -*- coding:utf-8 -*-
  import threading
  import time
  
  gl_num = 0
  
  def show(arg):
      global gl_num
      time.sleep(1)
      gl_num +=1
      print gl_num
  
  for i in range(10):
      t = threading.Thread(target=show, args=(i,))
      t.start()
  
  print 'main thread stop'
  复制代码
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  #!/usr/bin/env python
  #coding:utf-8
     
  import threading
  import time
     
  gl_num = 0
     
  lock = threading.RLock()
     
  def Func():
      lock.acquire()
      global gl_num
      gl_num +=1
      time.sleep(1)
      print gl_num
      lock.release()
         
  for i in range(10):
      t = threading.Thread(target=Func)
      t.start()
  信号量（Semaphore）
  
  互斥锁 同时只允许一个线程更改数据，而Semaphore是同时允许一定数量的线程更改数据 ，比如厕所有3个坑，那最多只允许3个人上厕所，后面的人只能等里面有人出来了才能再进去。
  
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  import threading,time
   
  def run(n):
      semaphore.acquire()
      time.sleep(1)
      print("run the thread: %s" %n)
      semaphore.release()
   
  if __name__ == '__main__':
   
      num= 0
      semaphore  = threading.BoundedSemaphore(5) #最多允许5个线程同时运行
      for i in range(20):
          t = threading.Thread(target=run,args=(i,))
          t.start()

  #!/usr/bin/env python
  #coding:utf-8
     
  import threading
  import time
     
  gl_num = 0
     
  lock = threading.RLock()
     
  def Func():
      lock.acquire()
      global gl_num
      gl_num +=1
      time.sleep(1)
      print gl_num
      lock.release()
         
  for i in range(10):
      t = threading.Thread(target=Func)
      t.start()
  

  　　

  Timer

  定时器，指定n秒后执行某操作

• from threading import Timer
   
   
  def hello():
      print("hello, world")
   
  t = Timer(1, hello)
  t.start()  # after 1 seconds, "hello, world" will be printed
  Python 进程
  

  　　Python 进程

• from multiprocessing import Process
  import threading
  import time
    
  def foo(i):
      print 'say hi',i
    
  for i in range(10):
      p = Process(target=foo,args=(i,))
      p.start()
  

  　　select

• #!/usr/bin/env python
  #-*-coding:utf-8-*
  import socket,select
  sk = socket.socket()
  sk.bind(('127.0.0.1',9999))
  sk.listen(5)
  inputs = [sk,] #sk服务端socket
  outputs = []
  message = {}
  while True:
      rlist,wlist,e = select.select(inputs,outputs,[],1)
      print (len(inputs),len(rlist),len(wlist))
      for i in rlist:
          if i ==sk:
              conn,addre = i.accept()
              #conn其实是socket对象
              inputs.append(conn)
              message[conn] = []
              #conn.sendall(bytes('hello',encoding='utf-8'))
          else:
              #有人给我发消息了
              try:
                 ret = i.recv(1024)
                 if not ret:
                     raise Exception('断开连接')
                 else:
                     outputs.append(i)
                     message[i].append(ret)
              except Exception as e:
                  inputs.remove(i)
                  del message[i]
      #所有给我发过消息的人
      for w in wlist:
          msg = message[w].pop()
          resp = msg + bytes('+response',encoding='utf-8')
          w.sendall(resp)
          outputs.remove(w)