@@ -413,6 +413,8 @@ def _get_test_server_config(
 
     for server in _collect_test_servers(name, config_file):
         was_already_started = server._started
+        # Another process using this server: try the next one rather than wait
+        server.claim_timeout = 0
         try:
             server.start()
         except Exception as e:
 
@@ -34,6 +34,30 @@ pytest -k "test_to_utc"
 pytest tests/test_caldav_unit.py
 ```
 
+### Parallel Test Runs
+
+Test runs share the servers (fixed ports, users and calendar names), so
+two runs against the same server would clobber each other.  Each process
+takes an exclusive per-server lock (`$TMPDIR/caldav-test-server-<name>.session.lock`)
+when it first starts using a server and holds it until it exits.  A second run
+against the same server waits; runs against different servers proceed in
+parallel:
+
+```bash
+pytest tests/test_caldav.py -k Baikal &
+pytest tests/test_caldav.py -k Nextcloud &
+```
+
+The lock file lives in the temp directory, so runs only see each other's
+locks when they share `TMPDIR`.
+
+The wait is capped at `PYTHON_CALDAV_TEST_SERVER_LOCK_TIMEOUT` seconds
+(default 1800), as two runs taking servers in different orders could
+otherwise deadlock.  After that, the tests for that server fail at once,
+naming the pid holding the lock; the run continues with the other servers.
+`get_davclient()` with `PYTHON_CALDAV_USE_TEST_SERVER` does not wait at all:
+it moves on to the next available server.
+
 ## Test Configuration
 
 Test configuration uses YAML or JSON files. The configuration loader searches
 
@@ -7,10 +7,13 @@
 - DockerTestServer: For servers that run in Docker containers
 """
 
+import os
+import threading
 from abc import ABC, abstractmethod
 from collections.abc import Iterator
 from contextlib import contextmanager
-from typing import Any
+from pathlib import Path
+from typing import IO, Any
 
 try:
     import niquests as requests
@@ -21,6 +24,22 @@
 DEFAULT_HTTP_TIMEOUT = 5
 MAX_STARTUP_WAIT_SECONDS = 60
 STARTUP_POLL_INTERVAL = 0.05
+SESSION_LOCK_TIMEOUT_SECONDS = 1800
+
+# Per-server session locks held by this process, keyed by server name.
+# flock conflicts between two opens even within one process, so each
+# lock file is opened only once.
+_session_locks: dict[str, IO[str]] = {}
+# Servers whose lock timed out; later claims fail at once instead of
+# waiting again for every remaining test.
+_session_lock_failures: dict[str, RuntimeError] = {}
+_session_locks_mutex = threading.Lock()
+
+
+def _lock_path(name: str, suffix: str = "") -> Path:
+    import tempfile
+
+    return Path(tempfile.gettempdir()) / f"caldav-test-server-{name.lower()}{suffix}.lock"
 
 
 class TestServer(ABC):
@@ -106,11 +125,83 @@ def features(self) -> Any:
 
         return resolve_features(self.config.get("features", []))
 
+    # Seconds to wait for another process's session lock; None means
+    # $PYTHON_CALDAV_TEST_SERVER_LOCK_TIMEOUT or SESSION_LOCK_TIMEOUT_SECONDS.
+    claim_timeout: float | None = None
+
+    @staticmethod
+    def claim_server(name: str, timeout: float | None = None) -> bool:
+        """Take an exclusive lock on server ``name`` for the rest of this process.
+
+        Test runs sharing a server would clobber each other's calendars (and
+        one run's teardown may stop a container another run still uses), so
+        a second process waits here until the first one exits.  Runs against
+        different servers proceed in parallel.  The OS drops the lock when
+        the process dies, so a crashed run leaves nothing stale behind.
+
+        Waits at most ``timeout`` seconds (default
+        ``$PYTHON_CALDAV_TEST_SERVER_LOCK_TIMEOUT``, or 30 minutes) - two runs
+        taking servers in different orders could otherwise deadlock.  A
+        timeout is remembered, so the remaining tests for that server fail
+        at once.
+
+        Returns True if the lock was taken just now, False if this process
+        already held it.  Anything learned about the server before a fresh
+        claim may be stale, since its previous user may have stopped it.
+        """
+        import fcntl
+        import time
+
+        with _session_locks_mutex:
+            if name in _session_locks:
+                return False
+            if name in _session_lock_failures:
+                raise _session_lock_failures[name]
+            if timeout is None:
+                timeout = float(
+                    os.environ.get(
+                        "PYTHON_CALDAV_TEST_SERVER_LOCK_TIMEOUT", SESSION_LOCK_TIMEOUT_SECONDS
+                    )
+                )
+            lock_file = open(_lock_path(name, ".session"), "a+")
+            deadline = time.monotonic() + timeout
+            announced = False
+            while True:
+                try:
+                    fcntl.flock(lock_file, fcntl.LOCK_EX | fcntl.LOCK_NB)
+                    break
+                except BlockingIOError:
+                    lock_file.seek(0)
+                    holder = lock_file.read().strip() or "unknown"
+                    if time.monotonic() > deadline:
+                        lock_file.close()
+                        error = RuntimeError(
+                            f"Test server {name} is in use by pid {holder}; "
+                            f"gave up after {timeout:.0f}s"
+                        )
+                        _session_lock_failures[name] = error
+                        raise error from None
+                    if not announced:
+                        print(f"[WAIT] {name} is in use by pid {holder} - waiting")
+                        announced = True
+                    time.sleep(1)
+            lock_file.truncate(0)
+            lock_file.write(str(os.getpid()))
+            lock_file.flush()
+            _session_locks[name] = lock_file
+            return True
+
+    def claim(self) -> bool:
+        """``claim_server()`` for this server, honouring ``claim_timeout``."""
+        return self.claim_server(self.name, self.claim_timeout)
+
     @abstractmethod
     def start(self) -> None:
         """
         Start the server if not already running.
 
+        Implementations must call ``self.claim()`` first.
+
         This method should be idempotent - calling it multiple times
         should not cause issues.
 
@@ -206,15 +297,15 @@ def get_server_params(self) -> dict[str, Any]:
         # Pass through scheduling_users if configured (for TestScheduling generation)
         if "scheduling_users" in self.config:
             params["scheduling_users"] = self.config["scheduling_users"]
+        # setup is always needed, since start() also takes the session lock
+        params["setup"] = lambda _: self.start()
         # Check if server is already running (either started by us or externally)
         already_running = self._started or self.is_accessible()
         if already_running:
             # Server is already running - mark as started but don't add teardown
             # to avoid stopping a server that was running before tests started
             self._started = True
         else:
-            # Server needs to be started - add setup/teardown callbacks
-            params["setup"] = lambda _: self.start()
             params["teardown"] = lambda _: self.stop()
         return params
 
@@ -340,7 +431,13 @@ def start(self) -> None:
         Raises:
             RuntimeError: If Docker is not available or container fails to start
         """
-        if self._started or self.is_accessible():
+        if self.claim():
+            # Whatever was seen before the lock (e.g. at collection) may be
+            # stale: the previous holder may have stopped the container.
+            self._started = False
+        if self._started:
+            return
+        if self.is_accessible():
             self._started = True  # Mark as started even if already running
             # Don't set _started_by_us - we didn't start it this time
             print(f"[OK] {self.name} is already running")
@@ -371,11 +468,8 @@ def _lock(self) -> Iterator[None]:
         repo share the same containers and ports.
         """
         import fcntl
-        import tempfile
-        from pathlib import Path
 
-        lock_path = Path(tempfile.gettempdir()) / f"caldav-test-server-{self.name.lower()}.lock"
-        with open(lock_path, "w") as lock_file:
+        with open(_lock_path(self.name), "w") as lock_file:
             fcntl.flock(lock_file, fcntl.LOCK_EX)
             try:
                 yield
@@ -482,6 +576,7 @@ def start(self) -> None:
         # No accessibility check here - the caldav library handles URL
         # normalization, RFC6764 discovery, and will provide proper error
         # messages if the server is unreachable
+        self.claim()
         self._started = True
 
     def stop(self) -> None:
 
@@ -39,6 +39,7 @@ def is_accessible(self) -> bool:
         return self._core.is_accessible()
 
     def start(self) -> None:
+        self.claim()
         self._core.start()
         self._started = self._core._started
 
@@ -73,6 +74,7 @@ def is_accessible(self) -> bool:
         return self._core.is_accessible()
 
     def start(self) -> None:
+        self.claim()
         self._core.start()
         self._started = self._core._started
 
 
@@ -5,9 +5,38 @@
 
 import pytest
 
+from . import base
 from .base import DockerTestServer
 
 
+@pytest.fixture(autouse=True)
+def isolated_session_locks(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
+    """Keep session locks taken by these tests out of the real tempdir."""
+    monkeypatch.setattr("tempfile.tempdir", str(tmp_path))
+    monkeypatch.setattr(base, "_session_locks", {})
+    monkeypatch.setattr(base, "_session_lock_failures", {})
+    yield
+    for f in base._session_locks.values():
+        f.close()
+
+
+@pytest.fixture
+def held_elsewhere(tmp_path: Path):
+    """Hold a server's session lock through a separate open file, as another process would."""
+    import fcntl
+
+    files = []
+
+    def hold(name: str) -> None:
+        f = open(tmp_path / f"caldav-test-server-{name.lower()}.session.lock", "a+")
+        fcntl.flock(f, fcntl.LOCK_EX)
+        files.append(f)
+
+    yield hold
+    for f in files:
+        f.close()
+
+
 class UnreachableDockerServer(DockerTestServer):
     """A docker server whose start.sh fails and which never answers."""
 
@@ -64,3 +93,108 @@ def is_accessible(self) -> bool:
 
         assert counter.read_text().count("run") == 1
         assert sum(s._started_by_us for s in servers) == 1
+
+
+class TestSessionLock:
+    """Test runs sharing a server must not overlap; different servers may."""
+
+    CLAIM = (
+        "import sys; sys.path.insert(0, {root!r}); "
+        "from tests.test_servers.base import TestServer; "
+        "TestServer.claim_server({name!r})"
+    )
+
+    def _claim_in_subprocess(self, tmp_path: Path, name: str) -> subprocess.CompletedProcess:
+        import os
+        import sys
+
+        root = str(Path(__file__).parents[2])
+        env = dict(os.environ, TMPDIR=str(tmp_path), PYTHON_CALDAV_TEST_SERVER_LOCK_TIMEOUT="1")
+        return subprocess.run(
+            [sys.executable, "-c", self.CLAIM.format(root=root, name=name)],
+            env=env,
+            capture_output=True,
+            text=True,
+            timeout=60,
+        )
+
+    def test_same_server_blocks_other_process(self, tmp_path: Path) -> None:
+        import os
+
+        base.TestServer.claim_server("Alpha")
+        base.TestServer.claim_server("Alpha")  # re-entrant within one process
+        blocked = self._claim_in_subprocess(tmp_path, "Alpha")
+        assert blocked.returncode != 0
+        assert f"pid {os.getpid()}" in blocked.stderr
+        assert self._claim_in_subprocess(tmp_path, "Beta").returncode == 0
+
+    def test_start_claims_server(self, tmp_path: Path) -> None:
+        server = base.ExternalTestServer({"name": "Gamma", "url": "http://localhost:1/"})
+        server.start()
+        assert self._claim_in_subprocess(tmp_path, "Gamma").returncode != 0
+
+    def test_setup_hook_set_for_running_server(self) -> None:
+        """test_caldav only reaches start() (and thus the lock) via the setup hook."""
+        server = base.ExternalTestServer({"name": "Delta", "url": "http://localhost:1/"})
+        assert "setup" in server.get_server_params()
+
+    def test_timeout_is_remembered(self, held_elsewhere, monkeypatch: pytest.MonkeyPatch) -> None:
+        """test_caldav claims per test; a timed-out server must not wait again each time."""
+        import time
+
+        held_elsewhere("Epsilon")
+        monkeypatch.setenv("PYTHON_CALDAV_TEST_SERVER_LOCK_TIMEOUT", "1")
+        with pytest.raises(RuntimeError, match="in use"):
+            base.TestServer.claim_server("Epsilon")
+        t0 = time.monotonic()
+        with pytest.raises(RuntimeError, match="in use"):
+            base.TestServer.claim_server("Epsilon")
+        assert time.monotonic() - t0 < 0.5
+
+    def test_claim_timeout_attribute_skips_wait(self, held_elsewhere) -> None:
+        """get_davclient()'s fallback must move on at once from a busy server."""
+        import time
+
+        held_elsewhere("Zeta")
+        server = base.ExternalTestServer({"name": "Zeta", "url": "http://localhost:1/"})
+        server.claim_timeout = 0
+        t0 = time.monotonic()
+        with pytest.raises(RuntimeError, match="in use"):
+            server.start()
+        assert time.monotonic() - t0 < 0.5
+
+    def test_get_davclient_falls_through_busy_server(
+        self, held_elsewhere, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        import time
+
+        from caldav import config
+
+        held_elsewhere("Busy")
+        monkeypatch.setenv("PYTHON_CALDAV_TEST_SERVER_LOCK_TIMEOUT", "30")
+        servers = [
+            base.ExternalTestServer({"name": n, "url": f"http://localhost:1/{n}/"})
+            for n in ("Busy", "Free")
+        ]
+        monkeypatch.setattr(config, "_collect_test_servers", lambda name, config_file: servers)
+        t0 = time.monotonic()
+        params = config._get_test_server_config(None, environment=False)
+        assert time.monotonic() - t0 < 5
+        assert params is not None and "Free" in params["url"]
+
+    def test_waiting_run_restarts_container_stopped_meanwhile(self, tmp_path: Path) -> None:
+        """Collection saw the container up, but its owner stopped it before we got the lock."""
+        counter = tmp_path / "runs"
+        start_script = tmp_path / "start.sh"
+        start_script.write_text(f"#!/bin/sh\necho run >> {counter}\n")
+        start_script.chmod(0o755)
+
+        class CountingServer(UnreachableDockerServer):
+            def is_accessible(self) -> bool:
+                return counter.exists()
+
+        server = CountingServer({"name": "Eta", "docker_dir": str(tmp_path)})
+        server.verify_docker = lambda: True  # type: ignore[method-assign]
+        server._started = True  # as get_server_params() leaves it at collection
+        server.start()
+        assert counter.read_text().count("run") == 1