python3.6_多線程和多進程

1.多線程

#多線程實例
from time import sleep,ctime
import threading

#多個函數
def talk(content,loop):
    for x in range(loop):
        print('Start talk:%s  %s' %(content,ctime()))
        sleep(3)

def write(content,loop):
    for x in range(loop):
        print('Start write:%s  %s' %(content,ctime()))
        sleep(5)

#定義多個線程
threads=[]
t1=threading.Thread(target=talk,args=('線程1開始',2))
threads.append(t1)

t2=threading.Thread(target=write,args=('線程2開始',2))
threads.append(t2)

#運行線程 
if __name__=='__main__':
    for x in threads:
        x.start()
    for x in threads:
        x.join() #線程守護，保證每個線程都運行完成

    print('over %s' %ctime())

2.多線程鎖

Python中有兩種鎖，一個鎖是原始的鎖（原語）， 不可重入，而另一種鎖則是可重入的鎖即遞歸鎖。而是thread模塊中，只提供了不可重入的鎖，而在threading中則提供這兩種鎖。

可重入：當一個線程擁有一個鎖的使用權后，再次獲取鎖的使用權時，不會阻塞，會立馬得到使用權，則原始鎖的話，則不行，會阻塞。

方法一、thread不可重入鎖

import thread

import time

 

lock = thread.allocate_lock()

 

def Count(id):

    global num;

 

    while True:

        lock.acquire()

        if num <= 10:

            print "Thread id is : %s     The num is %s\n" % (id, str(num))

            num = num + 1

        else:

            break

        lock.release()

    else:

        thread.exit_thread()

 

if __name__ == "__main__":

    num = 1

    thread.start_new_thread(Count, ('A',))

    thread.start_new_thread(Count, ('B',))

 

    time.sleep(5)

方法二、theading的Lock(不可重入鎖)

import threading

import time

 

lock = threading.Lock()

 

def Count(id):

    global num;

 

    while True:

        lock.acquire()

        if num <= 10:

 

            print "Thread id is : %s     The num is %s\n" % (id, str(num))

            num = num + 1

        else:

            break

        lock.release()

 

if __name__ == "__main__":

    num = 1

    t1 = threading.Thread(target=Count, args=('A', ))

    t2 = threading.Thread(target=Count, args=('B', ))

 

    t1.start()

    t2.start()

 

    time.sleep(5)

方法三：threading的RLock(可重入)

import threading

import time

 

lock = threading.RLock()

 

def CountNum(id):

    global num

     

    lock.acquire()

     

    if num <= 10:

        print "Thread id is : %s     The num is %s\n" % (id, str(num))

        num = num + 1

        CountNum(id)

 

    lock.release()

 

if __name__ == "__main__":

    num = 1

    t1 = threading.Thread(target=CountNum, args=('A'))

 

    t1.start()

 

    time.sleep(5)

3、多進程實例

#多進程實例
from time import sleep,ctime
from multiprocessing import Process

#多個函數
def talk(content,loop):
    for x in range(loop):
        print('Start talk:%s  %s' %(content,ctime()))
        sleep(2)

def write(content,loop):
    for x in range(loop):
        print('Start write:%s  %s' %(content,ctime()))
        sleep(3)

#定義多個線程
processes=[]
p1=Process(target=talk,args=('進程1開始',2))
processes.append(p1)

p2=Process(target=write,args=('進程2開始',2))
processes.append(p2)

#運行線程 
if __name__=='__main__':
    for x in processes:
        x.start()
    for x in processes:
        x.join() #線程守護，保證每個線程都運行完成

    print('over %s' %ctime())

4.多進程鎖

from multiprocessing import Process,Lock
# 線程的鎖是為了防止共享數據產生錯誤，從而加鎖保重每次操作數據只有一個線程
# 進程的鎖是為了在共享屏幕時不會出錯，比如打印時不會打亂了

def f(l,i):
    l.acquire()
    try:
        print('hello world',i)
    finally:
        l.release()

if __name__ == '__main__':
    lock = Lock()
    for num in range(10):
        Process(target=f,args=(lock,num)).start()