public void Execute(string[] args) { Options options = new Options(args); int threadsCount = options.ThreadsCount > 0 ? options.ThreadsCount : Environment.ProcessorCount; _loopsPerThread = options.MegaLoops * 1000000L; if (threadsCount == 1) { Burn(); } else { _loopsPerThread /= threadsCount; _gateEvent = new ManualResetEvent(false); Thread[] threads = new Thread[threadsCount]; for (int i = 0; i < threadsCount; i++) { var thread = new Thread(Burn); thread.IsBackground = true; thread.Start(); threads[i] = thread; } _gateEvent.Set(); foreach (var thread in threads) thread.Join(); } }
public static int Main() { Thread t1 = new Thread(new ThreadStart (MultiThreadExceptionTest.ThreadStart1)); t1.Name = "Thread 1"; Thread.Sleep (100); t1.Start(); Thread.Sleep (200); t1.Abort ("STATETEST"); t1.Join (); Console.WriteLine ("Result: " + result); if (result != 27) return 1; return 0; }
static void Main(string[] args) { int [] mas = {5,15}; ThreadManipulator Manipulator = new ThreadManipulator(); Thread Thread_AddingOne1 = new Thread(Manipulator.AddingOne); Thread Thread_AddingOne2 = new Thread(Manipulator.AddingOne); Thread Thread_AddingCustomValue = new Thread(Manipulator.AddingCustomValue); Thread Thread_Stop = new Thread(Manipulator.Stop); Thread_Stop.IsBackground = true; Console.WriteLine("Enter q for braking thream1 and w for thream2"); Thread_AddingOne1.Start(10); Thread_AddingOne2.Start(20); Thread_AddingCustomValue.Start(mas); Thread_Stop.Start(); Thread_AddingOne1.Join(); Thread_AddingOne2.Join(); Thread_AddingCustomValue.Join(); Thread_Stop.Join(); Console.ReadKey(); }
public void TestConcurrentQueueDeclare() { string x = GenerateExchangeName(); Random rnd = new Random(); List<Thread> ts = new List<Thread>(); System.NotSupportedException nse = null; for(int i = 0; i < 256; i++) { Thread t = new Thread(() => { try { // sleep for a random amount of time to increase the chances // of thread interleaving. MK. Thread.Sleep(rnd.Next(5, 500)); Model.ExchangeDeclare(x, "fanout", false, false, null); } catch (System.NotSupportedException e) { nse = e; } }); ts.Add(t); t.Start(); } foreach (Thread t in ts) { t.Join(); } Assert.IsNotNull(nse); Model.ExchangeDelete(x); }
/* * Reads all INFATI data and fills out all possible fields in the database */ static void UpdateDatabaseThreaded() { List<Worker> workerPool = new List<Worker>(); for (Int16 i = 1; i <= 1; i++) { workerPool.Add(new Worker(1, i)); } /* for (Int16 i = 12; i <= 20; i++) { workerPool.Add(new Worker(2, i)); } */ List<Thread> threads = new List<Thread>(); foreach (Worker worker in workerPool) { Thread thread = new Thread(new ThreadStart(worker.Start)); thread.Start(); threads.Add(thread); } foreach (var thread in threads) { thread.Join(); } Console.WriteLine("All threads ended"); }
static void RunWithTimeout(Action entryPoint, int timeout) { Thread thread = null; try { thread = new Thread(() => entryPoint()) { IsBackground = true }; if (thread != null) { thread.Start(); if(thread.IsAlive) thread.Join(timeout); } } catch (Exception ex) { ddbs.WriteErrorMessage(ddbs.ConnectionString, 0, null, "ошибка запуска задания " + ex.Message,-1); } finally { if (thread != null) thread.Abort(); if (thread != null) thread.Join(3000); if (thread != null) thread.Interrupt(); if (thread != null) GC.SuppressFinalize(thread); }; thread = null; }
public override void FolderFinishedHandler(Item item) { try { m_thread = new Thread(this.RetreiveData); m_thread.Name = "Tree Thread"; m_thread.Start(); m_thread.Join(); m_tree.Dispatcher.Invoke(() => { if (m_itemsStack.Peek().Header.ToString() == item.Name) { m_itemsStack.Pop(); } else { throw new Exception(string.Format("invalid element structure {0} != {1}", m_itemsStack.Peek(), item.Id)); } }); } catch (Exception exc) { m_thread.Abort(); m_thread.Join(); OnExceptionOccured(exc.Message); } }
static void Main() { var clock = new Thread(() => { for (int i = 0; i < 10; i++) { Console.WriteLine(i); Thread.Sleep(500); } }) { IsBackground = true }; // --- BACKGROUND THREAD EXPLANATION --- // Case 1 -- START clock.Start(); // Result: It never prints anything, i.e. Background threads can't keep a // process alive until it exits. // Case 1 -- END // Case 2 -- START clock.Start(); Thread.Sleep(2000); // Result: Prints four times, i.e. 0\n1\n2\n3 // Case 2 -- END // Case 3 -- START clock.Start(); clock.Join(); // Result: Prints all values, because the foreground thread (in Main method) // waits for the end of the execution of the clock thread with a help of // 'Join' method // Case 3 -- END // --- BACKGROUND THREAD EXPLANATION END --- // --- FOREGROUND THREAD EXPLANATION --- clock.IsBackground = false; // Case 1 -- START clock.Start(); // Result: Prints all values, because the foreground thread can keep a // process alive until it exits. All new threads are foreground by default // Case 1 -- END // Case 2 -- START clock.Start(); Thread.Sleep(2000); // Result: Prints all values. // Case 2 -- END // Case 3 -- START clock.Start(); clock.Join(); // Result: Prints all values. // Case 3 -- END // --- FOREGROUND THREAD EXPLANATION END --- }
public void should_wait_for_completion() { var thread = new Thread(() => _defaultCompletionCallback.WaitForCompletion()); thread.Start(); Assert.False(thread.Join(300)); _defaultCompletionCallback.ExecuteCallback(new CompletionAcknowledgementMessage(Guid.NewGuid(),"test", true, null)); Assert.IsTrue(thread.Join(300)); }
/// <summary> /// Attempts to terminate the passed in thread /// </summary> /// <param name="workerThread">The worker thread.</param> /// <param name="timeout">The timeout.</param> /// <returns></returns> public bool AttemptToTerminate(Thread workerThread, TimeSpan? timeout) { if (workerThread == null || !workerThread.IsAlive) return true; //if the thread is null or not alive, its terminated if (timeout.HasValue) { return workerThread.Join(timeout.Value); } workerThread.Join(); return true; }
/// <summary> /// Returns token (requires user input) /// </summary> /// <returns></returns> public static AuthenticationResult GetToken(string authEndpoint, string tenant, string clientId) { var adalWinFormType = typeof(WebBrowserNavigateErrorEventArgs); Trace.WriteLine("Getting a random type from \'Microsoft.IdentityModel.Clients.ActiveDirectory.WindowsForms\' to force it be deployed by mstest"); AuthenticationResult result = null; var thread = new Thread(() => { try { var context = new AuthenticationContext(Path.Combine(authEndpoint, tenant)); result = context.AcquireToken( resource: "https://management.core.windows.net/", clientId: clientId, redirectUri: new Uri("urn:ietf:wg:oauth:2.0:oob"), promptBehavior: PromptBehavior.Auto); } catch (Exception threadEx) { Console.WriteLine(threadEx.Message); } }); thread.SetApartmentState(ApartmentState.STA); thread.Name = "AcquireTokenThread"; thread.Start(); thread.Join(); return result; }
//------------------------------------------------------------------------------------------------------------------------ public void Deinitialize() { lock (this) { try { //close socket #if NETFX try { _sock?.Disconnect(false); } catch { } try { _sock?.Close(); } catch { } #endif try { _sock?.Dispose(); } catch { } _sock = null; //stop tasks IsRunning = false; #if NETFX DiscoveryTask?.Join(200); BroadcastTask?.Join(200); #elif UNIVERSAL DiscoveryTask?.Wait(200); BroadcastTask?.Wait(200); #endif DiscoveryTask = null; BroadcastTask = null; } catch (Exception ex) { DebugEx.Assert(ex); } } }
public void Should_be_able_to_block_calling_thread_until_collection_is_empty() { IPendingWorkCollection<int> pendingWorkCollection = CreatePendingWorkCollection(); pendingWorkCollection.Send(1); pendingWorkCollection.Send(1); Assert.That(pendingWorkCollection.Count, Is.EqualTo(2)); ThreadStart action = () => { Thread.Sleep(60); pendingWorkCollection.Retrieve(CancellationToken.None); Thread.Sleep(60); }; Thread thread1 = new Thread(action); Thread thread2 = new Thread(action); thread1.Start(); thread2.Start(); pendingWorkCollection.Wait(CancellationToken.None); Assert.That(pendingWorkCollection.Count, Is.EqualTo(0)); thread1.Join(); thread2.Join(); }
private void btnArrays_Click(object sender, EventArgs e) { Thread t1 = new Thread(rellenaArr1); Thread t2 = new Thread(rellenaArr2); t1.Start(); t2.Start(); t1.Join(); t2.Join(); Thread t3 = new Thread(circularArray); t3.Priority = ThreadPriority.AboveNormal; t3.Start(); poolThread[0] = new Thread(intercambiarImpar); poolThread[1] = new Thread(intercambiarImpar); poolThread[2] = new Thread(intercambiarImpar); poolThread[0].Start(); poolThread[1].Start(); poolThread[2].Start(); }
public void Start() { try { var inputFileInfo = new FileInfo(_inputPath); using (var inputFileStream = inputFileInfo.OpenRead()) { _reader = CreateReader(inputFileStream); _writer = new Thread(Write); _writer.Start(); for (int i = 0; i < _threadsCount; i++) { var thread = new Thread(ReadAndProcess); thread.Start(); _threads.Add(thread); } _threads?.ForEach(th => th.Join()); ReadFinish(); _writer?.Join(); } } catch { new Thread(() => { _eventHandler.Invoke("Произошла ошибка при запуске процесса!"); }).Start(); } }
public string StopRecording(String recordingDate, bool download) { camera.CloseShutter(); Video video = camera.Contents().VideosAsync().Result.LastOrDefault(); if (download) { // Create the thread object. This does not start the thread. GoProDownloader downloader = new GoProDownloader(camera, recordingDate); Thread downloaderThread = new Thread(downloader.Download); // Start the worker thread. downloaderThread.Start(); Console.WriteLine("main thread: Starting worker thread..."); // Loop until worker thread activates. while (!downloaderThread.IsAlive) { ; } downloaderThread.Join(); if (!downloader.successful) { throw new Exception("Unsuccessful download"); } } return video.Name; }
public void Stop() { _isCheckPortState = false; _portStateThread?.Join(); Disconnect(); }
public void Dispose() { Stop(); _pollerThread?.Join(); _client?.Dispose(); }
protected virtual void Dispose(bool disposing) { if (!disposing) { return; } lock (_lock) { if (_isRunning) { _refereceCount--; if (_refereceCount == 0) { _isRunning = false; _worker?.Join(); SDL_Quit(); OnJoyStickConnected = null; OnJoystickDisconnected = null; } } } }
private void ThisWindow_Closing(object sender, System.ComponentModel.CancelEventArgs e) { _serialStop = true; _serialThread?.Join(); Helpers.Serialize(_config, ConfigFile); }
public void Test_Transaction_ReleaseWhenFailToStart() { var blockingStream = new BlockingStream(); var db = new LiteDatabase(blockingStream) { Timeout = TimeSpan.FromSeconds(1) }; Thread lockerThread = null; try { lockerThread = new Thread(() => { db.GetCollection <Person>().Insert(new Person()); blockingStream.ShouldBlock = true; db.Checkpoint(); db.Dispose(); }); lockerThread.Start(); blockingStream.Blocked.WaitOne(1000).Should().BeTrue(); Assert.Throws <LiteException>(() => db.GetCollection <Person>().Insert(new Person())).Message.Should().Contain("timeout"); Assert.Throws <LiteException>(() => db.GetCollection <Person>().Insert(new Person())).Message.Should().Contain("timeout"); } finally { blockingStream.ShouldUnblock.Set(); lockerThread?.Join(); } }
private void Stop() { _cancellationTokenSource?.Cancel(); _thread?.Join(); _thread = null; }
public void Dispose() { _runTransactions = false; _waitHandle.Set(); _txMergingThread?.Join(); _waitHandle.Dispose(); }
public void Stop() { _clientCancelled = true; _clientThread?.Join(); _clientThread = null; EventManager.Instance.onClientStopped.Invoke(); }
public static void Main(String[] Args) { QConnection q = new QBasicConnection(Args.Length >= 1 ? Args[0] : "localhost", Args.Length >= 2 ? int.Parse(Args[1]) : 5001, null, null); try { q.Open(); Console.WriteLine("conn: " + q + " protocol: " + q.ProtocolVersion); Console.WriteLine("WARNING: this application overwrites: .u.upd function on q process"); Console.WriteLine("Press <ENTER> to close application"); q.Sync(".u.upd:{[x;y] show (x;y)};"); PublisherTask pt = new PublisherTask(q); Thread workerThread = new Thread(pt.Run); workerThread.Start(); Console.ReadLine(); pt.Stop(); workerThread.Join(); } catch (Exception e) { Console.WriteLine("`" + e.Message); } finally { q.Close(); } }
public void Stop() { isRuning = false; thread?.Join(); logRaderWriter?.Close(); logTelWriter?.Close(); }
public void IfResponseIsBlockedThenNextCommandWillWrite() { var b1 = new RedisInlineCommandBuilder(); var b2 = new RedisInlineCommandBuilder(); b1.SetCommand(":1"); b2.SetCommand(":2"); var loopbackConnection = new LoopbackConnection(); var executor = new PipelinedCommandExecutor(loopbackConnection); var t1 = new Thread(() => executor.ExecuteCommand(b1)); var t2 = new Thread(() => executor.ExecuteCommand(b2)); t1.Start(); t2.Start(); Thread.Sleep(100); var str = Encoding.ASCII.GetString(loopbackConnection.GetBuffer()); loopbackConnection.WriteResponce(); t1.Join(); t2.Join(); executor.Dispose(); Assert.That(str, Is.EqualTo(":1\r\n:2\r\n")); }
public void Dispose() { _cancellationTokenSource?.Cancel(); _cancellationTokenSource.Dispose(); _readerThread?.Join(); _udpClient?.Dispose(); }
public static string ShowFileDialogForExecutable(string fileName) { // Switch to default desktop if (SebWindowsClientMain.sessionCreateNewDesktop) SEBDesktopController.Show(SEBClientInfo.OriginalDesktop.DesktopName); // Create the thread object. This does not start the thread. Worker workerObject = new Worker(); Thread workerThread = new Thread(workerObject.ShowFileDialogInThread); workerThread.SetApartmentState(ApartmentState.STA); workerObject.fileNameExecutable = fileName; // Start the worker thread. workerThread.Start(); // Loop until worker thread activates. while (!workerThread.IsAlive) ; // Use the Join method to block the current thread // until the object's thread terminates. workerThread.Join(); // Switch to new desktop if (SebWindowsClientMain.sessionCreateNewDesktop) SEBDesktopController.Show(SEBClientInfo.SEBNewlDesktop.DesktopName); return workerObject.fileNameFullPath; }
/// <summary> /// Stops the accepting of new Connections. /// </summary> void StopListening() { tcpListener?.Stop(); tcpListener = null; acceptConnectionsThread?.Join(); acceptConnectionsThread = null; }
public void Close() { mThread?.Abort(); mThread?.Join(); mThread = null; System.Diagnostics.Debug.Assert(mSocketTarget == null); }
public void Stop() { var thread = _thread; if (thread == null) { return; } _thread = null; Thread alternateThread = null; if (_useAlternativeExchange) { alternateThread = _alternateThread; _alternateThread = null; } _cancellationTokenSource?.Cancel(); thread.Join(); if (_useAlternativeExchange) { alternateThread?.Join(); } _cancellationTokenSource?.Dispose(); }
public void Dispose() { if (_connectionTimer != null) { _connectionTimer.Dispose(); _connectionTimer = null; } _eventWait.Set(); _requestHandlerThread?.Join(); foreach (var ds in DataSources.Values) { ds.Disconnect(); } /* * if (DataSources.ContainsKey("Interactive Brokers")) * { * ((IB)DataSources["Interactive Brokers"]).Dispose(); * } */ if (DataSources.ContainsKey("ContinuousFuturesBroker")) { ((IContinuousFuturesBroker)DataSources["ContinuousFuturesBroker"]).Dispose(); } }
public void Dispose() { if (_connectionTimer != null) { _connectionTimer.Dispose(); _connectionTimer = null; } if (!_requestQueue.Reader.Completion.IsCompleted) { _requestQueue.Writer.Complete(); } _requestHandlerThread?.Join(); foreach (var ds in DataSources.Values) { ds.Disconnect(); } /* * if (DataSources.ContainsKey("Interactive Brokers")) * { * ((IB)DataSources["Interactive Brokers"]).Dispose(); * } */ if (DataSources.ContainsKey("ContinuousFuturesBroker")) { ((IContinuousFuturesBroker)DataSources["ContinuousFuturesBroker"]).Dispose(); } }
protected override void OnFormClosing(FormClosingEventArgs e) { base.OnFormClosing(e); exit = true; componentsUpdater?.Join(); }
public virtual void Dispose() { lock (_disposeLock) { if (_disposed) { return; } _disposed = true; } _inactivityWatcherThread?.Join(); _inactivityWatcherThread = null; DisposeOfManagedConnections(); DeleteTemporaryDataArtifacts(); var handlers = Disposed; try { handlers.Invoke(this, _autoDisposeInformation ?? new TempDbDisposedEventArgs( "TempDb instance was disposed", false, _timeout, _absoluteLifespan )); } catch { // suppress } }
public void Execute() { this.Config.LiveReloadScript = "<script type=\"text/javascript\" src=\"http://livejs.com/live.js\"></script>"; var thread = new Thread(RenderThread); try { using (var documentsWatcher = this.CreateWatcher(this.Config.DocumentsPath)) using (var filesWatcher = this.CreateWatcher(this.Config.FilesPath)) using (var layoutsWatcher = this.CreateWatcher(this.Config.LayoutsPath)) { documentsWatcher.EnableRaisingEvents = true; filesWatcher.EnableRaisingEvents = true; layoutsWatcher.EnableRaisingEvents = true; thread.Start(this); var serve = new RunServeCommand(); serve.Config = this.Config; serve.Execute(); } } finally { this.Waits[(int)EventTypes.EndWatch].Set(); thread.Join(); } }
protected override void Destroy() { commands.Enqueue(new SchedulerAsyncCommand(SchedulerAsyncCommandEnum.Dispose)); workerThread?.Join(); workerThread = null; }
private int Run() { int iRet = -1; Console.WriteLine("Abandoning only one Mutex in array " + "with other WaitHandles, signaling other mutexes"); CreateArray(64); Thread t = new Thread(new ThreadStart(this.AbandonOneAndRelease)); t.Start(); t.Join(); int i = -1; try { Console.WriteLine("Waiting..."); i = WaitHandle.WaitAny(wh); Console.WriteLine("WaitAny did not throw AbandonedMutexExcpetion"); } catch(AbandonedMutexException) { // Expected iRet = 100; } catch(Exception e) { Console.WriteLine("Unexpected exception thrown: " + e.ToString()); } Console.WriteLine(100 == iRet ? "Test Passed" : "Test Failed"); return iRet; }
public void CacheMinimap(MapPreview preview) { bool launchPreviewLoaderThread; lock (syncRoot) { generateMinimap.Enqueue(preview); launchPreviewLoaderThread = previewLoaderThreadShutDown; previewLoaderThreadShutDown = false; } if (launchPreviewLoaderThread) { Game.RunAfterTick(() => { // Wait for any existing thread to exit before starting a new one. previewLoaderThread?.Join(); previewLoaderThread = new Thread(LoadAsyncInternal) { Name = "Map Preview Loader", IsBackground = true }; previewLoaderThread.Start(); }); } }
private void btnStop_Click(object sender, EventArgs e) { _isEnd = true; progressBar.MarqueeAnimationSpeed = 0; cbYahoo.Enabled = true; btnStop.Enabled = false; btnPause.Enabled = false; checkerThread?.Abort(); btnStop.Text = "Stopping..."; stopwatch.Stop(); timer.Stop(); timer.Enabled = false; checkerThread?.Join(); btnStart.Enabled = true; btnAddMail.Enabled = true; btnDelete.Enabled = true; tbMail.Enabled = true; menuStrip.Enabled = true; btnStop.Text = "Stop"; if (mails.Count > 0) { btnExport.Enabled = true; } tbFind.Enabled = true; }
public void Dispose() { _runTransactions = false; // once all the concurrent transactions are done, this will signal the event, preventing // it from adding additional operations var done = _concurrentOperations.Signal(); _waitHandle.Set(); _txMergingThread?.Join(); _waitHandle.Dispose(); // make sure that the queue is empty and there are no pending // transactions waiting. // this is probably a bit more aggresive that what is needed, but it is better // to be cautious and slower on rare dispose than hang while (done == false) { try { done = _concurrentOperations.Signal(); } catch (InvalidOperationException) { break; } } while (_operations.TryDequeue(out MergedTransactionCommand result)) { result.TaskCompletionSource.TrySetCanceled(); } }
public void RegisterClassWithoutDependencyMethod_Fail() { var c = new Container(); c.RegisterType<EmptyClass>().AsSingleton(); c.RegisterType<SampleClassWithoutClassDependencyMethod>(); SampleClassWithoutClassDependencyMethod sampleClass = null; Exception exception = null; var thread = new Thread(() => { try { sampleClass = c.Resolve<SampleClassWithoutClassDependencyMethod>(ResolveKind.FullEmitFunction); } catch (Exception ex) { exception = ex; } }); thread.Start(); thread.Join(); if (exception != null) { throw exception; } Assert.IsNotNull(sampleClass); Assert.IsNull(sampleClass.EmptyClass); }
private void ReleaseResources(bool keepSounds) { for (int i = 0; i < playingChannels.Length; i++) { lock (playingChannels[i]) { for (int j = 0; j < playingChannels[i].Length; j++) { if (playingChannels[i][j] != null) { playingChannels[i][j].Dispose(); } } } } streamingThread?.Join(); for (int i = loadedSounds.Count - 1; i >= 0; i--) { if (keepSounds) { loadedSounds[i].DeleteALBuffers(); } else { loadedSounds[i].Dispose(); } } sourcePools[(int)SourcePoolIndex.Default]?.Dispose(); sourcePools[(int)SourcePoolIndex.Voice]?.Dispose(); SoundBuffers.ClearPool(); }
static void Main(string[] args) { UdpNotifierCacheDependency dependency = new UdpNotifierCacheDependency(); ObjectCacheQueue.Instance.Add("ClientData", string.Empty, dependency); object oldCacheData = ObjectCacheQueue.Instance["ClientData"]; Console.Title = "UdpCacheDependency测试Chat"; Console.WriteLine("Please input text..."); Thread thread = new Thread((ThreadStart)MonitorThread); thread.Start(); string cmd = Console.ReadLine(); while (cmd.ToLower() != "exit") { if (cmd.IsNotEmpty()) { if (cmd.ToLower() == "send100") SendOneHundredMessages(); else SendOneMessage(cmd); } cmd = Console.ReadLine(); } thread.Abort(); thread.Join(); }
public override void Dispose() { Instance = null; capturing = false; captureThread?.Join(); captureThread = null; }
private static string ScreenCaptureInStaThread(string received, Action screenCapture) { Exception caught = null; var t = new Thread(() => { try { screenCapture(); } catch (Exception e) { caught = e; } }); t.SetApartmentState(ApartmentState.STA); //Many WPF UI elements need to be created inside STA t.Start(); t.Join(); if (caught != null) { throw new Exception("Creating window failed.", caught); } return received; }
public void StopWork() { IsWorking = false; IsWorkPause = false; _workThread?.Join(); _workThread = null; }
public void runAction(ActionSequence<NaoSkeleton> action) { Executor executor = new Executor(action, nao, FPS); Thread t = new Thread(new ThreadStart(executor.run)); t.Start(); t.Join(); }
protected void Page_Load(object sender, EventArgs e) { try { Session["MainUrl"].ToString(); } catch (NullReferenceException) { Response.Redirect("~/"); return; } Debug.WriteLine(">>>> CodeQuality"); this.sitemap = (List<string>)Session["selectedSites"]; var ths = new ThreadStart(TestCodeQuality); var th = new Thread(ths); th.Start(); th.Join(); var sb = new System.Text.StringBuilder(); CodeQualitySession.RenderControl(new System.Web.UI.HtmlTextWriter(new System.IO.StringWriter(sb))); string htmlstring = sb.ToString(); Session["CodeQuality"] = htmlstring; }
public void ShouldCallExceptionHandlerOnUncaughtException() { var ex = new Exception(); var exceptionHandlerMock = new Mock<IExceptionHandler<object>>(); _batchEventProcessor.SetExceptionHandler(exceptionHandlerMock.Object); _batchHandlerMock.Setup(bh => bh.OnEvent(_ringBuffer[0], 0, true)) .Throws(ex); // OnNext raises an expcetion exceptionHandlerMock.Setup(bh => bh.HandleEventException(ex, 0, _ringBuffer[0])) .Callback(() => _countDownEvent.Signal()); // Exception should be handled here and signal the CDE var thread = new Thread(_batchEventProcessor.Run); thread.Start(); _ringBuffer.Publish(_ringBuffer.Next()); _countDownEvent.Wait(50); _batchEventProcessor.Halt(); thread.Join(); _batchHandlerMock.VerifyAll(); exceptionHandlerMock.VerifyAll(); }
private void Run(ThreadStart userDelegate, ApartmentState apartmentState) { lastException = null; Thread thread = new Thread( delegate() { #if !DEBUG try { #endif userDelegate.Invoke(); #if !DEBUG } catch (Exception e) { lastException = e; } #endif }); thread.SetApartmentState(apartmentState); thread.Start(); thread.Join(); if (ExceptionWasThrown()) ThrowExceptionPreservingStack(lastException); }
private void rellenaArrays_Click(object sender, EventArgs e) { Thread t1 = new Thread(rellena); Thread t2 = new Thread(rellena); Thread t3 = new Thread(rellena); Thread t4 = new Thread(rellena); Thread t5 = new Thread(rellena); t1.Start(); t2.Start(); t3.Start(); t4.Start(); t5.Start(); //Thread.Sleep(10000); //Esperar fin ejecución de todos los threads t1.Join(); t2.Join(); t3.Join(); t4.Join(); t5.Join(); //ver array for (int i = 0; i < 1000; i++) { Console.WriteLine(i + ".- " + numeros[i]); } }
public static void Main(string[] args) { // Create the thread object. This does not start the thread. Worker workerObject = new Worker(); Thread workerThread = new Thread(workerObject.DoWork); // Start the worker thread. workerThread.Start(); Console.WriteLine("main thread: Starting worker thread..."); // Loop until worker thread activates. while (!workerThread.IsAlive); // Put the main thread to sleep for 1 millisecond to // allow the worker thread to do some work: Thread.Sleep(1); // Request that the worker thread stop itself: workerObject.RequestStop(); // Use the Join method to block the current thread // until the object's thread terminates. workerThread.Join(); Console.WriteLine("main thread: Worker thread has terminated."); }
private void OnDestroy() { connected = false; client?.Close(); lookUpper?.Close(); clientThread?.Join(); }
public void CabinetMultithread() { this.multithreadExceptions = new List<Exception>(); const int threadCount = 10; IList<Thread> threads = new List<Thread>(threadCount); for (int i = 0; i < threadCount; i++) { Thread thread = new Thread(new ThreadStart(this.CabinetMultithreadWorker)); thread.Name = "CabinetMultithreadWorker_" + i; threads.Add(thread); } foreach (Thread thread in threads) { thread.Start(); } foreach (Thread thread in threads) { thread.Join(); } foreach (Exception ex in this.multithreadExceptions) { Console.WriteLine(); Console.WriteLine(ex); } Assert.AreEqual<int>(0, this.multithreadExceptions.Count); }
private void Cleanup() { isRunning = false; renderThread?.Join(); tripleBuffer?.Dispose(); stringFormat?.Dispose(); fontCategoryNames?.Dispose(); fontTeamNames?.Dispose(); fontScores?.Dispose(); penGridLines?.Dispose(); brushTeamNames?.Dispose(); brushScores?.Dispose(); bitmapScores?.Dispose(); if (brushesFireworks != null) { foreach (Brush brush in brushesFireworks) { brush?.Dispose(); } } if (brushesCategories != null) { foreach (Brush brush in brushesCategories) { brush?.Dispose(); } } }
// Выделение связных областей рекурсивным алгоритмом unsafe private void AllocationOfConnectedDomains_recursively() { int maxStackSize = 100000000; Bitmap tmp = bitmap.Clone(new Rectangle(0, 0, bitmap.Width, bitmap.Height), bitmap.PixelFormat); Thread t = new Thread(() => { UnsafeBitmap src = new UnsafeBitmap(tmp); Byte* pBaseSrc = src.LockBitmap(); int L = 1; for (int y = 0; y < height; y++) { for (int x = 0; x < width; x++) { FillLabels(pBaseSrc, x, y, L++); } } src.UnlockBitmap(); }, maxStackSize); t.Start(); t.Join(); objectsCount = RenumberDomains(); }
public void Shutdown() { Initialized = false; udp?.Close(); thread?.Join(); thread?.Abort(); }
public void Disconnect() { // only if started if (Connecting || Connected) { //destroy list. //Logger.Log("Disconnected"); // close client client.Close(); // wait until thread finished. this is the only way to guarantee // that we can call Connect() again immediately after Disconnect receiveThread?.Join(); // clear send queues. no need to hold on to them. // (unlike receiveQueue, which is still needed to process the // latest Disconnected message, etc.) sendQueue.Clear(); // let go of this one completely. the thread ended, no one uses // it anymore and this way Connected is false again immediately. client = null; } }