在多线程环境下如何在对象上加锁?
import thread, time

def counter(myId, count):
    for i in range(count):
        mutex.acquire()
        #time.sleep(1)
        print '[%s] => %s' % (myId, i)
        mutex.release()

mutex = thread.allocate_lock()
for i in range(10):
    thread.start_new_thread(counter, (i,3))

time.sleep(4)
print 'Main thread exiting.'

看了下Programming Python里对这段代码的解释是：同一时间里，解释器里只有一个线程执行这段代码。
请问如何才能锁定对象的访问，比如锁定对一个字典的访问？

On 12/29/06, zhujiemao <zhujiemao在126.com> wrote:
> 在多线程环境下如何在对象上加锁?
> import thread, time
>
> def counter(myId, count):
>     for i in range(count):
>         mutex.acquire()
>         #time.sleep(1)
>         print '[%s] => %s' % (myId, i)
>         mutex.release()
>
> mutex = thread.allocate_lock()
> for i in range(10):
>     thread.start_new_thread(counter, (i,3))
>
> time.sleep(4)
> print 'Main thread exiting.'
>
> 看了下Programming Python里对这段代码的解释是：同一时间里，解释器里只有一个线程执行这段代码。
> 请问如何才能锁定对象的访问，比如锁定对一个字典的访问？

在python 中好象不能对一个对象加锁，你可以在访问对象前申请锁，在访问完对象后释放锁就行了。访问字典也是一样。

-- 
I like python!
UliPad <>: http://wiki.woodpecker.org.cn/moin/UliPad
My Blog: http://www.donews.net/limodou

也就是说如果我想锁定一个对象，那么在任何要访问这个对象的代码都要申请锁访问完毕再释放。

------------------				 
zhujiemao
2006-12-30

-------------------------------------------------------------
发件人：limodou
发送日期：2006-12-29 20:26:22
收件人：
抄送：
主题：Re: [python-chinese]请问如何才能锁住一个对象？

On 12/29/06, zhujiemao <zhujiemao在126.com> wrote:
> 在多线程环境下如何在对象上加锁?
> import thread, time
>
> def counter(myId, count):
>     for i in range(count):
>         mutex.acquire()
>         #time.sleep(1)
>         print '[%s] => %s' % (myId, i)
>         mutex.release()
>
> mutex = thread.allocate_lock()
> for i in range(10):
>     thread.start_new_thread(counter, (i,3))
>
> time.sleep(4)
> print 'Main thread exiting.'
>
> 看了下Programming Python里对这段代码的解释是：同一时间里，解释器里只有一个线程执行这段代码。
> 请问如何才能锁定对象的访问，比如锁定对一个字典的访问？

在python 中好象不能对一个对象加锁，你可以在访问对象前申请锁，在访问完对象后释放锁就行了。访问字典也是一样。

-- 
I like python!
UliPad <>: http://wiki.woodpecker.org.cn/moin/UliPad
My Blog: http://www.donews.net/limodou
_______________________________________________
python-chinese
Post: send python-chinese在lists.python.cn
Subscribe: send subscribe to python-chinese-request在lists.python.cn
Unsubscribe: send unsubscribe to  python-chinese-request在lists.python.cn
Detail Info: http://python.cn/mailman/listinfo/python-chinese

On 12/30/06, zhujiemao <zhujiemao在126.com> wrote:
> 也就是说如果我想锁定一个对象，那么在任何要访问这个对象的代码都要申请锁访问完毕再释放。
>
是的。不过这只是一个策略，需要许多方法共同来遵守。比如你的某个方法是先申请，处理，再释放的过程，但其它的方法并不这样做，一样起不到效果。

-- 
I like python!
UliPad <>: http://wiki.woodpecker.org.cn/moin/UliPad
My Blog: http://www.donews.net/limodou

