多线程学习

线程这东西已经关注好久了。以前只是偶尔看看。最近一个项目（大文件传输）感觉要用到多线程。所以这次打算把它搞懂（不但会看，还会写。因为有时候会看。不一定会写）

打算先看一些简单的教程

 

C#多线程学习(一) 多线程的相关概念

C#多线程学习(二) 如何操纵一个线程

C#多线程学习(三) 生产者和消费者

C#多线程学习(四) 多线程的自动管理(线程池)

C#多线程学习(五) 多线程的自动管理(定时器)

C#多线程学习(六) 互斥对象

 

 

using System;
using System.Threading;
namespace ThreadTest
{
    public class Alpha
    {
        public void Beta()
        {
            while (true)
            {
                Console.WriteLine("Alpha.Beta is running in its own thread.");
            }
        }
    };
    public class Simple
    {
        public static int Main()
        {
            Console.WriteLine("Thread Start/Stop/Join Sample");
            Alpha oAlpha = new Alpha();
            //file://这里创建一个线程，使之执行Alpha类的Beta()方法　　  
            Thread oThread = new Thread(new ThreadStart(oAlpha.Beta));
            oThread.Start();
            while (!oThread.IsAlive)
                Thread.Sleep(1);
            oThread.Abort();
            oThread.Join(); 
            Console.WriteLine();
            Console.WriteLine("Alpha.Beta has finished");
            try
            {
                Console.WriteLine("Try to restart the Alpha.Beta thread");
                oThread.Start();
            }
            catch (ThreadStateException)
            {
                Console.Write("ThreadStateException trying to restart Alpha.Beta. "); 
                Console.WriteLine("Expected since aborted threads cannot be restarted.");
                Console.ReadLine();
            } return 0;
        }
    }
}

看了以上代码。有几个地方不太懂

1:  Thread oThread = new Thread(new ThreadStart(oAlpha.Beta));  是不是还有其它的写法

2:while (!oThread.IsAlive)
                Thread.Sleep(1);

     翻Msdn得:Thread.IsAlive 属性:获取一个值，该值指示当前线程的执行状态。

 那上面那个句话是不是指。当没有执行状态的时候，当前线程暂停1毫秒？

自己的理解：当没有其它线程执行的时候。主线程暂停1毫秒。把控制权交给其它线程

 

 public class  Students
    {
        public  static void study()
        {
            Console.WriteLine("I'm studing");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Thread th = new Thread(new ThreadStart(Students.study));
            th.Start();

            Thread.Sleep(10);
             th.Abort();

            try
            {
                Console.WriteLine("Try to restart the Alpha.Beta thread");
          
            }
            catch(ThreadStateException ex)
            {
                Console.Write("ThreadStateException trying to restart Alpha.Beta. "); 
                Console.WriteLine("Expected since aborted threads cannot be restarted."); 
                Console.ReadLine();
            }
  
            Console.WriteLine(); 
            Console.WriteLine("Alpha.Beta has finished"); 
            Console.ReadLine();
        }
    }

 结果:

 

 

修改:Thread.Sleep(60);

结果：

 

 

修改:Thread.Sleep(10); 删除:th.Abort(); 

结果： 
               

我们仔细对比。可能就会发现其中的一些东东

 

using System;
using System.Threading;

public class Worker
{
    // This method will be called when the thread is started.
    public void DoWork()
    {
        while (!_shouldStop)
        {
            Console.WriteLine("worker thread: working");
        }
        Console.WriteLine("worker thread: terminating gracefully.");
    }
    public void RequestStop()
    {
        _shouldStop = true;
    }
    // Volatile is used as hint to the compiler that this data
    // member will be accessed by multiple threads.
    private volatile bool _shouldStop;
}

public class WorkerThreadExample
{
    static void Main()
    {
        // Create the thread object. This does not start the thread.
        Worker workerObject = new Worker();
        Thread workerThread = new Thread(workerObject.DoWork);

        // Start the worker thread.
        workerThread.Start();
        Console.WriteLine("main thread: Starting worker thread");

        // Loop until worker thread activates.
        while (!workerThread.IsAlive) ;

        // Put the main thread to sleep for 1 millisecond to
        // allow the worker thread to do some work:
        Thread.Sleep(1);

        // Request that the worker thread stop itself:
        workerObject.RequestStop();

        // Use the Join method to block the current thread 
        // until the object's thread terminates.
        workerThread.Join();
        Console.WriteLine("main thread: Worker thread has terminated.");
        Console.ReadLine();
    }
}

 

执行结果：

 

怎么会是这个显示顺序呢？查阅网上资料。有人说“线程的执行顺序是不定的，与当时的环境和cpu调度有关” http://topic.csdn.net/u/20090601/08/18e29142-e79c-49ab-8aa1-a912acd2b537.html

郁闷，人家这么说我也只能这么信了。

 // Loop until worker thread activates.
        while (!workerThread.IsAlive) ;

 // Put the main thread to sleep for 1 millisecond to
 // allow the worker thread to do some work:
        Thread.Sleep(1);

 

又出现这个代码。舍意思呀。看注释好像是说  "一直循环直到workerThead这个线程拿到话语权，如果拿不到。就让主线程暂停一毫秒。多少个一毫秒呢？反正直到workerThead这个线程拿到话语权为止"

 看来先前的理解还是有点误差。

        // Use the Join method to block the current thread 
        // until the object's thread terminates.
        workerThread.Join();

 

这一句又怎么理解呢？翻议说“使用join方法来阻止当前线程(可能是主线程。不知道有没有可能是其它线程），直到该对象(workerThread)的线程终止”   看来如果不想让线程乱执行。得用上这一句