多线程实例、锁

1. 多线程实例
   进程是程序在计算机上的一次执行活动。当你运行一个程序，你就启动了一个进程。显然，程序是死的(静态的)，进程是活的(动态的)。进程可以分为系统进程和用户进程。凡是用于完成操作系统的各种功能的进程就是系统进程，它们就是处于运行状态下的操作系统本身；用户进程就不必我多讲了吧，所有由你启动的进程都是用户进程。进程是操作系统进行资源分配的单位。 
   它的思想简单介绍如下：在操作系统的管理下，所有正在运行的进程轮流使用CPU，每个进程允许占用CPU的时间非常短(比如10毫秒)，这样用户根本感觉不出来CPU是在轮流为多个进程服务，就好象所有的进程都在不间断地运行一样。但实际上在任何一个时间内有且仅有一个进程占有CPU。
   多进程和多线程的区别：
   多线程使用的是cpu的一个核，适合io密集型
   多进程使用的是cpu的多个核，适合运算密集型
   组件：
   Python提供了非常好用的多进程包，multiprocessing，我们在使用的时候，只需要导入该模块就可以了。
   Multiprocessing支持子进程，通信，共享数据，执行不同形式的同步，提供了Process，Pipe, Lock等组件
   Process
   1. 创建一个Process对象
   p = multiprocessing.Process(target=worker_1, args=(2, ))
   target = 函数名字
   args = 函数需要的参数，以tuple的形式传入
   注意： 单个元素的tuple的表现形式
   multprocessing用到的两个方法
   cpu_count() 统计cpu总数
   active_children() 获得所有子进程
    Process的常用方法
   is_alive() 判断进程是否存活
   run() 启动进程
   start() 启动进程，会自动调用run方法，这个常用
   join(timeout) 等待进程结束或者直到超时
   Process的常用属性
   name 进程名字
   pid 进程的pid
   

   import multiprocessing
   import time
   def work(interval, method):
       print("start work_" + method)
       time.sleep(interval)
       print("end work_" + method)
   
   
   if __name__ == "__main__":
       p1 = multiprocessing.Process(target=work, args=(1, "1"))
       p2 = multiprocessing.Process(target=work, args=(2, "2"))
       p3 = multiprocessing.Process(target=work, args=(3, "3"))
       p1.start()
       p2.start()
       p3.start()
       print("The number of CPU is:") + str(multiprocessing.cpu_count())
       for p in multiprocessing.active_children():
       print("The name of active child is: " + p.name + ", pid is: " + str(p.pid) + "is alive: " + str(p.is_alive()))   print("MAIN IS END!")

   
   
2. 多线程锁
   资源加锁其实并不是给资源加锁, 而是用锁去锁定资源，你可以定义多个锁, 像下面的代码, 当你需要独占某一资源时，任何一个锁都可以锁这个资源。
   就好比你用不同的锁都可以把相同的一个门锁住是一个道理。
   

   import  threading   
   import  time   
         
   counter = 0 
   counter_lock = threading.Lock() #只是定义一个锁,并不是给资源加锁,你可以定义多个锁,像下两行代码,当你需要占用这个资源时，任何一个锁都可以锁这个资源 
   counter_lock2 = threading.Lock()  
   counter_lock3 = threading.Lock() 
      
   #可以使用上边三个锁的任何一个来锁定资源 
       
   class  MyThread(threading.Thread):#使用类定义thread，继承threading.Thread 
        def  __init__(self,name):   
           threading.Thread.__init__(self)   
           self.name = "Thread-" + str(name) 
        def run(self):   #run函数必须实现 
            global counter,counter_lock #多线程是共享资源的，使用全局变量 
            time.sleep(1);   
            if counter_lock.acquire(): #当需要独占counter资源时，必须先锁定，这个锁可以是任意的一个锁，可以使用上边定义的3个锁中的任意一个 
               counter += 1    
               print "I am %s, set counter:%s"  % (self.name,counter)   
               counter_lock.release() #使用完counter资源必须要将这个锁打开，让其他线程使用 
                  
   if  __name__ ==  "__main__":   
       for i in xrange(1,101):   
           my_thread = MyThread(i) 
           my_thread.start()

   线程不安全:
   最普通的一个多线程小例子。我一笔带过地讲一讲，我创建了一个继承Thread类的子类MyThread，作为我们的线程启动类。按照规定，重写Thread的run方法，我们的线程启动起来后会自动调用该方法。于是我首先创建了10个线程，并将其加入列表中。再使用一个for循环，开启每个线程。在使用一个for循环，调用join方法等待所有线程结束才退出主线程。
   这段代码看似简单，但实际上隐藏着一个很大的问题，只是在这里没有体现出来。你真的以为我创建了10个线程，并按顺序调用了这10个线程，每个线程为n增加了1.实际上，有可能是A线程执行了n++，再C线程执行了n++，再B线程执行n++。
   这里涉及到一个“锁”的问题，如果有多个线程同时操作一个对象，如果没有很好地保护该对象，会造成程序结果的不可预期（比如我们在每个线程的run方法中加入一个time.sleep(1)，并同时输出线程名称，则我们会发现，输出会乱七八糟。因为可能我们的一个print语句只打印出一半的字符，这个线程就被暂停，执行另一个去了，所以我们看到的结果很乱），这种现象叫做“线程不安全”
   线程锁：
   于是，Threading模块为我们提供了一个类，Threading.Lock，锁。我们创建一个该类对象，在线程函数执行前，“抢占”该锁，执行完成后，“释放”该锁，则我们确保了每次只有一个线程占有该锁。这时候对一个公共的对象进行操作，则不会发生线程不安全的现象了。
   于是，我们把代码更改如下：
   

   # coding : uft-8
   __author__ = 'Phtih0n'
   import threading, time
   class MyThread(threading.Thread):
       def __init__(self):
           threading.Thread.__init__(self)
       def run(self):
           global n, lock
           time.sleep(1)
           if lock.acquire():
               print n , self.name
               n += 1
               lock.release()
   if "__main__" == __name__:
       n = 1
       ThreadList = []
       lock = threading.Lock()
       for i in range(1, 200):
           t = MyThread()
           ThreadList.append(t)
       for t in ThreadList:
           t.start()
       for t in ThreadList:
           t.join()