diff --git a/Src/IronPython/Runtime/Types/PythonType.cs b/Src/IronPython/Runtime/Types/PythonType.cs
index e3989f5dc..984833923 100644
--- a/Src/IronPython/Runtime/Types/PythonType.cs
+++ b/Src/IronPython/Runtime/Types/PythonType.cs
@@ -39,7 +39,7 @@ public partial class PythonType : IPythonMembersList, IDynamicMetaObjectProvider
         private PythonTypeAttributes _attrs;                // attributes of the type
         private int _flags;                                 // CPython-like flags on the type
         private int _version = GetNextVersion();            // version of the type
-        private List<WeakReference> _subtypes;              // all of the subtypes of the PythonType
+        private List<WeakReference<PythonType>> _subtypes;  // all of the subtypes of the PythonType
         private PythonContext _pythonContext;               // the context the type was created from, or null for system types.
         private bool? _objectNew, _objectInit;              // true if the type doesn't override __new__ / __init__ from object.
         internal Dictionary<CachedGetKey, FastGetBase> _cachedGets; // cached gets on user defined type instances
@@ -76,7 +76,6 @@ public partial class PythonType : IPythonMembersList, IDynamicMetaObjectProvider
         [MultiRuntimeAware]
         private static int MasterVersion = 1;
         private static readonly CommonDictionaryStorage _pythonTypes = new CommonDictionaryStorage();
-        private static readonly WeakReference[] _emptyWeakRef = Array.Empty<WeakReference>();
         private static readonly object _subtypesLock = new object();
         internal static readonly Func<string, Exception, Exception> DefaultMakeException = (message, innerException) => new Exception(message, innerException);
         internal static readonly Func<string, Exception> DefaultMakeExceptionNoInnerException = (message) => new Exception(message);
