一个winfrom 里面 可以 创建多个线程池吗

Question

现在有2个Queue ,  现在想创建2个线程池, 来分别操作它们, 要怎么弄呢?

Answer 1

弄清楚线程池干吗使的，2个消息队列可以通过一个线程池自动分配线程来处理 queue

Answer 2

以前我也总用想用多个线程池，现在我全废了，只要一个线程池能做任务事情了using System;
using System.Collections.Generic;
using System.Threading;
using System.Collections.Concurrent;namespace platform
{
    public class MissionPool
    {
        void _runMission()
        {
            for ( ; ; )
            {
                Mission mission_ = this._getMission();
                if (null != mission_)
                {
                    mission_._runMission();
                }
                else
                {
                    Thread.Sleep(1);
                }
            }
        }        Mission _getMission()
        {
            Mission result_ = null;
            IEnumerator<KeyValuePair<int, Mission>> enumerator_ = mUnFinish.GetEnumerator();
            while (enumerator_.MoveNext())
            {
                result_ = enumerator_.Current.Value;
                if (!result_._isRunning())
                {
                    break;
                }
                result_ = null;
            }
            if (null == result_)
            {
                lock (mLock)
                {
                    while (null == result_)
                    {
                        if (mRunIndex >= mMissions.Count)
                        {
                            mRunIndex = 0;
                        }
                        if (mMissions.Count > 0)
                        {
                            result_ = mMissions[mRunIndex];
                        }
                        else
                        {
                            break;
                        }
                        if (!result_._isRunning())
                        {
                            break;
                        }
                        result_ = null;
                    }
                }
            }
            return result_;
        }        public void _pushBack(IRunnable nRunnable)
        {
            if (false == mInit)
            {
                throw new Exception();
            }
            Mission mission_ = new Mission(nRunnable);
            lock (mLock)
            {
                mMissions.Add(mission_);
            }
            LogSingleton logSingleton_ = __singleton<LogSingleton>._instance();
            logSingleton_._logError(string.Format(@"MissionPool mMissions size:{0}",mMissions.Count));
        }        public void _runInit(int nSize = 5)
        {
            mInit = true;
            mSize = nSize;
            mLock = new object();
            mThreads = new List<Thread>(nSize);
            for (int i = 0; i < nSize; ++i)
            {
                Thread thread_ = new Thread(new ThreadStart(_runMission));
                thread_.Start();
                mThreads.Add(thread_);
            }
            mUnFinish = new ConcurrentDictionary<int, Mission>();
            mMissions = new List<Mission>();
        }        public MissionPool()
        {
            mUnFinish = null;
            mMissions = null;
            mThreads = null;
            mRunIndex = 0;
            mInit = false;
            mLock = null;
            mSize = -1;
        }
        ConcurrentDictionary<int, Mission> mUnFinish;
        List<Mission> mMissions;
        List<Thread> mThreads;
        int mRunIndex;
        object mLock;
        bool mInit;
        int mSize;
    }
}using System;namespace platform
{
    public class Mission
    {
        public void _runMission()
        {
            lock (mLock)
            {
                if (true == mRunning)
                {
                    return;
                }
                mRunning = true;
            }
            mDateTime = DateTime.Now;
            mRunnable._runRunnable();
            mDateTime = DateTime.Now;
            lock (mLock)
            {
                mRunning = false;
            }
        }        public bool _isRunning()
        {
            bool result_ = false;
            lock (mLock)
            {
                result_ = mRunning;
            }
            return result_;
        }        public double _getTimeSpan()
        {
            return (DateTime.Now - mDateTime).TotalMilliseconds;
        }        public Mission(IRunnable nRunnable)
        {
            mRunnable = nRunnable;
            mDateTime = DateTime.Now;
            mLock = new object();
            mRunning = false;
        }        IRunnable mRunnable;
        DateTime mDateTime;
        bool mRunning;
        object mLock;
    }
}
namespace platform
{
    public interface IRunnable
    {
        void _runRunnable();        string _getRunnableName();
    }
}

Answer 3

你可以做并发异步处理，新建一个委托代理对象，执行beginInvoke方法做异步处理

Answer 4

你可以做并发异步处理，新建一个委托代理对象，执行beginInvoke方法做异步处理没有明白?  我现在需要的是同时处理多个数据

Answer 5

Task  Class  是不是可以解决我的问题?

Answer 6

可以啊：  TaskFactory factory = new TaskFactory();
  List<Task> tasks = new List<Task>();
  tasks.add(factory.StartNew(Action));你可以factory.ContinueWhenAll(tasks.ToArray(),Action<Task[]>)监听所有线程结束，进而触发相应的事件

Answer 7

你可以做并发异步处理，新建一个委托代理对象，执行beginInvoke方法做异步处理没有明白?  我现在需要的是同时处理多个数据所以你认为一个线程池同时只能处理一个数据？

Answer 8

你可以做并发异步处理，新建一个委托代理对象，执行beginInvoke方法做异步处理没有明白?  我现在需要的是同时处理多个数据所以你认为一个线程池同时只能处理一个数据？我理解的线程池 只有一个回调函数