I have inherited code that uses multiple event loops to handle read/writing to/from multiple objects created using websockets.serve. These coroutines need to access a common list.
I assume the event loops run in parallel, each in its own thread. In that case you would treat shared data exactly as you would data shared between different threads. Specifically:
It will depend on what you are doing with the lists. If one thread is reading and the other is calling something like append, you don't need synchronization because you're protected by the GIL. But if you are doing something more complex, e.g. deleting the items directed by the reader thread, you will need to lock to ensure you don't lose items due to concurrent modification.
asyncio.Lock is definitely not the correct locking device to use because it is designed for use within one event loop, i.e. it's single-threaded. You can't use a threading.Lock either because it's non-async and would block the whole event loop. You could probably use loop.call_soon_threadsafe to synchronize between event loops, but it's not trivial.
The code you inherited uses asyncio in a way it was not intended to be used and you're likely to run into issues. Since the asyncio event loop is designed to scale to an arbitrary number of tasks, I recommend refactoring the code to use a single event loop. Then you'll need no special synchronization, as any code between awaits will naturally form a critical section, and if you need locking across await, you can use asyncio.Lock, which was created for that use case.
