Make LazySeq evaluation thread-safe (#935)

Fixes #934

Author: chrisrink10

CHANGELOG.md

@@ -22,6 +22,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
  * Fix a bug where reader column offset numbering began at 1, rather than 0 (#905)
  * Fix a bug where `basilisp.core/boolean` was returning the boolean coercions like Python rather than like Basilisp (#928)
  * Fix a bug where Basilisp vectors were not callable (#932)
+ * Fix a bug where `basilisp.lang.seq.LazySeq` instances were not thread-safe (#934)
 
 ### Other
  * Add several sections to Concepts documentation module (#666)

src/basilisp/lang/seq.py

@@ -1,4 +1,5 @@
 import functools
+import threading
 from typing import Callable, Iterable, Iterator, Optional, TypeVar, overload
 
 from basilisp.lang.interfaces import (
@@ -152,7 +153,7 @@ class LazySeq(IWithMeta, ISequential, ISeq[T]):
     Callers should never provide the `obj` or `seq` arguments -- these are provided
     only to support `with_meta` returning a new LazySeq instance."""
 
-    __slots__ = ("_gen", "_obj", "_seq", "_meta")
+    __slots__ = ("_gen", "_obj", "_seq", "_lock", "_meta")
 
     def __init__(
         self,
@@ -165,6 +166,7 @@ def __init__(
         self._gen: Optional[LazySeqGenerator] = gen
         self._obj: Optional[ISeq[T]] = obj
         self._seq: Optional[ISeq[T]] = seq
+        self._lock = threading.RLock()
         self._meta = meta
 
     @property
@@ -206,22 +208,23 @@ def _compute_seq(self) -> Optional[ISeq[T]]:
         return self._obj if self._obj is not None else self._seq
 
     def seq(self) -> Optional[ISeq[T]]:
-        self._compute_seq()
-        if self._obj is not None:
-            o = self._obj
-            self._obj = None
-            # Consume any additional lazy sequences returned immediately so we have a
-            # "real" concrete sequence to proxy to.
-            #
-            # The common idiom with LazySeqs is to return (cons value (lazy-seq ...))
-            # from the generator function, so this will only result in evaluating away
-            # instances where _another_ LazySeq is returned rather than a cons cell
-            # with a concrete first value. This loop will not consume the LazySeq in
-            # the rest position of the cons.
-            while isinstance(o, LazySeq):
-                o = o._compute_seq()  # type: ignore
-            self._seq = to_seq(o)
-        return self._seq
+        with self._lock:
+            self._compute_seq()
+            if self._obj is not None:
+                o = self._obj
+                self._obj = None
+                # Consume any additional lazy sequences returned immediately, so we
+                # have a "real" concrete sequence to proxy to.
+                #
+                # The common idiom with LazySeqs is to return
+                # (cons value (lazy-seq ...)) from the generator function, so this will
+                # only result in evaluating away instances where _another_ LazySeq is
+                # returned rather than a cons cell with a concrete first value. This
+                # loop will not consume the LazySeq in the rest position of the cons.
+                while isinstance(o, LazySeq):
+                    o = o._compute_seq()  # type: ignore
+                self._seq = to_seq(o)
+            return self._seq
 
     @property
     def is_empty(self) -> bool:
@@ -246,7 +249,8 @@ def cons(self, elem):
 
     @property
     def is_realized(self):
-        return self._gen is None
+        with self._lock:
+            return self._gen is None
 
 
 def sequence(s: Iterable[T]) -> ISeq[T]: