fix yaml race conditions

OpenUtau.Core/Util/Yaml.cs

@@ -1,4 +1,4 @@
-using OpenUtau.Classic;
+using System.IO;
 using OpenUtau.Core.Ustx;
 using YamlDotNet.Core;
 using YamlDotNet.Core.Events;
@@ -7,19 +7,51 @@
 using YamlDotNet.Serialization.NamingConventions;
 
 namespace OpenUtau.Core {
-    public static class Yaml {
-        public static ISerializer DefaultSerializer = new SerializerBuilder()
+    public class Yaml {
+        public static Yaml DefaultSerializer => instance;
+        public static Yaml DefaultDeserializer => instance;
+
+        private static readonly Yaml instance = new Yaml();
+
+        private readonly ISerializer serializer = new SerializerBuilder()
             .WithNamingConvention(UnderscoredNamingConvention.Instance)
             .ConfigureDefaultValuesHandling(DefaultValuesHandling.OmitNull)
             .WithEventEmitter(next => new FlowEmitter(next))
             .DisableAliases()
             .WithQuotingNecessaryStrings()
             .Build();
 
-        public static IDeserializer DefaultDeserializer = new DeserializerBuilder()
+        private readonly IDeserializer deserializer = new DeserializerBuilder()
             .WithNamingConvention(UnderscoredNamingConvention.Instance)
             .IgnoreUnmatchedProperties()
             .Build();
+
+        private readonly object serializerLock = new object();
+        private readonly object deserializerLock = new object();
+
+        public string Serialize(object? graph) {
+            lock (serializerLock) {
+                return serializer.Serialize(graph);
+            }
+        }
+
+        public void Serialize(TextWriter writer, object? graph) {
+            lock (serializerLock) {
+                serializer.Serialize(writer, graph);
+            }
+        }
+
+        public T Deserialize<T>(string input) {
+            lock (deserializerLock) {
+                return deserializer.Deserialize<T>(input);
+            }
+        }
+
+        public T Deserialize<T>(TextReader input) {
+            lock (deserializerLock) {
+                return deserializer.Deserialize<T>(input);
+            }
+        }
     }
 
     public class FlowEmitter : ChainedEventEmitter {