python 线程

线程：进程中的每个子任务，不能独立存在
    进程：独立的所有子任务的集合
线程，进程：目的都是想同时完成任务
特点：
    进程：独立（内存独立，CPU使用独立）启动进程效率低，开销大，进程之间很难共享数据，和数据通信，数据安全高
    线程;依赖进程（内存共享，CPU使用独立）启动开销小。线程之间容易共享数据，方便通信。线程不安全

如何使用上面的技术完成的多任务？
代码如何做？
Python：
    两种：函数和类
    python2：thread
    python3：_thread
            threading
import threading
import time
# 类
class mythread(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)
        print("mythread")
    def run(self):
        for i in range(1,11):
            print(i)
            time.sleep(1)#这里是按秒算的
    def start(self):
        print("开始mythread.....")
        threading.Thread.start(self)
t=mythread()
t.start()
t.join(3)#三秒后输出loading.....
print("loading......")
input()
join：线程阻塞方法线程，那个线程调用那个线程阻塞，直到join中制定的时间，或者run的代码完成
run()：使用户的任务方法，会在start之后自动调用
start：注意如果重写了start一定要调用父类的start

函数
def something():
    for i in range(1,11):
        print(i)
        time.sleep(1)
t=threading._start_new_thread(something,())
print("main.......")
print(t)


for n in range(30,20,-1):
    print(n)
    time.sleep(1)
input()



python set类是在python的set中，大家现在使用的python2.7.x中，不需要导入sets模块可以直接创建集合。
>>>set('boy')
set(['y', 'b', 'o'])
集合添加、删除
线程锁：
于是，Threading模块为我们提供了一个类，Threading.Lock，锁。我们创建一个该类对象，在线程函数执行前，“抢占”该锁，执行完成后，“释放”该锁，则我们确保了每次只有一个线程占有该锁。这时候对一个公共的对象进行操作，则不会发生线程不安全的现象了。
于是，我们把代码更改如下：
 
 

  
  

   
   

    
    
class tt1(threading.Thread):
    def run(self):
        for i  in range(1,11):
            if i==3:
                condition.acquire()
                condition.wait()
                condition.release()
            print(i)
            time.sleep(1)
class tt2(threading.Thread):
    def run(self):
        for i  in range(30,19,-1):
            if i==25:
                condition.acquire()
                condition.notify()
                condition.release
            print(i)
            time.sleep(1)
lock=threading.Lock()
condition=threading.Condition(lock=lock)
tt1().start()
tt2().start()