import copy

def Memento(obj, deep=False):

  # 對你要做快照的對象做快照
  state = (copy.copy if deep else copy.deepcopy)(obj.__dict__)
  def Restore():
    obj.__dict__ = state
  return Restore

class Transaction:

  deep = False
  def __init__(self, *targets):
    self.targets = targets
    self.Commit()
  # 模擬事務(wù)提交，其實就是初始化給每個對象往self.targets賦值
  def Commit(self):
    self.states = [Memento(target, self.deep) for target in self.targets]
  # 回滾其實就是調(diào)用Memento函數(shù)，執(zhí)行其中的閉包，將__dict__恢復(fù)
  def Rollback(self):
    for state in self.states:
      state()

# 裝飾器的方式給方法添加這個事務(wù)的功能
def transactional(method):
  # 這里的self其實就是要保存的那個對象，和類的實例無關(guān)
  def wrappedMethod(self, *args, **kwargs):
    state = Memento(self)
    try:
      return method(self, *args, **kwargs)
    except:
      # 和上面的回滾一樣，異常就恢復(fù)
      state()
      raise
  return wrappedMethod

class NumObj(object):
  def __init__(self, value):
    self.value = value
  def __repr__(self):
    return '<%s: %r>' % (self.__class__.__name__, self.value)
  def Increment(self):
    self.value += 1

  @transactional
  def DoStuff(self):
    # 賦值成字符串，再自增長肯定會報錯的
    self.value = '1111'
    self.Increment()

if __name__ == '__main__':

  n = NumObj(-1)
  print n
  t = Transaction(n)
  try:
    for i in range(3):
      n.Increment()
      print n
    # 這里事務(wù)提交會保存狀態(tài)從第一次的-1到2
    t.Commit()
    print '-- commited'
    for i in range(3):
      n.Increment()
      print n
    n.value += 'x' # will fail
    print n
  except:
    # 回滾只會回顧到上一次comit成功的2 而不是-1
    t.Rollback()
    print '-- rolled back'
  print n
  print '-- now doing stuff ...'
  try:
    n.DoStuff()
  except:
    print '-> doing stuff failed!'
    import traceback
    traceback.print_exc(0)
    pass
  # 第二次的異常回滾n還是2, 整個過程都是修改NumObj的實例對象
  print n

import Queue
import types
import threading
from contextlib import contextmanager

class ObjectPool(object):

  def __init__(self, fn_cls, *args, **kwargs):
    super(ObjectPool, self).__init__()
    self.fn_cls = fn_cls
    self._myinit(*args, **kwargs)

  def _myinit(self, *args, **kwargs):
    self.args = args
    self.maxSize = int(kwargs.get("maxSize",1))
    self.queue = Queue.Queue()
  def _get_obj(self):
    # 因為傳進來的可能是函數(shù)，還可能是類
    if type(self.fn_cls) == types.FunctionType:
      return self.fn_cls(self.args)
    # 判斷是經(jīng)典或者新類
    elif type(self.fn_cls) == types.ClassType or type(self.fn_cls) == types.TypeType:
      return apply(self.fn_cls, self.args)
    else:
      raise "Wrong type"

  def borrow_obj(self):
    # 這個print 沒用，只是在你執(zhí)行的時候告訴你目前的隊列數(shù)，讓你發(fā)現(xiàn)對象池的作用
    print self.queue._qsize()
    # 要是對象池大小還沒有超過設(shè)置的最大數(shù)，可以繼續(xù)放進去新對象
    if self.queue.qsize()<self.maxSize and self.queue.empty():
      self.queue.put(self._get_obj())
    # 都會返回一個對象給相關(guān)去用
    return self.queue.get() 
  # 回收
  def recover_obj(self,obj):
    self.queue.put(obj)

# 測試用函數(shù)和類
def echo_func(num):
  return num

class echo_cls(object):
  pass

# 不用構(gòu)造含有__enter__, __exit__的類就可以使用with，當(dāng)然你可以直接把代碼放到函數(shù)去用
@contextmanager
def poolobj(pool):
  obj = pool.borrow_obj()
  try:
    yield obj
  except Exception, e:
    yield None
  finally:
    pool.recover_obj(obj)

obj = ObjectPool(echo_func, 23, maxSize=4)
obj2 = ObjectPool(echo_cls, maxSize=4)

class MyThread(threading.Thread):

  def run(self):
    # 為了實現(xiàn)效果，我搞了個簡單的多線程，2個with放在一個地方了，只為測試用
    with poolobj(obj) as t:
      print t
    with poolobj(obj2) as t:
      print t

if __name__ == '__main__':
  threads = []
  for i in range(200):
    t = MyThread()
    t.start()
    threads.append(t)
  for t in threads:
    t.join(True)