cancellation

I have a boolean variable to control the execution of the server (start/stop) : private boolean ecoute=true; here is my class: sw=new SwingWorker<String,Void> (){ protected String doInBackground() throws Exception { try { server = new ServerSocket(Integer.parseInt(port.getText())); String str1="waiting for connexion.."; String str2="Connexion ok"; log.append(str1+"\n"); PrintWriter out=null; BufferedReader in=null; Socket socClient=null; while(ecoute){ socClient = server.accept(); log.append(str2+"\n"); in = new BufferedReader( new InputStreamReader(socClient.getInputStream()) ); out = new

I have a Thread (STAThread) in a Windows Service, which performs a big amount of work. When the windows service is restarted I want to stop this thread gracefully. I know of a couple of ways A volatile boolean ManualResetEvent CancellationToken As far as I have found out Thread.Abort is a no go... What is the best practice ? The work is perfomed in another class than the one where the thread is started, so it is necessary to either introduce a cancellationToken parameter in a constructor or for example have a volatile variable. But I just can't figure out what is smartest. Update Just to

The idea here is simple, but the implementation has some interesting nuances. This is the signature of the extension method I would like to implement in .NET 4 . public static Task<WebResponse> GetResponseAsync(this WebRequest request, CancellationToken token); Here is my initial implementation. From what I've read, the web request might need to be cancelled due to a timeout . In addition to the support described on that page, I want to properly call request.Abort() if cancellation is requested via the CancellationToken . public static Task<WebResponse> GetResponseAsync(this WebRequest request

Our application uses the TPL to serialize (potentially) long running units of work. The creation of work (tasks) is user-driven and may be cancelled at any time. In order to have a responsive user interface, if the current piece of work is no longer required we would like to abandon what we were doing, and immediately start a different task. Tasks are queued up something like this: private Task workQueue; private void DoWorkAsync (Action<WorkCompletedEventArgs> callback, CancellationToken token) { if (workQueue == null) { workQueue = Task.Factory.StartWork (() => DoWork(callback, token), token

Consider the following simplified example (ready to roll in LinqPad, elevated account required): void Main() { Go(); Thread.Sleep(100000); } async void Go() { TcpListener listener = new TcpListener(IPAddress.Any, 6666); try { cts.Token.Register(() => Console.WriteLine("Token was canceled")); listener.Start(); using(TcpClient client = await listener.AcceptTcpClientAsync() .ConfigureAwait(false)) using(var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5))) { var stream=client.GetStream(); var buffer=new byte[64]; try { var amtRead = await stream.ReadAsync(buffer, 0, buffer.Length, cts

My question is somewhat different from others that have asked about fault addresses. I'm trying to implement a horrible hack to determine, from a signal handler, whether the signal interrupted a syscall or ordinary user code by inspecting the code at the saved instruction pointer and comparing it against the possible syscall entry instructions for the host architecture it's running on. This is part of implementing correct POSIX thread cancellation that does not suffer from the race condition and resource leak described in my old question: How are POSIX cancellation points supposed to behave?