Многозадачност и сериализация

„ Програмиране с Python“, ФМИ

ДимиНитър Стефколай анБаКънчев Дийимитровски

26.05.2008

Многозадачност

Всички искат да са като Наполеон — да правят поне две неща едновременно Операционните системи ни дават два подхода:

• Създаване на нови процеси (с fork)
• Няколко нишки в един и същи процес

import os
import time

def log(msg): print "\n* %s" % msg

orders = 0
while True:
    order = raw_input('Enter order: ')
    if not order: continue
    if order in ('q', 'x', 'quit', 'exit'): break
    pid = os.fork()
    if 0 == pid:
        time.sleep(3)
        log("Order '%s' is ready!" % order)
        break
    else:
        log("Roger that '%s'(%d). Please, wait in quiet desperation." % (order, orders))
        orders += 1

Предимства и недостатъци на fork

Против:

• Създаването на нов процес е бавно и паметоемко
• Комуникацията между процеси е трудна — нямат обща памет

За:

• Стабилност
• Дъщерният процес е независим — ако омаже нещо, родителят няма да пострада

Нишки

• Наричат ги lightweight процеси
• Много нишки живеят в един и същи процес
• Глобалните променливи са общи за нишките
• Създават се бързо и лесно

Нишки в python

• thread — процедурен модул, стар, неудобен
• threading — ОО, нов, удобен, weapon of choice

Създаване на нова нишка

• Нишка — наследник на threading.Thread
• Код — в метода run
• Създаване и изпълнение на кода паралелно — метод start

import threading
import time

orders = 0

class Chef(threading.Thread):
    def __init__(self, order):
        self.order = order
        threading.Thread.__init__(self)
    def run(self):
        time.sleep(3)
        log("Order '%s' is ready!" % self.order)

while True:
    order = raw_input('Enter order: ')
    if not order: continue
    if order in ('q', 'x', 'quit', 'exit'): break
    chef = Chef(order)
    chef.start()
    log("Roger that '%s'. Please, wait in quiet desperation." % order)
    orders += 1

import random
import time
import threading

taken = False

class Philosopher(threading.Thread):
    def __init__(self, name):
        super(Customer, self).__init__()
        self.name = name

    def log(self, msg): print "%s: %s" % (self.name, msg)
    def eat(self): time.sleep(random.random())
    def ponder(self): time.sleep(random.random())

    def refresh(self):
        global taken
        self.log("Please excuse me...")
        while taken: pass
        taken = True
        self.log("--> (entered the bathroom)")
        time.sleep(random.random())
        taken = False
        self.log("<-- (left the bathroom)")


    def run(self):
        while True:
            self.eat()
            self.ponder()
            self.refresh()

Критични секции

• Части от кода, които могат да бъдат изпълнени само от една нишка в даден момент се наричат критични секции
• Те са критична част от многозадачното програмиране
• Има много похвати за реализирането на критични секции.
• Всичките са равномощни на нещо, наречено семафор.

threading.Lock

• threading.Lock() ни връща Lock обект
• Викането на метода му acquire() ни гарантира, че само ние притежаваме този Lock
• Викането на release() освобождава Lock-а и разрешава някой друг да го заключи с acquire()
• Ако викнем acquire() докато Lock-а е зает — методът чака, докато не се освободи

import random
import time
import threading

bathroom = threading.Lock()

class Philosopher(threading.Thread):
    def __init__(self, name):
        super(Customer, self).__init__()
        self.name = name

    def log(self, msg): print "%s: %s" % (self.name, msg)
    def eat(self): time.sleep(random.random())
    def ponder(self): time.sleep(random.random())

    def refresh(self):
        self.log("Please excuse me...")
        bathroom.acquire()
        self.log("--> (entered the bathroom)")
        time.sleep(random.random())
        bathroom.release()
        self.log("<-- (left the bathroom)")

    def run(self):
        while True:
            self.eat()
            self.ponder()
            self.refresh()

with и обекти с acquire и release

• Всички Lock-оподбни обекти от threading са и context manager-и
• Ако ги ползваме с with ни се гарантира викането на acquire() преди и на release() след блока

with bathroom:
	self.log("--> (entered the bathroom)")
	time.sleep(random.random())
	self.log("<-- (left the bathroom)")

Модерно строителство, модерни ресторанти и семафори

• …ако има повече от една тоалетна в сградата?

Или още по-добре

• Ресторант с 10 човека
• Всеки е едновременно готвач и сервитьор
• 5 фурни

Семафори в орехова черупка

• Числова променлива v
• Операция P(v) — чакай докато v > 0, след което v -= 1
• Операция V(v) — v += 1

Предложени от Едсгер Дейкстра (Едсгар Дийкстра?)

threading.Semaphore

• threading.Semaphore(k) ни връща семафор с интерфейс като на Lock и стойност k
• При всяко изпълнение на acquire() стойността се намалява с 1
• При всяко изпълнение на release() стойността се увеличава с 1
• Ако стойността е 0, acquire() спи, докато някой не я увеличи с release()
• Lock() е еквивалентен на Semaphore(1)

import threading
import random
import time

ovens = threading.Semaphore(5)