@@ -680,17 +679,15 @@ public static PythonDictionary __prepare__([ParamDictionary]IDictionary<object,
 
         public PythonList __subclasses__(CodeContext/*!*/ context) {
             PythonList ret = new PythonList();
-            IList<WeakReference> subtypes = SubTypes;
+            var subtypes = SubTypes;
 
             if (subtypes != null) {
                 PythonContext pc = context.LanguageContext;
 
-                foreach (WeakReference wr in subtypes) {
-                    if (wr.IsAlive) {
-                        PythonType pt = (PythonType)wr.Target;
-
+                foreach (var wr in subtypes) {
+                    if (wr.TryGetTarget(out PythonType pt)) {
                         if (pt.PythonContext == null || pt.PythonContext == pc) {
-                            ret.AddNoLock(wr.Target);
+                            ret.AddNoLock(pt);
                         }
                     }
                 }
@@ -1270,8 +1267,8 @@ public static PythonDictionary __prepare__([ParamDictionary]IDictionary<object,
         private void ClearObjectNewInSubclasses(PythonType pt) {
             lock (_subtypesLock) {
                 if (pt._subtypes != null) {
-                    foreach (WeakReference wr in pt._subtypes) {
-                        if (wr.Target is PythonType type) {
+                    foreach (var wr in pt._subtypes) {
+                        if (wr.TryGetTarget(out PythonType type)) {
                             type._objectNew = null;
 
                             ClearObjectNewInSubclasses(type);
@@ -1284,8 +1281,8 @@ public static PythonDictionary __prepare__([ParamDictionary]IDictionary<object,
         private void ClearObjectInitInSubclasses(PythonType pt) {
             lock (_subtypesLock) {
                 if (pt._subtypes != null) {
-                    foreach (WeakReference wr in pt._subtypes) {
-                        if (wr.Target is PythonType type) {
+                    foreach (var wr in pt._subtypes) {
+                        if (wr.TryGetTarget(out PythonType type)) {
                             type._objectInit = null;
 
                             ClearObjectInitInSubclasses(type);
@@ -2465,9 +2462,9 @@ public static PythonDictionary __prepare__([ParamDictionary]IDictionary<object,
         #region Private implementation details
 
         private void UpdateVersion() {
-            foreach (WeakReference wr in SubTypes) {
-                if (wr.IsAlive) {
-                    ((PythonType)wr.Target).UpdateVersion();
+            foreach (var wr in SubTypes) {
+                if (wr.TryGetTarget(out PythonType pt)) {
+                    pt.UpdateVersion();
                 }
             }
 
@@ -2497,31 +2494,35 @@ public static PythonDictionary __prepare__([ParamDictionary]IDictionary<object,
                     null);
             }
         }
-      
+
         /// <summary>
         /// Internal helper function to add a subtype
         /// </summary>
         private void AddSubType(PythonType subtype) {
             if (_subtypes == null) {
-                Interlocked.CompareExchange<List<WeakReference>>(ref _subtypes, new List<WeakReference>(), null);
+                Interlocked.CompareExchange(ref _subtypes, new List<WeakReference<PythonType>>(), null);
             }
 
             lock (_subtypesLock) {
-                _subtypes.Add(new WeakReference(subtype));
+                if (_subtypes.Count == _subtypes.Capacity) {
+                    _subtypes.RemoveAll(x => !x.TryGetTarget(out _)); // remove dead entries
+                }
+                _subtypes.Add(new WeakReference<PythonType>(subtype));
             }
         }
 
         private void RemoveSubType(PythonType subtype) {
-            int i = 0;
-            if (_subtypes != null) {
-                lock (_subtypesLock) {
-                    while (i < _subtypes.Count) {
-                        if (!_subtypes[i].IsAlive || _subtypes[i].Target == subtype) {
-                            _subtypes.RemoveAt(i);
-                            continue;
-                        }
-                        i++;
+            if (_subtypes is null) return;
+
+            lock (_subtypesLock) {
+                int i = 0;
+                while (i < _subtypes.Count) {
+                    var wr = _subtypes[i];
+                    if (!wr.TryGetTarget(out PythonType target) || target == subtype) {
+                        _subtypes.RemoveAt(i);
+                        continue;
                     }
+                    i++;
                 }
             }
         }
@@ -2530,9 +2531,9 @@ public static PythonDictionary __prepare__([ParamDictionary]IDictionary<object,
         /// Gets a list of weak references to all the subtypes of this class.  May return null
         /// if there are no subtypes of the class.
         /// </summary>
-        private IList<WeakReference> SubTypes {
+        private IList<WeakReference<PythonType>> SubTypes {
             get {
-                if (_subtypes == null) return _emptyWeakRef;
+                if (_subtypes == null) return Array.Empty<WeakReference<PythonType>>();
 
                 lock (_subtypesLock) {
                     return _subtypes.ToArray();
diff --git a/Src/IronPythonTest/Cases/IronPythonCasesManifest.ini b/Src/IronPythonTest/Cases/IronPythonCasesManifest.ini
index 02e23cc1c..f63aa1863 100644
--- a/Src/IronPythonTest/Cases/IronPythonCasesManifest.ini
+++ b/Src/IronPythonTest/Cases/IronPythonCasesManifest.ini
@@ -55,10 +55,9 @@ Ignore=true
 Reason=Assertion error
 
 [IronPython.test_memory]
-#RunCondition=NOT $(IS_POSIX)
-#Reason=Memory allocation on Mono may not match MS.NET
-Ignore=true
-Reason=Fails intermittently - https://github.com/IronLanguages/ironpython3/issues/508
+IsolationLevel=PROCESS # to avoid having a long list of object subtypes
+RunCondition=NOT $(IS_MONO)
+Reason=Memory allocation on Mono may not match MS.NET
 
 [IronPython.test_number]
 Timeout=300000 # 5 minute timeout - slow on macOS
diff --git a/Tests/test_memory.py b/Tests/test_memory.py
index 48887d7d6..e4493b1a4 100644
--- a/Tests/test_memory.py
+++ b/Tests/test_memory.py
@@ -82,9 +82,9 @@ def setUp(self):
         from Microsoft.Scripting.Generation import Snippets
 
         self.skipMemoryCheck = Snippets.Shared.SaveSnippets or clr.GetCurrentRuntime().Configuration.DebugMode
-        self.expectedMem = 24000
 
         # account for adaptive compilation
+        self.expectedMem = 24000
         if is_cli64:
             self.expectedMem = int(self.expectedMem*1.25)