Suggest an Improved approach for Multi-threaded application

I am building up a multi-threaded application where I spawn three threads when application starts and these threads continue to run for application lifetime. All my threads are exclusive and do not interfere with each other in anyway. Now a user can suspend the application and, here I want to suspend or, say, abort my threads.

I am currently spawning threads as foreground threads, but I guess changing them to background threads wouldn't affect my application anyway (except they(foreground threads) would keep the application alive until they finish).

I would ask people here开发者_高级运维 to suggest an approach to suspend the application via thread.suspend() or thread.abort(). I know thread.suspend is obsolete and risky, but is it harmful for my application also where I am not using any type of synchronization.

PS: My threads are saving and retrieving some data to & from embedded database(sqlite) every minute.

Use the Blocking mechanisms like WaitHandles (ManualResetEvent, AutoResetEvent), Monitor, Semaphore etc...

Andrew

P.S. the question is quite broad so I would ultimately recommend reading up on proven practices and principles of Multi Threading which will include synchronization. Your requirements do not sound too complex so I am sure you will be able to research the best way which suits your needs.

You could create a mutex and let the threads wait for a signal on that mutex. This way your threads are not destroyed but they will sleep almost without consuming resources.

Mutex.WaitOne

I always use ManualResetEvent for this:

class Myclass
{
    ManualResetEvent _event;
    Thread _thread;

    public void Start()
    {
        _thread = new Thread(WorkerThread);
        _thread.IsBackground = true;
        _thread.Start();
    }

    public void Stop()
    {
        _event.Set();
        if (!_thread.Join(5000))
            _thread.Abort();
    }

    private void WorkerThread()
    {
        while (true)
        {
            // wait 5 seconds, change to whatever you like
            if (_event.WaitOne(5000))
                break; // signalled to stop

            //do something else here
        }
    }
}

Actually, this situation is the only one where Thread.Suspend does make sense. The reason it's obsoleted is because people misuse it to fake synchronization, or use it on threads they do not own (e.g., ThreadPool threads).