ThreadPoolSchedulerTest.cs 9.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341
  1. // Licensed to the .NET Foundation under one or more agreements.
  2. // The .NET Foundation licenses this file to you under the MIT License.
  3. // See the LICENSE file in the project root for more information.
  4. #if !NO_THREAD
  5. using System;
  6. using System.Collections.Generic;
  7. using System.Linq;
  8. using System.Reactive.Concurrency;
  9. using System.Threading;
  10. using Microsoft.Reactive.Testing;
  11. using Microsoft.VisualStudio.TestTools.UnitTesting;
  12. using Assert = Xunit.Assert;
  13. namespace ReactiveTests.Tests
  14. {
  15. [TestClass]
  16. public class ThreadPoolSchedulerTest
  17. {
  18. [TestMethod]
  19. public void Schedule_ArgumentChecking()
  20. {
  21. ReactiveAssert.Throws<ArgumentNullException>(() => ThreadPoolScheduler.Instance.Schedule(42, default));
  22. ReactiveAssert.Throws<ArgumentNullException>(() => ThreadPoolScheduler.Instance.Schedule(42, DateTimeOffset.Now, default));
  23. ReactiveAssert.Throws<ArgumentNullException>(() => ThreadPoolScheduler.Instance.Schedule(42, TimeSpan.Zero, default));
  24. }
  25. [TestMethod]
  26. public void Get_Now()
  27. {
  28. var res = ThreadPoolScheduler.Instance.Now - DateTime.Now;
  29. Assert.True(res.Seconds < 1);
  30. }
  31. [TestMethod]
  32. public void ScheduleAction()
  33. {
  34. var id = Thread.CurrentThread.ManagedThreadId;
  35. var nt = ThreadPoolScheduler.Instance;
  36. var evt = new ManualResetEvent(false);
  37. nt.Schedule(() => { Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
  38. evt.WaitOne();
  39. }
  40. [TestMethod]
  41. public void ProperRooting_NoGC_SingleShot()
  42. {
  43. var cts = new CancellationTokenSource();
  44. new Thread(() =>
  45. {
  46. while (!cts.IsCancellationRequested)
  47. {
  48. Thread.Sleep(50);
  49. GC.Collect();
  50. GC.WaitForPendingFinalizers();
  51. }
  52. }).Start();
  53. var tp = ThreadPoolScheduler.Instance;
  54. var N = 100;
  55. var cd = new CountdownEvent(N);
  56. for (var i = 0; i < N; i++)
  57. {
  58. tp.Schedule(TimeSpan.FromMilliseconds(100 + i), () => { cd.Signal(); });
  59. }
  60. Assert.True(cd.Wait(TimeSpan.FromMinutes(1)));
  61. cts.Cancel();
  62. }
  63. [TestMethod]
  64. public void ProperRooting_NoGC_Periodic()
  65. {
  66. var cts = new CancellationTokenSource();
  67. new Thread(() =>
  68. {
  69. while (!cts.IsCancellationRequested)
  70. {
  71. Thread.Sleep(50);
  72. GC.Collect();
  73. GC.WaitForPendingFinalizers();
  74. }
  75. }).Start();
  76. var tp = ThreadPoolScheduler.Instance;
  77. var N = 5;
  78. var e = new ManualResetEvent(false);
  79. var n = 0;
  80. var d = tp.SchedulePeriodic(TimeSpan.FromMilliseconds(80), () => { if (Interlocked.Increment(ref n) == N) { e.Set(); } });
  81. Assert.True(e.WaitOne(TimeSpan.FromMinutes(1)));
  82. d.Dispose();
  83. cts.Cancel();
  84. }
  85. [TestMethod]
  86. public void ScheduleActionDueRelative()
  87. {
  88. var id = Thread.CurrentThread.ManagedThreadId;
  89. var nt = ThreadPoolScheduler.Instance;
  90. var evt = new ManualResetEvent(false);
  91. nt.Schedule(TimeSpan.FromSeconds(0.2), () => { Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
  92. evt.WaitOne();
  93. }
  94. [TestMethod]
  95. public void ScheduleActionDue0()
  96. {
  97. var id = Thread.CurrentThread.ManagedThreadId;
  98. var nt = ThreadPoolScheduler.Instance;
  99. var evt = new ManualResetEvent(false);
  100. nt.Schedule(TimeSpan.FromTicks(0), () => { Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
  101. evt.WaitOne();
  102. }
  103. [TestMethod]
  104. public void ScheduleActionDueAbsolute()
  105. {
  106. var id = Thread.CurrentThread.ManagedThreadId;
  107. var nt = ThreadPoolScheduler.Instance;
  108. var evt = new ManualResetEvent(false);
  109. nt.Schedule(DateTimeOffset.UtcNow + TimeSpan.FromSeconds(0.2), () => { Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
  110. evt.WaitOne();
  111. }
  112. [TestMethod]
  113. public void ScheduleActionCancel()
  114. {
  115. var id = Thread.CurrentThread.ManagedThreadId;
  116. var nt = ThreadPoolScheduler.Instance;
  117. var set = false;
  118. var d = nt.Schedule(TimeSpan.FromSeconds(0.2), () => { Assert.True(false); set = true; });
  119. d.Dispose();
  120. Thread.Sleep(400);
  121. Assert.False(set);
  122. }
  123. #if !NO_PERF
  124. #if !WINDOWS_UWP
  125. [TestMethod]
  126. public void ScheduleLongRunning_ArgumentChecking()
  127. {
  128. ReactiveAssert.Throws<ArgumentNullException>(() => ThreadPoolScheduler.Instance.ScheduleLongRunning(42, default));
  129. }
  130. [TestMethod]
  131. public void ScheduleLongRunning()
  132. {
  133. var id = Thread.CurrentThread.ManagedThreadId;
  134. var nt = ThreadPoolScheduler.Instance;
  135. var evt = new ManualResetEvent(false);
  136. nt.ScheduleLongRunning(42, (x, cancel) => { Assert.NotEqual(id, Thread.CurrentThread.ManagedThreadId); evt.Set(); });
  137. evt.WaitOne();
  138. }
  139. [TestMethod]
  140. public void ScheduleLongRunningCancel()
  141. {
  142. var nt = ThreadPoolScheduler.Instance;
  143. var started = new ManualResetEvent(false);
  144. var stopped = new ManualResetEvent(false);
  145. var n = 0;
  146. var d = nt.ScheduleLongRunning(42, (x, cancel) =>
  147. {
  148. for (n = 0; !cancel.IsDisposed; n++)
  149. {
  150. if (n == 10)
  151. {
  152. started.Set();
  153. }
  154. }
  155. stopped.Set();
  156. });
  157. started.WaitOne();
  158. d.Dispose();
  159. stopped.WaitOne();
  160. Assert.True(n >= 10);
  161. }
  162. #endif
  163. [TestMethod]
  164. public void Stopwatch()
  165. {
  166. var nt = ThreadPoolScheduler.Instance;
  167. var sw = nt.StartStopwatch();
  168. var s0 = sw.Elapsed.Ticks;
  169. Thread.Sleep(10);
  170. var s1 = sw.Elapsed.Ticks;
  171. Assert.True(s1 > s0);
  172. }
  173. [TestMethod]
  174. public void Periodic_ArgumentChecking()
  175. {
  176. ReactiveAssert.Throws<ArgumentNullException>(() => ThreadPoolScheduler.Instance.SchedulePeriodic(0, TimeSpan.FromSeconds(1), null));
  177. ReactiveAssert.Throws<ArgumentOutOfRangeException>(() => ThreadPoolScheduler.Instance.SchedulePeriodic(0, TimeSpan.FromSeconds(-1), _ => _));
  178. }
  179. [TestMethod]
  180. public void Periodic_Regular()
  181. {
  182. Periodic_Impl(TimeSpan.FromMilliseconds(25));
  183. }
  184. #if !WINDOWS_UWP
  185. [TestMethod]
  186. public void Periodic_Zero()
  187. {
  188. Periodic_Impl(TimeSpan.Zero);
  189. }
  190. #endif
  191. private void Periodic_Impl(TimeSpan period)
  192. {
  193. var gate = new object();
  194. var n = 0;
  195. var e = new ManualResetEvent(false);
  196. var lst = new List<int>();
  197. var d = ThreadPoolScheduler.Instance.SchedulePeriodic(0, period, x =>
  198. {
  199. lock (gate)
  200. {
  201. if (n++ == 10)
  202. {
  203. e.Set();
  204. }
  205. }
  206. lst.Add(x);
  207. return x + 1;
  208. });
  209. e.WaitOne();
  210. d.Dispose();
  211. var m = default(int);
  212. var k = default(int);
  213. var i = 0;
  214. do
  215. {
  216. lock (gate)
  217. {
  218. m = n;
  219. }
  220. Thread.Sleep(50);
  221. lock (gate)
  222. {
  223. k = n;
  224. }
  225. } while (m != k && i++ < 10); // Wait for Dispose to reach the timer; should be almost instantaneous due to nop'ing out of the action.
  226. Assert.NotEqual(10, i);
  227. var res = lst.ToArray();
  228. Assert.True(res.Length >= 10);
  229. Assert.True(res.Take(10).SequenceEqual(Enumerable.Range(0, 10)));
  230. }
  231. [TestMethod]
  232. public void Periodic_NonReentrant()
  233. {
  234. var n = 0;
  235. var fail = false;
  236. var d = ThreadPoolScheduler.Instance.SchedulePeriodic(0, TimeSpan.FromMilliseconds(50), x =>
  237. {
  238. try
  239. {
  240. if (Interlocked.Increment(ref n) > 1) // Without an AsyncLock this would fail.
  241. {
  242. fail = true;
  243. }
  244. Thread.Sleep(100);
  245. return x + 1;
  246. }
  247. finally
  248. {
  249. Interlocked.Decrement(ref n);
  250. }
  251. });
  252. Thread.Sleep(500);
  253. d.Dispose();
  254. Assert.False(fail);
  255. }
  256. #endif
  257. #if DESKTOPCLR
  258. [TestCategory("SkipCI")]
  259. [TestMethod]
  260. public void No_ThreadPool_Starvation_Dispose()
  261. {
  262. ThreadPool.GetAvailableThreads(out var bwt, out var bio);
  263. var N = Environment.ProcessorCount * 2;
  264. for (var i = 0; i < N; i++)
  265. {
  266. var e = new ManualResetEvent(false);
  267. var f = new ManualResetEvent(false);
  268. var d = ThreadPoolScheduler.Instance.Schedule(TimeSpan.FromMilliseconds(1), () => { e.Set(); f.WaitOne(); });
  269. e.WaitOne();
  270. d.Dispose();
  271. f.Set();
  272. }
  273. ThreadPool.GetAvailableThreads(out var ewt, out var eio);
  274. Assert.False(bwt - ewt >= N);
  275. }
  276. #endif
  277. }
  278. }
  279. #endif