class WaiterChef(threading.Thread):
    def __init__(self, name):
        super(WaiterChef, self).__init__()
        self.name = name

    def run(self):
        while True:
            print "...(%s) waiting for an oven" % self.name
            ovens.acquire()
            print "--> (%s) Cooking..." % self.name
            time.sleep(random.random() * 10)
            ovens.release()
            print "<-- (%s) Serving..." % self.name
            time.sleep(random.random() * 4)


for _ in range(0, 10): WaiterChef(_).start()

threading.Event

• По-проста комуникация, в която няколко нишки изчакват събитие от друга
• wait() блокира докато събитието не се случи
• set() „случва“ събитието

Коледа на село

• 2 баби, майсторки баничакрки, пекат баници за 3-мата си внука
• Искаме след като бабите опекат нещо, някой от свободните внуци да започва да яде
• Бабите се казват producer-и, внуците — consumer-и

threading.Condition

• wait() — чака, докато някоя баба не произведе нова баница
• notify() — това трявба да каже една баба, която е опекла баница. Ще събуди някой от чакащите. Ако няма чакащи няма да направи нищо.
• notifyAll() — ще събуди всички чакащи
• release() и acquire() работят върху вътрешен за Condition Lock, който може да се подаде при конструиране
• wait и notify работят само ако владеем вътрешния Lock

threading.local

• Инстанцира се чрез threading.local()
• Позволява свободен достъп до атрибути
• Всяка нишка вижда различни стойности зад атрибутите на този обект

Още един проблем

• Имаме нужда да пазим информация между две изпълнения на едно и също приложение.
• Искаме достъпа до тази информация да е лесен и да добавя минимално код в самото приложение.
• Нуждите на приложението са прости и няма да имаме нужда от конкурентен достъп или заключване на ресурси.

Решение

• Сериализация се нарича възможността да представяме обекти като поредица от байтове.
• По този начин те могат да бъдат записвани във файловата система.
• Могат и да бъдат изпращани през мрежата и реконструирани впоследствие.

Pickle

pickle е модул, който може да сериализира прости Python обекти.

• pickle.dump(object, file)

Приема отворен за писане файл file и Python обект object. Записва обекта в файла.

• pickle.load(object)

Приема отворен за четене файл и прочита един обект, който е и резултат от функцията

from __future__ import with_statement
import pickle

with open('/home/bilbo/foo.txt', 'w') as file:
	pickle.dump("The answer", file)
	pickle.dump(["spam", "eggs", "ham"], file)

with open('/home/bilbo/foo.txt', 'r') as file:
	print pickle.load(file)
	print pickle.load(file)

import pickle

serializedList = pickle.dumps(["spam", "eggs", "ham"])
print repr(serializedList)

"(lp0\nS'spam'\np1\naS'eggs'\np2\naS'ham'\np3\na."

Какво може да се сериализира?

• True, False и None
• int, long, float и complex
• str и unicode
• Списъци, речници, множества и n-орки, които съдържат само обекти, които могат да се сериализират
• Функции и класове, дефинирани в корена на модула
• Вградени функции, дефинирани в корена на модула

import pickle

primes = [2, 3, 5, 7, 11, 13]
answer = 42
things = [primes, answer, primes]
print things[0] is things[2] # True

serialized = pickle.dumps(things)
newThings = pickle.loads(serialized)
print newThings[0] is newThings[2] # True

print newThings[0] is things[0] # False

from __future__ import with_statement
import pickle

with open('/home/aquarius/foo.txt', 'w') as file:
	pickler = pickle.Pickler(file)
	pickler.dump('Under the Violet Moon')
	pickler.dump('Soldier of Fortune')
	pickler.dump('Colubrid on the Tree')

with open('/home/aquarius/foo.txt') as file:
	unpickler = pickle.Unpickler(file)
	print unpickler.load()
	print unpickler.load()
	print unpickler.load()

cPickle

cPickle e реализация на pickle на C, което я прави доста по-бърза.

import cPlickle as pickle
...

import pickle
import cPickle
from timeit import Timer

fancy = [[x ** 2 for x in range(0, 1000)], ["spam", "ham", "eggs"], 
			["-" * i for i in range(0, 1000)],]

def pickleWith(pickler):
	serialized = pickler.dumps(fancy)
	restored = pickler.loads(serialized)

print "pickle: ", Timer("pickleWith(pickle)", "from __main__ import *").timeit(50)
print "cPickle: ", Timer("pickleWith(cPickle)", "from __main__ import *").timeit(50)

# pickle:  3.28504800797
# cPickle:  0.722439050674

shelve

• shelve е сравнително прост модул, който позволява да записвате данни във файл под формата на речник.
• Можете да ги достъпвате в последствие по ключовете, с които сте ги записали.
• Всички обекти се сериализират посредством pickle.
• Организацията им във файла става посредством dbm, gdbm или berkeley db.

import shelve

db = shelve.open('/home/bilbo/foo.db')
db['name'] = 'Mityo the Python'
db['age'] = 33
db['favouriteBands'] = ["Blackmore's Night", "Deep Purple", "Rainbow"]
db['favouriteSong'] = "Colubrid on the Tree"
db.close()

db = shelve.open('/home/bilbo/foo.db')
print db.keys()
print db['name']
print db['favouriteBands']
print db['favouriteSong']
db.close()

Още въпроси?

• Страница на курса: http://fmi.py-bg.net/
• Форуми на курса: http://fmi.py-bg.net/forums/