On 12/29/06, zhujiemao <zhujiemao at 126.com> wrote:
>
> 在多线程环境下如何在对象上加锁?
> import thread, time
>
> def counter(myId, count):
>     for i in range(count):
>         mutex.acquire()
>         #time.sleep(1)
>         print '[%s] => %s' % (myId, i)
>         mutex.release()
>
> mutex = thread.allocate_lock()
> for i in range(10):
>     thread.start_new_thread(counter, (i,3))
>
> time.sleep(4)
> print 'Main thread exiting.'
>
> 看了下Programming Python里对这段代码的解释是：同一时间里，解释器里只有一个线程执行这段代码。
> 请问如何才能锁定对象的访问，比如锁定对一个字典的访问？
> _______________________________________________
> python-chinese
> Post: send python-chinese at lists.python.cn
> Subscribe: send subscribe to python-chinese-request at lists.python.cn
> Unsubscribe: send unsubscribe to  python-chinese-request at lists.python.cn
> Detail Info: http://python.cn/mailman/listinfo/python-chinese


首先对于多线程应用，锁得太多是很影响性能的，只在需要加锁的地方加锁。
其次合理的 OO 设计是对象只应该暴露出接口，而不是内部数据。如果你是要编写一个线程安全的类，你应该把具体加锁的策略写到实现中去。
如果你是要使用一个现有的不是线程安全的类，你可以考虑继承它，比如你说：比如锁定对一个字典的访问？ 你可以继承 dict ，编写一个线程安全的字典类。
总之，同步的代码最好不要在代码里到处蔓延。

刚才 google 了一下，搜到这个代码：
http://mail.python.org/pipermail/python-list/2004-July/269680.html
一个metaclass，自动把 class 中的方法变成线程安全的，也就是自动调用方法前加锁，调用后释放，如果性能不是很重要，这个很方便的。

-- 
http://codeplayer.blogspot.com/
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://python.cn/pipermail/python-chinese/attachments/20061230/d7b10c6c/attachment.htm 

谢谢大家

------------------				 
zhujiemao
2006-12-30

-------------------------------------------------------------
发件人：yi huang
发送日期：2006-12-30 14:54:01
收件人：
抄送：
主题：Re: [python-chinese]请问如何才能锁住一个对象？

On 12/29/06, zhujiemao <zhujiemao在126.com> wrote:
>
> 在多线程环境下如何在对象上加锁?
> import thread, time
>
> def counter(myId, count):
>     for i in range(count):
>         mutex.acquire()
>         #time.sleep(1)
>         print '[%s] => %s' % (myId, i)
>         mutex.release()
>
> mutex = thread.allocate_lock()
> for i in range(10):
>     thread.start_new_thread(counter, (i,3))
>
> time.sleep(4)
> print 'Main thread exiting.'
>
> 看了下Programming Python里对这段代码的解释是：同一时间里，解释器里只有一个线程执行这段代码。
> 请问如何才能锁定对象的访问，比如锁定对一个字典的访问？
> _______________________________________________
> python-chinese
> Post: send python-chinese在lists.python.cn
> Subscribe: send subscribe to python-chinese-request在lists.python.cn
> Unsubscribe: send unsubscribe to  python-chinese-request在lists.python.cn
> Detail Info: http://python.cn/mailman/listinfo/python-chinese


首先对于多线程应用，锁得太多是很影响性能的，只在需要加锁的地方加锁。
其次合理的 OO 设计是对象只应该暴露出接口，而不是内部数据。如果你是要编写一个线程安全的类，你应该把具体加锁的策略写到实现中去。
如果你是要使用一个现有的不是线程安全的类，你可以考虑继承它，比如你说：比如锁定对一个字典的访问？ 你可以继承 dict ，编写一个线程安全的字典类。
总之，同步的代码最好不要在代码里到处蔓延。

刚才 google 了一下，搜到这个代码：
http://mail.python.org/pipermail/python-list/2004-July/269680.html
一个metaclass，自动把 class 中的方法变成线程安全的，也就是自动调用方法前加锁，调用后释放，如果性能不是很重要，这个很方便的。

-- 
http://codeplayer.blogspot.com/
_______________________________________________
python-chinese
Post: send python-chinese在lists.python.cn
Subscribe: send subscribe to python-chinese-request在lists.python.cn
Unsubscribe: send unsubscribe to  python-chinese-request在lists.python.cn
Detail Info: http://python.cn/mailman/listinfo/python-chinese