diff --git a/‎git/util.py‎
Lines changed: 20 additions & 6 deletions b/‎git/util.py‎
Lines changed: 20 additions & 6 deletions
diff --git a/‎test/test_util.py‎
Lines changed: 18 additions & 3 deletions b/‎test/test_util.py‎
Lines changed: 18 additions & 3 deletions
@@ -1166,20 +1166,34 @@ def _obtain_lock_or_raise(self) -> None:
         if self._has_lock():
             return
         lock_file = self._lock_file_path()
-        # Create the lock in one step, the way Git and gitdb's LockedFD do. Testing
-        # for the file first leaves a window in which another holder creates it and
-        # both proceed, and O_CREAT|O_EXCL additionally refuses to follow a symbolic
-        # link planted at the lock path instead of writing through it.
+        # Create the lock in one step. Checking for it first would allow another
+        # holder to create it between the check and the open.
         try:
-            fd = os.open(lock_file, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
+            if sys.platform == "win32":
+                import _winapi
+
+                # Unlike POSIX, Windows follows dangling symlinks even with O_EXCL.
+                # Open the reparse point itself so an existing link is rejected.
+                handle = _winapi.CreateFile(
+                    lock_file,
+                    _winapi.GENERIC_WRITE,
+                    0,
+                    0,
+                    1,  # CREATE_NEW
+                    0x00200000,  # FILE_FLAG_OPEN_REPARSE_POINT
+                    0,
+                )
+                _winapi.CloseHandle(handle)
+            else:
+                fd = os.open(lock_file, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
+                os.close(fd)
         except FileExistsError as e:
             raise OSError(
                 "Lock for file %r did already exist, delete %r in case the lock is illegal"
                 % (self._file_path, lock_file)
             ) from e
         except OSError as e:
             raise OSError(str(e)) from e
-        os.close(fd)
 
         self._owns_lock = True
 
 
@@ -447,17 +447,28 @@ def test_lock_file(self):
             lock_file._obtain_lock_or_raise()
             lock_file._release_lock()
 
+    @ddt.data(False, True)
     @requires_symlinks
-    def test_lock_file_does_not_follow_a_symlink(self):
+    def test_lock_file_does_not_follow_a_symlink(self, target_exists):
         with tempfile.TemporaryDirectory() as tdir:
             my_file = os.path.join(tdir, "my-lock-file")
             outside = os.path.join(tdir, "outside-the-lock")
+            content = b"Do not modify the symlink target."
+            if target_exists:
+                with open(outside, "wb") as stream:
+                    stream.write(content)
             os.symlink(outside, my_file + ".lock")
 
             lock_file = LockFile(my_file)
             self.assertRaises(IOError, lock_file._obtain_lock_or_raise)
             assert not lock_file._has_lock()
-            assert not os.path.exists(outside)
+            lock_file._release_lock()
+            assert os.path.islink(my_file + ".lock")
+            if target_exists:
+                with open(outside, "rb") as stream:
+                    self.assertEqual(stream.read(), content)
+            else:
+                assert not os.path.exists(outside)
 
     def test_lock_file_is_obtained_by_a_single_holder(self):
         with tempfile.TemporaryDirectory() as tdir:
@@ -483,7 +494,11 @@ def obtain():
             for thread in threads:
                 thread.join()
 
-            self.assertEqual(1, len(holders))
+            try:
+                self.assertEqual(1, len(holders))
+            finally:
+                for lock_file in holders:
+                    lock_file._release_lock()
 
     def test_blocking_lock_file(self):
         with tempfile.TemporaryDirectory() as tdir: