一丶進程

　　1.什麽是進程

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

　　狹義定義:進程是正在運行的程序的實例.

　　廣義定義:進程是一個具有一定獨立功能的程序關於某個數據集合的一次運行活動 .它是操作系統動態執行的基本單元,在傳統的操作系統中,進程既是基本的分配單元,也是基本的執行單元.

　　2.進程和線程的區別:

　　　　1.進程是CPU資源分配的最小單元........線程是CPU計算的最小單元

　　　　2.一個進程中可以有多個線程

　　　　3.對於Python來說它的進程和線程和其他語言有差異,是有GIL鎖,GIL鎖保證一個進程中同一時刻只有一個線程被CPU調度

　　3.通過繼承方式創建進程

import multiprocessing
class MyProcess(multiprocessing.Process):

    def run(self):
        print(‘當前進程‘,multiprocessing.current_process())

def run():
    p1 = MyProcess()
    p1.start()

    p2 
 
= MyProcess()
    p2.start()

if __name__ == ‘__main__‘:
    run()
# 當前進程 <MyProcess(MyProcess-1, started)>
# 當前進程 <MyProcess(MyProcess-2, started)>

　　4.使用process模塊創建進程

import time
from multiprocessing import Process

def f(name):
    print(‘hello‘, name)
    
 
print(‘我是子進程‘)

if __name__ == ‘__main__‘:
    p = Process(target=f, args=(‘bob‘,))
    p.start()
    time.sleep(1)
    print(‘執行主進程的內容了‘)

import time
from multiprocessing import Process

def f(name):
    print(‘hello‘, name)
    time.sleep(1)
    print(‘我是子進程‘)


if __name__ == ‘__main__‘:
    p = Process(target=f, args=(‘bob‘,))
    p.start()
    #p.join()
    print(‘我是父進程‘)

import os
from multiprocessing import Process

def f(x):
    print(‘子進程id ：‘,os.getpid(),‘父進程id ：‘,os.getppid())
    return x*x

if __name__ == ‘__main__‘:
    print(‘主進程id ：‘, os.getpid())
    p_lst = []
    for i in range(5):
        p = Process(target=f, args=(i,))
        p.start()

　　5.進程的常用功能

import time
def task(arg):
    time.sleep(2)
    print(arg)


def run():
    print(‘111111111‘)
    p1 = multiprocessing.Process(target=task,args=(1,))
    p = p1.name = ‘pp1‘
    print(p)
    p1.start()
    print(‘222222222‘)

    p2 = multiprocessing.Process(target=task, args=(2,))
    p2.name = ‘pp2‘
    p2.start()
    print(‘333333333‘)

if __name__ == ‘__main__‘:
    run()
# 111111111
# pp1
# 222222222
# 333333333
# 2
# 1

二丶數據共享

　　1.進程間的數據不共享

import multiprocessing
data_list = []
def task(arg):
    data_list.append(arg)
    print(data_list)
def run():
    for i in range(10):
        p = multiprocessing.Process(target=task,args=(i,))
        p.start()

if __name__ == ‘__main__‘:
    run()

　　2.進程間的數據共享multiprocessing.Queue

import multiprocessing
q = multiprocessing.Queue()

def task(arg,q):
    q.put(arg)

def run():
    for i in range(10):
        p = multiprocessing.Process(target=task, args=(i, q,))
        p.start()

    while True:
        v = q.get()
        print(v)

run()

import multiprocessing
def task(arg,q):
    q.put(arg)

if __name__ == ‘__main__‘:
    q = multiprocessing.Queue()
    for i in range(10):
        p = multiprocessing.Process(target=task,args=(i,q,))
        p.start()
    while True:
        v = q.get()
        print(v)

　　3.進程間的數據共享Manager

import multiprocessing
m = multiprocessing.Manager()
dic = m.dict()

def task(arg):
    dic[arg] = 100

def run():
    for i in range(10):
        p = multiprocessing.Process(target=task, args=(i,))
        p.start()

    input(‘>>>‘)
    print(dic.values())

if __name__ == ‘__main__‘:

    run()

import multiprocessing
import time
def task(arg,dic):
    time.sleep(2)
    dic[arg] = 100

if __name__ == ‘__main__‘:
    m = multiprocessing.Manager()
    dic = m.dict()

    process_list = []
    for i in range(10):
        p = multiprocessing.Process(target=task, args=(i,dic,))
        p.start()

        process_list.append(p)

    while True:
        count = 0
        for p in process_list:
            if not p.is_alive():
                count += 1
        if count == len(process_list):
            break
    print(dic)
#{1: 100, 0: 100, 2: 100, 3: 100, 4: 100, 5: 100, 6: 100, 7: 100, 8: 100, 9: 100}

三丶進程鎖

　　線程既然有線程鎖,進程肯定也有進程鎖,兩種鎖完全一樣

import time
import multiprocessing

lock = multiprocessing.RLock()

def task(arg):
    print(‘鬼子來了‘)
    lock.acquire()
    time.sleep(4)
    print(arg)
    lock.release()

if __name__ == ‘__main__‘:
    p1 = multiprocessing.Process(target=task,args=(1,))
    p1.start()

    p2 = multiprocessing.Process(target=task, args=(2,))
    p2.start()

四丶進程池

from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor
import os,time
def task(n):
    time.sleep(1)
    print(‘[%s] is running‘%os.getpid())
if __name__ == ‘__main__‘:
    p = ProcessPoolExecutor(3)
    for i in range(10):
        obj = p.submit(task,i).result()
    p.shutdown()  #相當於close和join方法

五丶初識爬蟲

import requests
from bs4 import BeautifulSoup
from concurrent.futures import ThreadPoolExecutor,ProcessPoolExecutor


# 模擬瀏覽器發送請求
# 內部創建 sk = socket.socket()
# 和抽屜進行socket連接 sk.connect(...)
# sk.sendall(‘...‘)
# sk.recv(...)

def task(url):
    print(url)
    r1 = requests.get(
        url=url,
        headers={
            ‘User-Agent‘:‘Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.92 Safari/537.36‘
        }
    )

    # 查看下載下來的文本信息
    soup = BeautifulSoup(r1.text,‘html.parser‘)
    print(soup.text)

    content_list = soup.find(‘div‘,attrs={‘id‘:‘content-list‘})
    for item in content_list.find_all(‘div‘,attrs={‘class‘:‘item‘}):
        title = item.find(‘a‘).text.strip()
        target_url = item.find(‘a‘).get(‘href‘)
        print(title,target_url)

def run():
    pool = ThreadPoolExecutor(5)
    for i in range(1,50):
        pool.submit(task,‘https://dig.chouti.com/all/hot/recent/%s‘ %i)

if __name__ == ‘__main__‘:
    run()

進程丶數據共享丶鎖丶進程池丶模塊(爬蟲)