Path: csiph.com!fu-berlin.de!uni-berlin.de!not-for-mail
From: Stefan Schwarzer <sschwarzer@sschwarzer.net>
Newsgroups: de.comp.lang.python
Subject: =?utf-8?q?=5BPython-de=5D_Re=3A_Code_Style_Review?=
Date: Tue, 29 Nov 2022 18:51:17 +0100
Lines: 64
Message-ID: <3d4a86fc-9794-30bb-4f28-6154caf24cfa@sschwarzer.net>
References: <tm2jhn$1k5h8$1@news1.tnib.de> <480b80d21e58d280c437b4854bfc7cf1@posteo.de> <d60e87cd-51b9-084e-3fb6-d15b7588004d@chrisarndt.de> <tm37ut$1lfhm$1@news1.tnib.de>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
User-Agent: Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.8.1.24) Gecko/20100411 Thunderbird/2.0.0.24 Mnenhy/0.7.6.666
Content-Language: en-US, de-DE
In-Reply-To: <tm37ut$1lfhm$1@news1.tnib.de>
Message-ID-Hash: RHSNU6S6CWCELVTUKTFJSX3EGNGKGNHN
Precedence: list
Archived-At: <https://mail.python.org/archives/list/python-de@python.org/message/RHSNU6S6CWCELVTUKTFJSX3EGNGKGNHN/>
Xref: csiph.com de.comp.lang.python:5876

On 2022-11-28 22:07, Marc Haber wrote:
> Kann ich die Locks innerhalb der entsprechenden Funktion definieren
> oder bekomme ich dann in jedem Thread ein eigenes Lock, was der
> Intention entgegen spricht?
> 
> Ist:
> 
> foolock = threading.Lock()
> def foo:
>      with foolock:
>          (tue Dinge mit foo, potenziell multithreaded)
> 
> dasselbe wie
> 
> def foo:
>      foolock = threading.Lock()
>      with foolock:
>          (tue Dinge mit foo, potenziell multithreaded)
> 
> ?

Die Ansätze sind _nicht_ gleichwertig. Wie du richtig
erkannt/vermutet hast, definierst du im zweiten Ansatz bei
Ausführung von `foo` "on the fly" ein Lock-Objekt.
Dieses hat mit anderen Lock-Objekten, die in anderen
Threads in `foo` erzeugt werden, nichts zu tun. Das Lock
ist damit wirkungslos (vielleicht mal abgesehen von dem
Sonderfall, dass du das Lock in anderen Aufrufen im
`with`-Block weiterreichst, aber das ist eine ganz andere
Semantik, die du hier vermutlich nicht im Sinn hast :-) ).

> Ist die in
> https://www.bogotobogo.com/python/Multithread/python_multithreading_Using_Locks_with_statement_Context_Manager.php
> und
> https://www.pythontutorial.net/python-concurrency/python-threading-lock/
> verwendete Schreibweise, wo das Lock als Parameter mit in die Funktion
> hineingereicht wird, wirklich "schönes" Python?

Allgemein würde ich nicht `acquire` und `release` explizit
verwenden beziehungsweise die meisten der Situationen, wo
man `acquire` und `release` verwendet, können mit einem
`with some_lock:` übersichtlicher geschrieben werden.

> Oder schreibe ich mein ganzes Programm als eine Klasse, die genau
> einmal instanziiert wird und dann in ihren statischen Variablen (so
> wäre es in C++) die Tabelle, die Konfiguration, die Locks, den
> Debugstatus etc hält? Sind solche Ein-Instanz-Klassen "schönes"
> Python?

Ich kenne so etwas unter dem Namen "Active Object"-Pattern;
jedenfalls nehme ich an, dass das gemeint ist (auch wenn es
sich aus meiner Sicht etwas wüst anhört, ganz verschiedene
Sachen in die Instanz zu packen, falls das so gemeint ist).

Ein weiterer Ansatz ist, Queues zur Synchronisation zu
verwenden, was tendenziell deutlich weniger fehleranfällig
ist. Ich habe vor ein paar Jahren einen Vortrag zu
Nebenläufigkeit in Python gehalten, der auch Queues und
Active Objects behandelt:

https://sschwarzer.com/download/concurrency_pycon_de2018.pdf

Viele Grüße
Stefan