private void OnDestroy() { destroyed = true; if (privilegeRequester != null) { privilegeRequester.OnPrivilegesDone -= handlePrivilegesDone; } closeClient(); ssdpRequestThread?.Interrupt(); ssdpListenThread?.Interrupt(); connectionThread?.Interrupt(); receiveThread?.Interrupt(); }
void InternalConnect() { try { client.Connect(IP, Port); _Connecting = false; client.NoDelay = NoDelay; client.SendTimeout = SendTimeout; sendThread = new Thread(() => { SendLoop(this); }); sendThread.IsBackground = true; sendThread.Start(); ReceiveLoop(this); } catch (SocketException exception) { Log.WriteNow("Client Recv: failed to connect to ip=" + IP + " port=" + Port + " reason=" + exception); OnDisconnect?.Invoke(); } catch (ThreadInterruptedException) { } catch (ThreadAbortException) { } catch (Exception exception) { Log.WriteNow("Client Recv Exception: " + exception); } sendThread?.Interrupt(); _Connecting = false; client?.Close(); }
/// <summary> /// Disconnects from the game server. /// </summary> public void Disconnect() { if (!isConnecting && !IsConnected) { Debug.Log("Already disconnected..."); return; } Debug.Log("Disconnecting..."); sslStream?.Close(); client?.Close(); // Ensure the receive packets thread exits, and in turn // that the send packet thread exits as well receivePacketsThread?.Interrupt(); // We interrupted the receive Thread, so we can't guarantee that // connecting was reset. let's do it manually. isConnecting = false; // No need to continue sending because we're disconnecting. // The receive queue though, may still have packets that we // want to process. sendPacketsQueue.Clear(); client = null; }
public void Disconnect() { // only if started if (Connecting || Connected) { // close client client.Close(); // wait until thread finished. this is the only way to guarantee // that we can call Connect() again immediately after Disconnect // -> calling .Join would sometimes wait forever, e.g. when // calling Disconnect while trying to connect to a dead end receiveThread?.Interrupt(); // we interrupted the receive Thread, so we can't guarantee that // connecting was reset. let's do it manually. _Connecting = false; // 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; } }
private void ReceiveThreadFunction(string ip, int port) { try { client.Connect(ip, port); _Connecting = false; sendThread = new Thread(() => { SendLoop(0, client, sendQueue, sendPending); }); sendThread.IsBackground = true; sendThread.Start(); ReceiveLoop(0, client, receiveQueue, MaxMessageSize); } catch (SocketException exception) { Logger.Log("Client Recv: failed to connect to ip=" + ip + " port=" + port + " reason=" + exception); receiveQueue.Enqueue(new Message(0, EventType.Disconnected, null)); } catch (Exception exception) { Logger.LogError("Client Recv Exception: " + exception); } sendThread?.Interrupt(); _Connecting = false; client.Close(); }
public void Stop() { alive = false; thread?.Interrupt(); Join(); thread = null; }
public void StopBeginReadln() { _inputReaderThread?.Interrupt(); _inputReaderThread?.Join(); _inputReaderThread = null; _readingStarted = false; }
public void Stop() { // only if started if (!Active) { return; } Logger.Log("Server: stopping..."); // stop listening to connections so that no one can connect while we // close the client connections // (might be null if we call Stop so quickly after Start that the // thread was interrupted before even creating the listener) listener?.Stop(); // kill listener thread at all costs. only way to guarantee that // .Active is immediately false after Stop. // -> calling .Join would sometimes wait forever listenerThread?.Interrupt(); listenerThread = null; // close all client connections foreach (KeyValuePair <int, ClientToken> kvp in clients) { TcpClient client = kvp.Value.client; // close the stream if not closed yet. it may have been closed // by a disconnect already, so use try/catch try { client.GetStream().Close(); } catch {} client.Close(); } // clear clients list clients.Clear(); }
// dispose all the state safely public void Dispose() { // close client client.Close(); // wait until thread finished. this is the only way to guarantee // that we can call Connect() again immediately after Disconnect // -> calling .Join would sometimes wait forever, e.g. when // calling Disconnect while trying to connect to a dead end receiveThread?.Interrupt(); // we interrupted the receive Thread, so we can't guarantee that // connecting was reset. let's do it manually. Connecting = false; // clear send pipe. no need to hold on to elements. // (unlike receiveQueue, which is still needed to process the // latest Disconnected message, etc.) sendPipe.Clear(); // IMPORTANT: DO NOT CLEAR RECEIVE PIPE. // we still want to process disconnect messages in Tick()! // let go of this client completely. the thread ended, no one uses // it anymore and this way Connected is false again immediately. client = null; }
static int Main () { lock (_lock2) { Thread t1; lock (_lock1) { t1 = new Thread (new ThreadStart(T1)); t1.Start (); Monitor.Wait (_lock1); } Thread.Sleep (100); _actions.Add ("Main: interrupting T1"); t1.Interrupt (); } #if NET_2_0 if (_actions.Count != 3) { #else if (_actions.Count != 3) { #endif Console.WriteLine ("#1: " + _actions.Count); return 1; } if ((string) _actions [0] != "T1: started") { Console.WriteLine ("#2: " + (string) _actions [0]); return 2; } if ((string) _actions [1] != "T1: trying Lock1") { Console.WriteLine ("#3: " + (string) _actions [1]); return 3; } if ((string) _actions [2] != "Main: interrupting T1") { Console.WriteLine ("#4: " + (string) _actions [2]); return 4; } return 0; } static void T1 () { _actions.Add ("T1: started"); lock (_lock1) { Monitor.Pulse (_lock1); } try { _actions.Add ("T1: trying Lock1"); lock (_lock2) { _actions.Add ("T1: got Lock1"); } } catch (Exception) { _actions.Add ("T1: interrupted"); } } }
private void OnDestroy() { closeClient(); connectionThread?.Interrupt(); ssdpListenThread?.Interrupt(); ssdpRequestThread?.Interrupt(); }
public void Dispose() { lock (simulatorLocker) { simulatorThread?.Interrupt(); simulatorThread?.Join(); } }
public void Dispose() { _running = false; _clientLoop?.Interrupt(); if (!_clientLoop.Join(1000)) { _clientLoop?.Abort(); } }
/// <summary> /// Disposes all resources. /// </summary> public void Dispose() { if (!disposed) { disposed = true; inputRefresher?.Interrupt(); inputRefresher?.Join(); } }
public void Load(string text) { lock (playLock) { if (playing && playThread != null) { interrupted = true; Stop(); GotKey(); playThread?.Interrupt(); playThread?.Join(1000); playThread?.Abort(); } } backgroundCache = null; briefingColor = 0; fullText = RemoveComments(text).Replace("\r", ""); }
// the thread function void ReceiveThreadFunction(string ip, int port) { // absolutely must wrap with try/catch, otherwise thread // exceptions are silent try { // connect (blocking) client.Connect(ip, port); _Connecting = false; // set socket options after the socket was created in Connect() // (not after the constructor because we clear the socket there) client.NoDelay = NoDelay; client.SendTimeout = SendTimeout; // start send thread only after connected sendThread = new Thread(() => { SendLoop(0, client, sendQueue, sendPending); }); sendThread.IsBackground = true; sendThread.Start(); // run the receive loop ReceiveLoop(0, client, receiveQueue, MaxMessageSize); } catch (SocketException exception) { // this happens if (for example) the ip address is correct // but there is no server running on that ip/port Logger.Log("Client Recv: failed to connect to ip=" + ip + " port=" + port + " reason=" + exception); // add 'Disconnected' event to message queue so that the caller // knows that the Connect failed. otherwise they will never know receiveQueue.Enqueue(new Message(0, EventType.Disconnected, null)); } catch (Exception exception) { // something went wrong. probably important. Logger.LogError("Client Recv Exception: " + exception); } // sendthread might be waiting on ManualResetEvent, // so let's make sure to end it if the connection // closed. // otherwise the send thread would only end if it's // actually sending data while the connection is // closed. sendThread?.Interrupt(); // Connect might have failed. thread might have been closed. // let's reset connecting state no matter what. _Connecting = false; // if we got here then we are done. ReceiveLoop cleans up already, // but we may never get there if connect fails. so let's clean up // here too. client.Close(); }
public void Dispose() { _stop = true; Robustness.Instance.SafeCall(() => { _udpClient?.Dispose(); }); Robustness.Instance.SafeCall(() => { _receiveThread?.Interrupt(); _receiveThread?.Abort(); }); }
public void Dispose() { _messages?.Dispose(); _executorThread?.Interrupt(); foreach (var m in _modules.Values) { m.Dispose(); } }
/// <summary> /// Closes the TouchPortal sockets. /// And most importantly, interrupts the foreground thread. /// </summary> /// <param name="exception"></param> public void Close(Exception exception) { _logger.LogInformation($"Closing: {exception}"); _listenerThread?.Interrupt(); _streamWriter?.Close(); _streamReader?.Close(); _touchPortalSocket?.Close(); OnDisconnect?.Invoke(exception); }
private void CancelButton_Click(object sender, EventArgs e) { backgroundThread?.Interrupt(); jobThread?.Interrupt(); backgroundThread?.Join(); jobThread?.Join(); backgroundThread = null; jobThread = null; WorkerButton.Enabled = true; }
static void KillTheThread(Thread thread) { try { thread?.Interrupt(); thread?.Abort(); thread = null; } catch (Exception e) { Debug.WriteLine(e); } }
// the thread function void ReceiveThreadFunction(string ip, int port) { // absolutely must wrap with try/catch, otherwise thread // exceptions are silent try { // connect (blocking) client.Connect(ip, port); _Connecting = false; // create send queue for this client SafeQueue <byte[]> sendQueue = new SafeQueue <byte[]>(); sendQueues[0] = sendQueue; // start send thread only after connected sendThread = new Thread(() => { SendLoop(0, client, sendQueue); }); sendThread.IsBackground = true; sendThread.Start(); // run the receive loop ReceiveLoop(0, client, receiveQueue); } catch (SocketException exception) { // this happens if (for example) the ip address is correct // but there is no server running on that ip/port Logger.Log("Client Recv: failed to connect to ip=" + ip + " port=" + port + " reason=" + exception); // add 'Disconnected' event to message queue so that the caller // knows that the Connect failed. otherwise they will never know receiveQueue.Enqueue(new Message(0, EventType.Disconnected, null)); } catch (Exception exception) { // something went wrong. probably important. Logger.LogError("Client Recv Exception: " + exception); } // try interrupting send thread after receive thread // ends, just to be sure sendThread?.Interrupt(); // Connect might have failed. thread might have been closed. // let's reset connecting state no matter what. _Connecting = false; // if we got here then we are done. ReceiveLoop cleans up already, // but we may never get there if connect fails. so let's clean up // here too. client.Close(); }
/// <summary> /// disposes client and stops threads /// </summary> public void Dispose() { Log.Verbose($"Dispose {ToString()}"); // check hasDisposed first to stop ThreadInterruptedException on lock if (hasDisposed) { return; } Log.Info($"Connection Close: {ToString()}"); lock (disposedLock) { // check hasDisposed again inside lock to make sure no other object has called this if (hasDisposed) { return; } hasDisposed = true; // stop threads first so they dont try to use disposed objects receiveThread.Interrupt(); sendThread?.Interrupt(); try { // stream stream?.Dispose(); stream = null; client.Dispose(); client = null; } catch (Exception e) { Log.Exception(e); } sendPending.Dispose(); // release all buffers in send queue while (sendQueue.TryDequeue(out ArrayBuffer buffer)) { buffer.Release(); } onDispose.Invoke(this); } }
// Coroutine to attempt fetching pre-registered server address at intervals. // Once valid address received, attempt to connect then start receiving stream. // The connection logic unfortunately cannot be easily delegated to one thread because // UnityWebRequest must be called on the main thread, necessitating a complicated // workaround. IEnumerator getServerAddress() { while (!socketConnected) { MLog("getServerAddress :: Making discovery request"); discoveryRequest = UnityWebRequest.Get("https://danielchan.io/mldiscovery/get"); yield return(discoveryRequest.SendWebRequest()); if (discoveryRequest.isNetworkError || discoveryRequest.isHttpError) { MLog("getServerAddress :: Error - " + discoveryRequest.error); } var message = discoveryRequest.downloadHandler.text; MLog("getServerAddress :: Received server address - " + message); var address = message.Split(':'); var ip = address[0]; var port = Convert.ToInt32(address[1]); if (ip.Equals("") || port < 1) { continue; } connectionAttemptFinished = false; connectionThread = new Thread(() => connectToServerBlocking(ip, port)); connectionThread.IsBackground = true; connectionThread.Start(); yield return(new WaitUntil(() => connectionAttemptFinished)); MLog("getServerAddress :: Finished connection attempt"); yield return(new WaitForSeconds(3)); } receiveThread?.Interrupt(); writeThread?.Interrupt(); receiveThread = new Thread(receiveStream); receiveThread.IsBackground = true; receiveThread.Start(); writeThread = new Thread(writeStream); writeThread.IsBackground = true; writeThread.Start(); }
public void Dispose() { SerialSendThread?.Interrupt(); SerialSendThread?.Join(); if (Port != null && Port.IsOpen) { byte[] bytes = Encoding.ASCII.GetBytes("hvpoe 1 0\r"); Port.Write(bytes, 0, bytes.Length); Thread.Sleep(200); bytes = Encoding.ASCII.GetBytes("clra\r\r"); Port.Write(bytes, 0, bytes.Length); Port.Close(); } }
/// <summary> /// Clean up any resources being used. /// </summary> /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param> protected override void Dispose(bool disposing) { // Hack to stop crash. // If we do not set ShouldUpdate to false then the component will try and access its disposed self. soupGraphicsControl.ShouldUpdate = false; if (disposing && (components != null)) { components.Dispose(); } base.Dispose(disposing); // Stops any further stat logging. _statLoggingThread?.Interrupt(); _statLoggingThread?.Join(); }
/// <summary> /// Stops the emulation of the device /// </summary> public void Stop() { if (running) { running = false; XInput.InputChanged -= XInputInputChanged; if (ForceFeedbackSupported) { controller.FeedbackReceived -= ControllerFeedbackReceived; logger.Info($"Force feedback mapping is disconnected on {ToString()}."); } xOutputInterface?.Unplug(controllerCount); logger.Info($"Emulation stopped on {ToString()}."); resetId(); thread?.Interrupt(); } }
public void Disconnect() { if (!Connecting && !Connected) { return; } client.Close(); receiveThread?.Interrupt(); _Connecting = false; sendQueue.Clear(); client = null; }
public void Stop() { serverStopped = true; // Interrupt then stop so that Exception is handled correctly acceptThread?.Interrupt(); listener?.Stop(); acceptThread = null; Log.Info("Server stopped, Closing all connections..."); // make copy so that foreach doesn't break if values are removed Connection[] connectionsCopy = connections.Values.ToArray(); foreach (Connection conn in connectionsCopy) { conn.Dispose(); } connections.Clear(); }
public void Stop() { isRunning = false; threadRecv?.Interrupt(); threadRecv = null; if (currentSocket != null) { try { currentSocket.Shutdown(SocketShutdown.Both); } catch (Exception e) { Debuger.LogWarning(e.Message + e.StackTrace); } currentSocket.Close(); currentSocket = null; } }
public void Stop() { if (!Active) { return; } Logger.Log("Server: stopping..."); listener?.Stop(); listener_thread?.Interrupt(); listener_thread = null; foreach (var kvp in clients) { var client = kvp.Value.client; try { client.GetStream().Close(); } catch {} client.Close(); } clients.Clear(); }
static void Main() { // First, set the name of the current thread so that it's easier // to view in the debugger. Thread mainThread = Thread.CurrentThread; mainThread.Name = "Main Thread"; // Create an instance of the ThreadedClass. ThreadedClass tc1 = new ThreadedClass("Thread1"); // Set the ThreadedClass's boolean wait forever flag to false. tc1.WaitIndefinitely = false; // Create the thread giving it the delegate with the // method that should be called when the thread starts. Console.WriteLine("Main - Creating first worker thread."); Thread t1 = new Thread(tc1.ThreadMethod); t1.Name = "First Worker Thread"; // Start the thread t1.Start(); Console.WriteLine ("Main - First worker thread started."); // Sleep for a few seconds. Console.WriteLine("Main - Sleeping for 5 seconds."); Thread.Sleep (5000); // Start another thread ThreadedClass tc2 = new ThreadedClass("Thread2"); tc2.WaitIndefinitely = true; Console.WriteLine ("Main - Creating second worker thread."); Thread t2 = new Thread(tc2.ThreadMethod); t2.Name = "Second Worker Thread"; t2.Start(); Console.WriteLine ("Main - Second worker thread started."); // Sleep for a few seconds. Console.WriteLine("Main - Sleeping for 5 seconds."); Thread.Sleep(5000); // Now wake the second worker thread. Console.WriteLine("Main - Interrupting Thread2."); t2.Interrupt(); // Sleep for a few more seconds to give the thread time to finish up. Console.WriteLine("Main - Sleeping for 10 seconds."); Thread.Sleep(10000); Console.Write ("Main - Press <ENTER> to end: "); Console.ReadLine(); }
public String testMonitorInterruptDuringWait() { Thread thread; lock (this) { thread = new Thread(new ThreadStart(threadFunc)); thread.Start(); this.seen = false; Monitor.Wait(this); } lock (this.o) { thread.Interrupt(); Thread.Sleep(800); this.seen = true; } thread.Join(); return this.result; }
public String testMonitorInterruptSleep() { Thread thread; lock (this) { thread = new Thread(new ThreadStart(threadFunc)); thread.Start(); Monitor.Wait(this); } thread.Interrupt(); this.seen = true; Thread.MemoryBarrier(); thread.Join(); return this.result; }
private static bool TestFairness() { const int RUN_TIME = 15000; const int SETUP_TIME = 20; const int READERS = 50; const int WRITERS = 10; Thread[] rdthrs = new Thread[READERS]; Thread[] wrthrs = new Thread[WRITERS]; int[] readersCounters = new int[READERS]; int[] writersCounters = new int[WRITERS]; int[] interruptCounters = new int[READERS + WRITERS]; int sentInterrupts = 0; ManualResetEventSlim startEvent = new ManualResetEventSlim(false); ReadersWriters_ rwLock = new ReadersWriters_(); for (int i = 0; i < READERS; i++) { int tid = i; rdthrs[i] = new Thread(() => { // Wait the start for all threads startEvent.Wait(); int endTime = Environment.TickCount + RUN_TIME; do { do { try { rwLock.StartRead(); break; } catch (ThreadInterruptedException) { interruptCounters[tid]++; } } while (true); Thread.Yield(); rwLock.EndRead(); if ((++readersCounters[tid] % 1000) == 0) { Console.Write("[#r{0}]", tid); } } while (Environment.TickCount < endTime); try { Thread.Sleep(0); } catch (ThreadInterruptedException) { interruptCounters[tid]++; } }); rdthrs[i].Start(); } for (int i = 0; i < WRITERS; i++) { int tid = i; wrthrs[i] = new Thread(() => { // Wait the start for all threads startEvent.Wait(); int endTime = Environment.TickCount + RUN_TIME; do { do { try { rwLock.StartWrite(); break; } catch (ThreadInterruptedException) { interruptCounters[tid + READERS]++; } } while (true); Thread.Yield(); rwLock.EndWrite(); if ((++writersCounters[tid] % 1000) == 0) { Console.Write("[#w{0}]", tid); } } while (Environment.TickCount < endTime); try { Thread.Sleep(0); } catch (ThreadInterruptedException) { interruptCounters[tid + READERS]++; } }); wrthrs[i].Start(); } // Create the and start the bomber thread... Thread bomber = new Thread(() => { const int MIN_TIME = 5; const int MAX_TIME = 50; Random rnd = new Random(Environment.TickCount); // Wait the start for all threads startEvent.Wait(); do { try { Thread.Sleep(rnd.Next(MIN_TIME, MAX_TIME)); } catch (ThreadInterruptedException) { break; } int target = rnd.Next(0, READERS + WRITERS); if (target < READERS) { rdthrs[target].Interrupt(); } else { wrthrs[target - READERS].Interrupt(); } sentInterrupts++; } while (true); }); bomber.Start(); // Sleep for a while and then unblock the test threads. Thread.Sleep(SETUP_TIME); startEvent.Set(); Thread.Sleep(RUN_TIME); // Interrupt the bomber thread and wait until it has been exited. bomber.Interrupt(); bomber.Join(); // Wait until all threads have been terminated. for (int i = 0; i < READERS + WRITERS; i++) { if (i < READERS) rdthrs[i].Join(); else wrthrs[i - READERS].Join(); } // Show results Console.WriteLine("\nReader counters:"); for (int i = 0; i < READERS; i++) { if ((i % 5) == 0) Console.WriteLine(); Console.Write("[#r{0}: {1,4}]", i, readersCounters[i]); } Console.WriteLine("\nWriter counters:"); for (int i = 0; i < WRITERS; i++) { if ((i % 5) == 0) Console.WriteLine(); Console.Write("[#w{0}: {1,4}", i, writersCounters[i]); } Console.WriteLine("\ninterrupt counters:"); int sum = 0; for (int i = 0; i < READERS + WRITERS; i++) { sum += interruptCounters[i]; if ((i % 5) == 0) Console.WriteLine(); Console.Write("[#{0}: {1,4}]", i, interruptCounters[i]); } Console.WriteLine("\nsent interrupts: {0}, received: {1}", sentInterrupts, sum); return true; }
public String testMonitorInterruptDuringSleep() { Thread thread; thread = new Thread(new ThreadStart(threadFunc)); thread.Start(); while ((thread.ThreadState & ThreadState.WaitSleepJoin) == 0) continue; thread.Interrupt(); thread.Join(); return this.result; }