C# Threading.Suspend in Obsolete, thread has been deprecated?

问题

In my application, I am performing my file reading by another thread(other that GUI thread). There are two buttons that suspend and resume the Thread respectively.

private void BtnStopAutoUpd_Click(object sender, EventArgs e)
        {
           autoReadThread.Suspend();
        }

private void BtnStartAutoUpd_Click(object sender, EventArgs e)
        {
           autoReadThread.Resume();  
        }

but I am facing this warning,

Thread.Suspend has been deprecated. Please use other classes in System.Threading, such as Monitor, Mutex, Event, and Semaphore, to synchronize Threads or protect resources. http://go.microsoft.com/fwlink/?linkid=14202

Any how I run only single thread (rather than GUI thread), so How can I apply Synchronization here, or monitor.

Update Code:

 class ThreadClass
{

    // This delegate enables asynchronous calls for setting the text property on a richTextBox control.
    delegate void UpdateTextCallback(object text);

    // create thread that perform actual task
    public Thread autoReadThread = null;

    public ManualResetEvent _event = new ManualResetEvent(true);

    // a new reference to rich text box
    System.Windows.Forms.RichTextBox Textbox = null;

    private volatile bool _run;

    public bool Run
    {
        get { return _run; }
        set { _run = value; }
    }

    public ThreadClass(string name, System.Windows.Forms.RichTextBox r1)
    {
        Textbox = r1;
        Run = true;
        this.autoReadThread = new Thread(new ParameterizedThreadStart(UpdateText));
        this.autoReadThread.Start(name);
    }

    private void UpdateText(object fileName)
    {

        //while (true)
        //{
        //    _event.WaitOne();
            while (Run)
            {

                if (Textbox.InvokeRequired)
                {
                    UpdateTextCallback back = new UpdateTextCallback(UpdateText);
                    Textbox.BeginInvoke(back, new object[] { fileName });
                    Thread.Sleep(1000);
                }

                else
                {
                    string fileToUpdate = (string)fileName;
                    using (StreamReader readerStream = new StreamReader(fileToUpdate))
                    {
                        Textbox.Text = readerStream.ReadToEnd();
                    }
                    break;
                //}
            }
        }       
    }

}

}

run is bool value, a thread controls it(Initially its true)

and to start thread I am creating this class instance(this start thread also) in other class

回答1:

 //true makes the thread start as "running", false makes it wait on _event.Set()
  ManualResetEvent _event = new ManualResetEvent(true); 
  Thread _thread = new Thread(ThreadFunc);

  public void ThreadFunc(object state)
  {
      while (true)
      {
          _event.Wait();

          //do operations here
      }
  }


  _thread.Start();

  // to suspend thread.
  _event.Reset();

  //to resume thread
  _event.Set();

Note that all operations are completed before the thread is "suspended"

What you want

private void ThreadFunc(object fileName)
{
    string fileToUpdate = (string)fileName;
    while (Run)
    {
        _event.WaitOne(); 

        string data;
        using (StreamReader readerStream = new StreamReader(fileToUpdate))
        {
            data = readerStream.ReadToEnd();
        }

        if (Textbox.InvokeRequired)
        {
            UpdateTextCallback back = new UpdateTextCallback(UpdateText);
            Textbox.BeginInvoke(back, new object[] { data });
        }

                Thread.Sleep(1000); 
    }       
}


private void UpdateText(string data)
{
    Textbox.Text = data;
}

回答2:

The reason Suspend and Resume are deprecated is because there are no guarantees at what point in the execution the thread will be suspended on. This is a bad thing. The issue is described here as well as a solution.

The solution should involved a WaitHandle (maybe AutoResetEvent or ManualResetEvent) which you can use to signal to your autoReadThread to stop/start.

回答3:

I would use the Monitor mechanism for achieving pausing and resuming threads. The Monitor.Wait will cause the thread to wait for the Monitor.Pulse.

private bool _pause = false;
private object _threadLock = new object();

private void RunThread()
{
    while (true)
    {
        if (_pause)
        {
            lock (_threadLock)
            {
                Monitor.Wait(_threadLock);
            }
        }

        // Do work
    }
}

private void PauseThread()
{
    _pause = true;
}

private void ResumeThread()
{
    _pause = false;
    lock (_threadLock)
    {
        Monitor.Pulse(_threadLock);
    }
}

来源：https://stackoverflow.com/questions/4509067/c-sharp-threading-suspend-in-obsolete-thread-has-been-deprecated