import threading
import time

########直接创建线程的方式##############
def music(num): # 子线程的任务
    print(‘您现在听到的音乐数目为:%s‘%(num),time.ctime())
    time.sleep(5)

if __name__ == ‘__main__‘:
    t1 = threading.Thread(target=music,args=(100,)) #定义一个线程实例对象（此时没有任何现象产生）
    t1.start() # 启动的这一时刻才产生出了子线程（创建的那句任然是主线程的）

    print(‘你输入的密码有误，请重新输入‘,time.ctime()) # 主线程的代码

#####################用面向对象的方式来创建线程#################
####继承的方式创建进程

# import threading
# import time
# class MyThread(threading.Thread):
#     def __init__(self,name,num):
#         threading.Thread.__init__(self)
#         self.name = name
#         self.num = num
#     def run(self):
#         print(‘ s% running on number :%s‘%(self.name,self.num),time.ctime())
#         time.sleep(3)
#
# if __name__ == ‘__main__‘:
#     t1 = MyThread(‘alex‘,12)
#     t2 = MyThread(‘egon‘,23)
#     t1.start()
#     t2.start()
#     print(‘ending.......‘,time.ctime())

#coding:utf8
from threading import Thread
import time

def counter():
    i = 0
    for _ in range(100000000):
        i = i + 1
    return True


def main():
    l=[]
    start_time = time.time()
    for i in range(2):

        t = Thread(target=counter)
        t.start()
        l.append(t)
        t.join()

    for t in l:
        t.join()
    # counter()
    # counter()
    end_time = time.time()
    print("Total time: {}".format(end_time - start_time))

if __name__ == ‘__main__‘:
    main()


‘‘‘
py2.7:
     串行:9.17599987984s
     并发:9.26799988747s
py3.6:
     串行:9.540389776229858s
     并发:9.568442583084106s

‘‘‘

计算密集型，多线程并发相比串行，没有显著优势

#coding:utf8
from multiprocessing import Process
import time

def counter():
    i = 0
    for _ in range(100000000):
        i = i + 1

    return True

def main():

    l=[]
    start_time = time.time()

    # for _ in range(2):
    #     t=Process(target=counter)
    #     t.start()
    #     l.append(t)
    #     #t.join()
    #
    # for t in l:
    #    t.join()
    counter()
    counter()
    end_time = time.time()
    print("Total time: {}".format(end_time - start_time))

if __name__ == ‘__main__‘:
    main()


‘‘‘

py2.7:
     串行:8.92299985886 s
     并行:8.19099998474 s

py3.6:
     串行:9.963459014892578 s
     并发:5.1366541385650635 s

‘‘‘

multiprocess多进程实现并发运算能够提升效率

import threading
import time

# mutexA = threading.Lock()
# mutexB = threading.Lock()
rlock = threading.RLock()

class MyThread(threading.Thread):

    def __init__(self):
        threading.Thread.__init__(self)

    def run(self):
        self.fun1()
        self.fun2()

    def fun1(self):
        rlock.acquire()  # 如果锁被占用,则阻塞在这里,等待锁的释放

        print("I am %s , get res: %s---%s" %(self.name, "ResA",time.time()))

        rlock.acquire()
        print("I am %s , get res: %s---%s" %(self.name, "ResB",time.time()))
        rlock.release()

        rlock.release()


    def fun2(self):
        rlock.acquire()
        print("I am %s , get res: %s---%s" %(self.name, "ResB",time.time()))
        time.sleep(0.2)

        rlock.acquire()
        print("I am %s , get res: %s---%s" %(self.name, "ResA",time.time()))
        rlock.release()

        rlock.release()

if __name__ == "__main__":

    print("start---------------------------%s"%time.time())

    for i in range(0, 10):
        my_thread = MyThread()
        my_thread.start()


#运行结果：从以下结果也可以发现，线程之间是竞争关系
"""
start---------------------------1494316940.0863945
I am Thread-1 , get res: ResA---1494316940.0873976
I am Thread-1 , get res: ResB---1494316940.0873976
I am Thread-1 , get res: ResB---1494316940.0873976
I am Thread-1 , get res: ResA---1494316940.287911
I am Thread-2 , get res: ResA---1494316940.287911
I am Thread-2 , get res: ResB---1494316940.287911
I am Thread-2 , get res: ResB---1494316940.287911
I am Thread-2 , get res: ResA---1494316940.4883447
I am Thread-4 , get res: ResA---1494316940.4883447
I am Thread-4 , get res: ResB---1494316940.4883447
I am Thread-4 , get res: ResB---1494316940.4883447
I am Thread-4 , get res: ResA---1494316940.6886203
I am Thread-6 , get res: ResA---1494316940.6886203
I am Thread-6 , get res: ResB---1494316940.6896234
I am Thread-6 , get res: ResB---1494316940.6896234
I am Thread-6 , get res: ResA---1494316940.890659
I am Thread-8 , get res: ResA---1494316940.890659
I am Thread-8 , get res: ResB---1494316940.890659
I am Thread-8 , get res: ResB---1494316940.890659
I am Thread-8 , get res: ResA---1494316941.0918815
I am Thread-10 , get res: ResA---1494316941.0918815
I am Thread-10 , get res: ResB---1494316941.0918815
I am Thread-10 , get res: ResB---1494316941.0918815
I am Thread-10 , get res: ResA---1494316941.2923715
I am Thread-5 , get res: ResA---1494316941.2923715
I am Thread-5 , get res: ResB---1494316941.2923715
I am Thread-5 , get res: ResB---1494316941.2923715
I am Thread-5 , get res: ResA---1494316941.493138
I am Thread-9 , get res: ResA---1494316941.493138
I am Thread-9 , get res: ResB---1494316941.493138
I am Thread-9 , get res: ResB---1494316941.493138
I am Thread-9 , get res: ResA---1494316941.6937861
I am Thread-7 , get res: ResA---1494316941.6937861
I am Thread-7 , get res: ResB---1494316941.6937861
I am Thread-7 , get res: ResB---1494316941.6937861
I am Thread-7 , get res: ResA---1494316941.8946414
I am Thread-3 , get res: ResA---1494316941.8946414
I am Thread-3 , get res: ResB---1494316941.8946414
I am Thread-3 , get res: ResB---1494316941.8946414
I am Thread-3 , get res: ResA---1494316942.0956843
"""

