python 多线程

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

共享数据容易，方便通信，线程不安全。

线程的状态：
     1.新建状态(New)： 
        当用new操作符创建一个线程时， 例如new Thread(r)，线程还没有
        开始运行，此时线程处在新建状态。 当一个线程处于新生状态时，
        程序还没有开始运行线程中的代码
     2.就绪状态(Runnable)
        一个新创建的线程并不自动开始运行，要执行线程，必须调用线程的
        start()方法。当线程对象调用start()方法即启动了线程，start()方
        法创建线程运行的系统资源，并调度线程运行run()方法。当start()方
        法返回后，线程就处于就绪状态。
        处于就绪状态的线程并不一定立即运行run()方法，线程还必须同其他线
        程竞争CPU时间，只有获得CPU时间才可以运行线程。因为在单CPU的计算
        机系统中，不可能同时运行多个线程，一个时刻仅有一个线程处于运行状
        态。因此此时可能有多个线程处于就绪状态。对多个处于就绪状态的线程
        是由Java运行时系统的线程调度程序(thread scheduler)来调度的。
    3.运行状态(Running)
        当线程获得CPU时间后，它才进入运行状态，真正开始执行run()方法.
    4. 阻塞状态(Blocked)
        线程运行过程中，可能由于各种原因进入阻塞状态:
        1>线程通过调用sleep方法进入睡眠状态；
        2>线程调用一个在I/O上被阻塞的操作，即该操作在输入输出操作完成之前不会返回到它的调用者；
        3>线程试图得到一个锁，而该锁正被其他线程持有；
        4>线程在等待某个触发条件；
        ......           
        所谓阻塞状态是正在运行的线程没有运行结束，暂时让出CPU，这时其
        他处于就绪状态的线程就可以获得CPU时间，进入运行状态。
    5. 死亡状态(Dead)
        有两个原因会导致线程死亡：
        1) run方法正常退出而自然死亡，
        2) 一个未捕获的异常终止了run方法而使线程猝死。
        为了确定线程在当前是否存活着（就是要么是可运行的，
        要么是被阻塞了），需要使用isAlive方法。如果是可运行或被阻塞，
        这个方法返回true； 如果线程仍旧是new状态且不是可运行的， 或者线
        程死亡了，则返回false.

# 函数方法实现线程
import threading
import time
def test():
    for i in range(11):
        print(i)
        time.sleep(1)  # 睡眠时间  秒
print("------aaa------")
threading._start_new_thread(test,())  #定义多线程同时进行
for i in range(20,10,-1):
    print(i)
    time.sleep(1)
input()  #用输入来结束循环

#用类方法来实现线程
import threading
import time
class MyThread(threading.Thread):
    def __init__(self,name=Name):
        threading.Thread.__init__(self)

        self.name = name  #  添加线程名
        print("MyThread...")
    def run(self):
        for i in range(11):
            print（"%s\t%d"%(self.name,i)）
            time.sleep(1)
    def start(self):  #重新定义start方法
        print("start...")
        super().start() #调用父类的start方法
t = MyThread("mythread1")
t.start()

print(t.getNname())  #fan
print(threading.current_thread())  #得到当前线程变量
list = threading.enumerate() #返回一个在运行的线程，启动后，结束前。不包括启动前和结束后
print(list)
for i in range(10,21,1):
    print(i)

    t.join()   #用join方法插入  提前运行插入，插入结束后才运行被插入
    time.sleep(1)

由于并发的问题，需要加锁：
锁当然有锁定和未锁定两种状态，当一个线程要访问共享数据时，必须要先获得
锁定，如果已经有别的线程获得锁定，那么久进入暂停状态，等别的线程把锁释
放后，再进行操作

Condition:更精准的控制锁，提供四个方法，上锁(acquire()),等待(wait()),
解锁(release()),唤醒(notify(),notify_all())
lock = threading.lock()
threading.Condition(lock=lock)

给线程加锁：

import threading
import time
class MyThread(threading.Thread):
    def __init__(self,name=None):
        threading.Thread.__init__(self)
        self.name = name
        print("MyThread...")
    def run(self):
        for i in range(11):
            if i == 3:
                cond.acquire()
                cond.wait()
                cond.release()
            print("%s\t%d"%(self.name,i))
            time.sleep(1)
    def start(self):
        print("start...")
        super().start() #调用父类的start方法
class Thread2(threading.Thread):
    def run(self):
        for i in range(20,10,-1):
            print(i)
            time.sleep(1)
        cond.acquire()
        cond.notify()
        cond.release()
lock = threading.Lock() #定义锁
cond = threading.Condition(lock=lock)
t1 = MyThread("nood1")
t2 = Thread2()
t1.start()
t2.start()
print(t1.getName())