談談對線程與進程的理解

概念：

線程

線程（threading)是操作系統能夠進行運算調度的最小單位。它被包含在進程之中，是進程中的實際運作單位。一條線程指的是進程中一個單一順序的控制流，一個進程中可以並發多個線程，每條線程並行執行不同的任務。

進程

進程（Process）是計算機中的程序關於某數據集合上的一次運行活動，是系統進行資源分配和調度的基本單位，是操作系統結構的基礎。在早期面向進程設計的計算機結構中，進程是程序的基本執行實體；在當代面向線程設計的計算機結構中，進程是線程的容器。程序是指令、數據及其組織形式的描述，進程是程序的實體。

進程與線程區別

a.地址空間和其它資源：進程間相互獨立，同一進程的各線程間共享。某進程內的線程在其它進程不可見。

b.通信：進程間通信IPC，線程間可以直接讀寫進程數據段（如全局變量）來進行通信——需要進程同步和互斥手段的輔助，以保證數據的一致性。

c.調度和切換：線程上下文切換比進程上下文切換要快得多。

d.在多線程OS中，進程不是一個可執行的實體。

 

threading模塊

直接調用

import threading
import time

def tell(num): #定義每個線程要運行的函數

    print(num)
    time.sleep(3)

if __name__ == '__main__':
    t1 = threading.Thread(target=tell,args=(1,)) #生成一個線程實例
    t2 = threading.Thread(target=tell,args=(2,)) #生成另一個線程實例
    t1.start() #啟動線程
    t2.start() #啟動另一個線程
    print(t1.getName()) #獲取線程名
    print(t2.getName())

繼承調用

__author__ = 'thinkpad'
# !/usr/bin/env python
#-*- coding:utf-8 -*-

import threading
import time

class MyThread(threading.Thread):

    def __init__(self,num):
        threading.Thread.__init__(self)
        self.num = num
    def run(self):#定義每個線程要運行的函數
        print(self.num)
        time.sleep(3)

if __name__ == '__main__':
    t1 = MyThread(1)
    t2 = MyThread(2)
    t1.start()
    t2.start()
    print(t1.getName())
    print(t2.getName())

 互拆鎖

__author__ = 'thinkpad'
# !/usr/bin/env python
#-*- coding:utf-8 -*-
import threading
import time

def addNum():
    global num #在每個線程中都獲取這個全局變量
    print('--get num:',num )
    time.sleep(1)
    lock.acquire() #修改數據前加鎖
    num  -=1 #對此公共變量進行-1操作
    lock.release() #修改后釋放
num = 100  #設定一個共享變量
thread_list = []

lock = threading.Lock() #生成全局鎖
for i in range(100):
    t = threading.Thread(target=addNum)
    t.start()
    thread_list.append(t)

for t in thread_list: #等待所有線程執行完畢
    t.join()
print('final num:', num )

 

多進程Mutiprocessing

from multiprocessing import Process
import time
def f(name):
    time.sleep(2)
    print('hello', name)

if __name__ == '__main__':
    for i in range(4):
        p = Process(target=f, args=('bob',))
        p.start()
        p.join()

from multiprocessing import Process
import os

def info(title):
    print(title)
    print('module name:', __name__)
    print('parent process:', os.getppid())
    print('process id:', os.getpid())
    print("\n\n")

def f(name):
    info('\033[31;1mfunction f\033[0m')
    print('hello', name)

if __name__ == '__main__':
    info('\033[32;1mmain process line\033[0m')
    p = Process(target=f, args=('bob',))
    p.start()
    p.join()

 

 進程間通訊

queues

from multiprocessing import Process, Queue
 
def f(q):
    q.put([42, None, 'hello'])
 
if __name__ == '__main__':
    q = Queue()
    p = Process(target=f, args=(q,))
    p.start()
    print(q.get())    # prints "[42, None, 'hello']"
    p.join()

Pipes

from multiprocessing import Process, Pipe

def f(conn):
    conn.send([42, None, 'hello'])
    conn.close()
 
if __name__ == '__main__':
    parent_conn, child_conn = Pipe()
    p = Process(target=f, args=(child_conn,))
    p.start()
    print(parent_conn.recv())   # prints "[42, None, 'hello']"
    p.join()

Mangager

from multiprocessing import Process, Manager

def f(d, l):
    d[1] = '1'
    d[2] = '2'
    d[0.25] = None
    l.append(1)
    print(l)

if __name__ == '__main__':
    with Manager() as manager:
        d = manager.dict()

        l = manager.list(range(5))
        p_list = []
        for i in range(10):
            p = Process(target=f, args=(d, l))
            p.start()
            p_list.append(p)
        for res in p_list:
            res.join()

        print(d)
        print(l)

進程同步

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()

進程池

from  multiprocessing import Process,Pool
import time

def Foo(i):
    time.sleep(2)
    return i+100

def Bar(arg):
    print('-->exec done:',arg)

pool = Pool(5)

for i in range(10):
    pool.apply_async(func=Foo, args=(i,),callback=Bar)
    #pool.apply(func=Foo, args=(i,))

print('end')
pool.close()
pool.join()#進程池中進程執行完畢后再關閉，如果注釋，那么程序直接關閉。