递归锁解决死锁

################event同步对象#############


import threading,time
class Boss(threading.Thread):

    def run(self):
        print("BOSS：今晚大家都要加班到22:00。")
        print(event.isSet())#执行结果为： False
        event.set()
        time.sleep(5)
        print("BOSS：<22:00>可以下班了。")
        print(event.isSet())
        event.set()  # 此方法就是在 设定 类似于（标志位）的东西。

class Worker(threading.Thread):
    def run(self):

        event.wait()#（在boss类中有一个set设定后就不等待了） 是等待的意思，是在等待类似于(标志位)的东西，一旦这个东西被设定了就不会再等待了
                    #        一旦event被设定，等同于pass；反之若没有被设定就相当于一个阻塞的状态；

        print("Worker：哎……命苦啊！")
        time.sleep(1)
        event.clear()  # 用来清除 此标志位
        event.wait()  # 此时清空的标志位 ，没有设定了，此时又在等待
        print("Worker：OhYeah!")


if __name__=="__main__":
    event=threading.Event() # 先创建一个event 同步对象


    threads=[]
    for i in range(5):
        threads.append(Worker()) # 将五个Worker类的实例对象添加到列表threads中去
    threads.append(Boss()) # 创建了一个老板对象
    for t in threads:
        t.start()
    for t in threads:
        t.join()
################5个工人对象加一个老板对象再加一个主线程对象，这七个线程一起进行运行#########
    print("ending.....")

#通过进程队列来实现进程之间的通信###########
# from multiprocessing import Process,Queue
# import queue
#
# def f(q,n):
#     q.put(n*(n+1))
#     print(‘son process is‘,id(q))
#
#
#
# if __name__ == ‘__main__‘:
#     q = Queue() #创建了一个进程队列
#     print(‘main process is‘,id(q))
#     for i in range(3):
#         p = Process(target=f,args=(q,i))# 讲三个进程对象和进程队列传递到子进程中去
#         p.start()
#     print(q.get())
#     print(q.get())
#     print(q.get())


#########################通过双向管道的形式进行通信####################

from multiprocessing import Process, Pipe


def f(conn):
    conn.send([12, {"name":"yuan"}, ‘hello‘])
    response=conn.recv()
    print("response",response)
    conn.close()
    print("q_ID2:",id(conn))


if __name__ == ‘__main__‘:

    parent_conn, child_conn = Pipe() #双向管道 （既可以发送消息、也可以接受消息）

    print("q_ID1:",id(child_conn))
    p = Process(target=f, args=(child_conn,)) # 创建子进程 对象将 子进程的管道也传输给子进程实现子进程与主进程之间的通信
    p.start()

    print(parent_conn.recv())   # prints "[42, None, ‘hello‘]"
    parent_conn.send("儿子你好!")


###########################通过 manager 实现通信及数据共享#############

from multiprocessing import Process, Manager

def f(d, l,n):

    d[n] = ‘1‘    #{0:"1"}
    d[‘2‘] = 2    #{0:"1","2":2}

    l.append(n)    #[0,1,2,3,4,   0,1,2,3,4,5,6,7,8,9]
    #print(l)


if __name__ == ‘__main__‘:

    with Manager() as manager: # 创建了一个manager 的对象

        d = manager.dict()#{} #通过自己的方式创建一个manager类型的字典

        l = manager.list(range(5))#[0,1,2,3,4]


        p_list = []

        for i in range(10):
            p = Process(target=f, args=(d,l,i))
            p.start()
            p_list.append(p)

        for res in p_list:
            res.join()

        print(d)
        print(l)

############# 进程池##############

from multiprocessing import Pool
import time

def foo(args):
    time.sleep(1)
    print(args,time.ctime())



if __name__ == ‘__main__‘:
    p = Pool(5) # 池中限定的最大进程数
    for i in range(30):
        p.apply_async(func = foo,args=(i,)) # 从池子中去取一个异步进程并执行

    p.close() # 等待子进程执行完毕后关闭线程池
    p.join()

##############################################进程池例子2################
from  multiprocessing import Process,Pool
import time,os

def Foo(i):

    time.sleep(1)
    print(i)
    print("son",os.getpid())

    return "HELLO %s"%i


def Bar(arg): # 主进程的函数（主进程的任务）
    print(arg)
    print("hello")
    print("Bar:",os.getpid())

if __name__ == ‘__main__‘:

    pool = Pool(5) # 进程池中最多有5个进程
    print("main pid",os.getpid())
    for i in range(100):
        # pool.apply(func=Foo, args=(i,))  #同步接口
        #pool.apply_async(func=Foo, args=(i,))

        #回调函数：  就是某个动作或者函数执行成功后再去执行的函数

        pool.apply_async(func=Foo, args=(i,),callback=Bar) #Bar 就是回调函数

    pool.close()
    pool.join()         # join与close调用顺序是固定的

    print(‘end‘)