/// <summary> /// Queue thread for processing /// </summary> /// <remarks> /// Typically only used by queued threads to add work items to the queue /// </remarks> internal static void Queue(ManagedThread item) { lock (m_queuedThreads) { m_queuedThreads.AddLast(item); } }
/// <summary> /// Remove completed thread from active thread list /// </summary> internal static void Remove(ManagedThread item) { lock (m_queuedThreads) { m_activeThreads.Remove(item); } }
/// <summary> /// Add an item to the active thread list /// </summary> /// <remarks> /// Typically only used by standard threads when user calls "Start" /// </remarks> internal static void Add(ManagedThread item) { // Standard threads are simply added to the active thread list when started lock (m_queuedThreads) { item.Status = ThreadStatus.Started; m_activeThreads.AddLast(item); } }
/// <summary> /// Queues a work item for processing on the managed thread pool /// </summary> /// <param name="callback">A WaitCallback representing the method to execute.</param> /// <returns>Reference to queued thread</returns> /// <remarks> /// This differs from the normal thread pool QueueUserWorkItem function in that it does /// not return a success value determing if item was queued, but rather a reference to /// to the managed thread that was actually placed on the queue. /// </remarks> public static ManagedThread QueueUserWorkItem(ThreadStart callback) { if (callback == null) throw (new ArgumentNullException("callback")); ManagedThread item = new ManagedThread(ThreadType.QueuedThread, callback, null, null); ManagedThreads.Queue(item); ThreadPool.QueueUserWorkItem(HandleItem); return item; }
/// <summary> /// Queues a work item for processing on the managed thread pool /// </summary> /// <param name="callback">A WaitCallback representing the method to execute.</param> /// <param name="state">An object containing data to be used by the method.</param> /// <param name="ctx">Alternate execution context in which to run the thread.</param> /// <returns>Reference to queued thread</returns> /// <remarks> /// This differs from the normal thread pool QueueUserWorkItem function in that it does /// not return a success value determing if item was queued, but rather a reference to /// to the managed thread that was actually placed on the queue. /// </remarks> public static ManagedThread QueueUserWorkItem(ContextCallback callback, object state, ExecutionContext ctx) { if (callback == null) throw (new ArgumentNullException("callback")); ManagedThread item = new ManagedThread(ThreadType.QueuedThread, callback, state, ctx); ManagedThreads.Queue(item); ThreadPool.QueueUserWorkItem(HandleItem); return item; }
/// <summary> /// Removes a queued thread from thread pool if still queued, if allowAbort is True /// aborts the thread if executing (standard or queued) /// </summary> /// <param name="item">Thread to cancel</param> /// <param name="allowAbort">Set to True to abort thread if executing</param> /// <param name="stateInfo">An object that contains application-specific information, such as state, which can be used by the thread being aborted.</param> public static void Cancel(ManagedThread item, bool allowAbort, object stateInfo) { if (item == null) throw new ArgumentNullException("item"); LinkedListNode<ManagedThread> node; lock (m_queuedThreads) { // Change thread status to aborted item.Status = ThreadStatus.Aborted; // See if item is still queued for execution in thread pool node = m_queuedThreads.Find(item); // Handle abort or dequeue if (node == null) { if (allowAbort) { // Started items may be aborted, even if running in thread pool if (stateInfo == null) item.Thread.Abort(); else item.Thread.Abort(stateInfo); } } else { // Remove item from queue if queued thread has yet to start m_queuedThreads.Remove(node); } } }
private static string ThreadStatusText(ManagedThread item) { string runtime = Seconds.ToText(item.RunTime); switch (item.Status) { case ThreadStatus.Unstarted: return "Not Started"; case ThreadStatus.Queued: return "Queued"; case ThreadStatus.Executing: return "Executing for " + runtime; case ThreadStatus.Completed: return "Completed in " + runtime; case ThreadStatus.Aborted: return "Aborted, ran for " + runtime; default: return "Status Unknown"; } }
/// <summary> /// Queues a work item for processing on the managed thread pool /// </summary> /// <param name="callback">A WaitCallback representing the method to execute.</param> /// <param name="state">An object containing data to be used by the method.</param> /// <returns>Reference to queued thread</returns> /// <remarks> /// This differs from the normal thread pool QueueUserWorkItem function in that it does /// not return a success value determing if item was queued, but rather a reference to /// to the managed thread that was actually placed on the queue. /// </remarks> public static ManagedThread QueueUserWorkItem(ParameterizedThreadStart callback, object state) { if ((object)callback == null) throw (new ArgumentNullException("callback")); ManagedThread item = new ManagedThread(ThreadType.QueuedThread, callback, state, null); ManagedThreads.Queue(item); ThreadPool.QueueUserWorkItem(HandleItem); return item; }
internal void StartAsyncTransfer() { #if ThreadTracking ManagedThread thread = new ManagedThread(TransferThreadProc); thread.Name = "TVA.Net.Ftp.FileTransferer.TransferThreadProc() [" + m_remoteFile + "]"; #else Thread thread = new Thread(TransferThreadProc); thread.Name = "Transfer file thread: " + m_remoteFile; #endif thread.Start(); }
public override void Start() { if (Enabled && !IsRunning && ValidConfigurationString(ConfigurationString)) { try { int serverPort = 0; if (m_configurationData.ContainsKey("port")) serverPort = int.Parse(m_configurationData["port"]); m_udpServer = new StateInfo<Socket>(); m_udpServer.ID = ServerID; m_udpServer.Passphrase = HandshakePassphrase; m_udpServer.Client = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp); if (Handshake) { // We will listen for data only when Handshake is enabled and a valid port has been specified in // the configuration string. We do this in order to keep the server stable and besides that, the // main purpose of a UDP server is to serve data in most cases. if (serverPort > 0) { m_udpServer.Client.Bind(new IPEndPoint(IPAddress.Any, serverPort)); #if ThreadTracking ManagedThread receiveThread = new ManagedThread(ReceiveClientData); receiveThread.Name = "TVA.Communication.UdpServer.ReceiveClientData() [" + ServerID.ToString() + "]"; #else Thread receiveThread = new Thread(ReceiveClientData); #endif receiveThread.Start(); } else { throw new ArgumentException("Server port must be specified in the configuration string."); } } OnServerStarted(EventArgs.Empty); if (!Handshake && m_configurationData.ContainsKey("clients")) { // We will ignore the client list in configuration string when Handshake is enabled. foreach (string clientString in m_configurationData["clients"].Replace(" ", "").Split(',')) { try { int clientPort = 0; string[] clientStringSegments = clientString.Split(':'); if (clientStringSegments.Length == 2) clientPort = int.Parse(clientStringSegments[1]); StateInfo<IPEndPoint> udpClient = new StateInfo<IPEndPoint>(); udpClient.ID = Guid.NewGuid(); udpClient.Client = Transport.GetIpEndPoint(clientStringSegments[0], clientPort); lock (m_udpClients) { m_udpClients.Add(udpClient.ID, udpClient); } OnClientConnected(udpClient.ID); } catch { // Ignore invalid client entries. } } } } catch (Exception ex) { OnServerStartupException(ex); } } }