Thread（线程）和ThreadPool（线程池） Thread回调与返回值

Thread（线程）

Thread开启线程：接收一个参数

TestClass tc = new TestClass();
            //没有返回值，有一个object类型的参数的委托；两种写法。
            ParameterizedThreadStart threadStart1 = t => tc.TestThread(t.ToString());
            //ParameterizedThreadStart threadStart2 = new ParameterizedThreadStart(tc.TestThread);
            List<Thread> threadList = new List<Thread>();
            for (int i = 0; i < 5; i++)
            {
                Thread thread = new Thread(threadStart1);
                thread.Start("test" + i);
                threadList.Add(thread);
            }

            //等待Thread执行结束1,
            while (threadList.Count(c => c.ThreadState == ThreadState.Running) > 0)
            {
                Thread.Sleep(1000);
            }

            //等待Thread执行结束2,附加都主线程，
            //主线程会等待附加的线程结束，然后再执行下面的操作，会卡界面。
            //foreach (var item in threadList)
            //{
            //    item.Join();
            //}

            Console.Read();

测试方法：

public class TestClass
    {
        public void TestThread(object name)
        {
            Console.WriteLine("TestThreadStart ThreadID:{0},Name:{1},Time:{2}", Thread.CurrentThread.ManagedThreadId, name, DateTime.Now.ToString());
            long num = 0;
            for (int i = 0; i < 99999999; i++)
            {
                num += i;
            }
            string result = num.ToString();
            Console.WriteLine("TestThreadEnd ThreadID:{0},Name:{1},Time:{2},Result:{3}", Thread.CurrentThread.ManagedThreadId, name, DateTime.Now.ToString(), result);
        }
    }

Thread，默认是 前台线程，前台线程 即使 程序进程 结束，前台线程也会继续执行完毕。

后台线程：会随着 程序进程 的结束而强制结束，无论是否执行完毕。

Thead.Join()是附加到主线程上面，所以当 程序进程 结束的时候，被Join的线程也会强制结束。

Thread.IsBackground 可以设置 是否是后台线程。

Thread回调、返回值

/// <summary>
        /// Thread实现回调函数；通过修改共有变量，获取Thread返回值；
        /// </summary>
        /// <param name="func"></param>
        /// <param name="callBack"></param>
        /// <returns></returns>
        public string ThreadWithCallBack(Func<string> func, Action callBack)
        {
            string result = null;
            ThreadStart threadStart = new ThreadStart
                (
                    () =>
                    {
                        result = func();
                        callBack();
                    }
                );
            Thread thread = new Thread(threadStart);
            thread.Start();//线程开始
            thread.Join();//附加到主线程，主线程将等待异步结束
            return result;
        }

ThreadPool（线程池）维护一定数量的线程，当有新的线程申请时，分配空闲线程给他使用，使用完毕后释放，线程可以重复使用。

而Thread每次都是申请新的线程，回收需要GC垃圾回收机制自动回收。

线程池里的线程全部都是后台线程。获得最大 工作线程、io线程。

int workerThreads = 0, ioThreads = 0;

ThreadPool.GetMaxThreads(out workerThreads, out ioThreads);

线程池实现异步、线程池等待：

#region ThreadPool 线程池实现异步、线程池等待
            {
                TestClass tc = new TestClass();
                //线程池实现异步
                //WaitCallback callBack = t => { tc.TestThread(t); };
                //ThreadPool.QueueUserWorkItem(callBack, "ThreadPoolTest");

                //int workerThreads = 0, ioThreads = 0;
                //ThreadPool.GetMaxThreads(out workerThreads, out ioThreads);

                //线程池等待
                //当设为 false，为非终止状态，WaitOne() 不会立即返回，等待Set() =>执行 Set() 后，变成终止状态
                //当设为 true，为终止状态，WaitOne() 立即返回，等待Set() =>执行 Set() 后，变成终止状态
                ManualResetEventSlim manualReset = new ManualResetEventSlim(false);//ManualResetEventSlim 是线程安全的
                WaitCallback callBack1 = t => 
                {
                    tc.TestThread(t);
                    manualReset.Set();
                };
                //执行线程池
                ThreadPool.QueueUserWorkItem(callBack1, "ThreadPoolTest");
                //等待线程执行结束
                manualReset.WaitHandle.WaitOne();
            }
            #endregion