Stop PythonDerivedType.Finalize from trying to delete any Python objects

tonyroberts · tonyroberts · commit ecf3237d27a8 · 2014-09-15T13:07:07.000+01:00
once Py_Finalize has started.
diff --git a/pythonnet/src/runtime/classderived.cs b/pythonnet/src/runtime/classderived.cs
@@ -531,29 +531,45 @@ public static void Finalize(IPythonDerivedType obj)
             FieldInfo fi = obj.GetType().GetField("__pyobj__");
             CLRObject self = (CLRObject)fi.GetValue(obj);
 
-            // delete the python object in an asnyc task as we may not be able to acquire
-            // the GIL immediately and we don't want to block the GC thread.
-            var t = Task.Factory.StartNew(() =>
+            // If python's been terminated then just free the gchandle.
+            lock (Runtime.IsFinalizingLock)
             {
-                // If python's been terminated then there's nothing to do
-                if (0 == Runtime.Py_IsInitialized())
-                    return;
-
-                IntPtr gs = Runtime.PyGILState_Ensure();
-                try
+                if (0 == Runtime.Py_IsInitialized() || Runtime.IsFinalizing)
                 {
-                    // the C# object is being destroyed which must mean there are no more
-                    // references to the Python object as well so now we can dealloc the
-                    // python object.
-                    IntPtr dict = Marshal.ReadIntPtr(self.pyHandle, ObjectOffset.DictOffset(self.pyHandle));
-                    if (dict != IntPtr.Zero)
-                        Runtime.Decref(dict);
-                    Runtime.PyObject_GC_Del(self.pyHandle);
                     self.gcHandle.Free();
+                    return;
                 }
-                finally
+            }
+
+            // delete the python object in an asnyc task as we may not be able to acquire
+            // the GIL immediately and we don't want to block the GC thread.
+            var t = Task.Factory.StartNew(() =>
+            {
+                lock (Runtime.IsFinalizingLock)
                 {
-                    Runtime.PyGILState_Release(gs);
+                    // If python's been terminated then just free the gchandle.
+                    if (0 == Runtime.Py_IsInitialized() || Runtime.IsFinalizing)
+                    {
+                        self.gcHandle.Free();
+                        return;
+                    }
+
+                    IntPtr gs = Runtime.PyGILState_Ensure();
+                    try
+                    {
+                        // the C# object is being destroyed which must mean there are no more
+                        // references to the Python object as well so now we can dealloc the
+                        // python object.
+                        IntPtr dict = Marshal.ReadIntPtr(self.pyHandle, ObjectOffset.DictOffset(self.pyHandle));
+                        if (dict != IntPtr.Zero)
+                            Runtime.Decref(dict);
+                        Runtime.PyObject_GC_Del(self.pyHandle);
+                        self.gcHandle.Free();
+                    }
+                    finally
+                    {
+                        Runtime.PyGILState_Release(gs);
+                    }
                 }
             });
         }
diff --git a/pythonnet/src/runtime/moduleobject.cs b/pythonnet/src/runtime/moduleobject.cs
@@ -442,6 +442,12 @@ public static String[] ListAssemblies(bool verbose)
             return names;
         }
 
+        [ModuleFunctionAttribute()]
+        public static int _AtExit()
+        {
+            return Runtime.AtExit();
+        }
+
     }
 
 }
diff --git a/pythonnet/src/runtime/pythonengine.cs b/pythonnet/src/runtime/pythonengine.cs
@@ -117,6 +117,16 @@ public static void Initialize() {
                 Runtime.Initialize();
                 initialized = true;
                 Exceptions.Clear();
+
+                // register the atexit callback (this doesn't use Py_AtExit as the C atexit
+                // callbacks are called after python is fully finalized but the python ones
+                // are called while the python engine is still running).
+                string code =
+                "import atexit, clr\n" +
+                "atexit.register(clr._AtExit)\n";
+                PyObject r = PythonEngine.RunString(code);
+                if (r != null)
+                    r.Dispose();
             }
         }
 
diff --git a/pythonnet/src/runtime/runtime.cs b/pythonnet/src/runtime/runtime.cs
@@ -84,6 +84,10 @@ public class Runtime {
 #error You must define one of PYTHON23 to PYTHON34
 #endif
 
+        // set to true when python is finalizing
+        internal static Object IsFinalizingLock = new Object();
+        internal static bool IsFinalizing = false;
+
         internal static bool wrap_exceptions;
         internal static bool is32bit;
 
@@ -232,6 +236,14 @@ internal static void Shutdown() {
         Py_Finalize();
     }
 
+    // called *without* the GIL aquired by clr._AtExit
+    internal static int AtExit() {
+        lock (IsFinalizingLock) {
+            IsFinalizing = true;
+        }
+        return 0;
+    }
+
     internal static IntPtr Py_single_input = (IntPtr)256;
     internal static IntPtr Py_file_input = (IntPtr)257;
     internal static IntPtr Py_eval_input = (IntPtr)258;

Original file line number	Diff line number	Diff line change
`@@ -442,6 +442,12 @@ public static String[] ListAssemblies(bool verbose)`
`442`	`442`	`return names;`
`443`	`443`	`}`
`444`	`444`
	`445`	`+ [ModuleFunctionAttribute()]`
	`446`	`+ public static int _AtExit()`
	`447`	`+ {`
	`448`	`+ return Runtime.AtExit();`
	`449`	`+ }`
	`450`	`+`
`445`	`451`	`}`
`446`	`452`
`447`	`453`	`}`