谁有多线程代码！！我想实现10个线程同时执行一个方法！

[jiebao521]

我想10个线程同时执行一个方法， 但是每个方法传入的参数是不一样的！ 我在网上找了些代码，但是不行，造成线程混乱，谁能教教我啊！ ！

想要实现的是： 10个线程同时去登陆网站，然后采集东西。 当然我也有10个用户名。 10个线程 每个线程对应一个用户。

[半兽人写程序]

分太少了。不然老夫贴出来

[Icedmilk]

ThreadPool.QueueUserWorkItem();

[sanjiawan]

给你个多线程的例子

private void btnDataUp_Click(object sender, RoutedEventArgs e)
{
            Thread thread = new Thread(GetDataUp);  //创建一个线程   其中GetDataUp是该线程要执行的方法
            thread.Start();                         //该线程运行  无论上述线程是否执行完毕都继续执行一下代码
            lblUpdateMessage.Visibility = Visibility.Visible;
}


private void GetDataUp()
        {
                //执行的代码
                Action action; //封装一个方法  该方法不具备参数并且不返回值                 action = () =>
                {
                    //执行的代码
                };
                btnDataUp.Dispatcher.BeginInvoke(DispatcherPriority.SystemIdle, action);  //关联的线程上异步执行委托 执行Action方法         
           
        }

[半兽人写程序]

    public abstract class BaseProcessor
    {
        public BaseProcessor()
        {
            m_SyncEvents = new SyncEvents();
            m_Thread = null;
            m_ExitTimeOut = 500;
            m_WorkTimeOut = System.Threading.Timeout.Infinite;
            m_IsPause = false;
            m_IsStoping = false;
            m_ThreadName = "";
        }
        
        public BaseProcessor(int exitTimeOut , int workTimeOut)
        {
            m_SyncEvents = new SyncEvents();
            m_Thread = null;
            m_ExitTimeOut = exitTimeOut;
            m_WorkTimeOut = workTimeOut;
        }

        public BaseProcessor(int exitTimeOut)
        {
            m_SyncEvents = new SyncEvents();
            m_Thread = null;
            m_ExitTimeOut = exitTimeOut;
            m_WorkTimeOut = System.Threading.Timeout.Infinite;
        }

        public bool IsPause
        {
            get { return this.m_IsPause; }
        }

        public bool IsStoping
        {
            get { return this.m_IsStoping; }
        }

        public virtual void Start()
        {
           
            this.m_ExitObject = new ExitObject();
            this.m_ExitObject.Reset();
            this.m_ExitObject.name = this.ThreadName;
            m_IsPause = false;
            m_IsStoping = false;
            if (m_Thread == null || !m_Thread.IsAlive)
            {
                m_Thread = new Thread(new ThreadStart(this.DoWork));
                if (this.ThreadName != string.Empty)
                {
                    m_Thread.Name = this.ThreadName;
                }
             
                this.SyncEventsHandle.ExitWaitHandle.Reset();
                m_Thread.Start();
            }
            m_SyncEvents.WorkWaitHandle.Set();

        }

        public virtual void DoNextStep()
        {
            m_SyncEvents.WorkWaitHandle.Set();
        }

        public virtual void Stop()
        {
            m_IsStoping = true;
            if (m_Thread == null)
                return;
            try
            {
                this.BeforeStoping();
                this.SyncEventsHandle.ExitWaitHandle.Set();
                if (!m_Thread.Join(500))
                {
                    m_Thread.Abort();
                }
            }
            catch (System.Exception ex)
            {
                System.Diagnostics.Debug.WriteLine(ex.Message.ToString());
            }

            this.m_Thread = null;
        }

        public virtual void Pause()
        {
            m_IsPause = true;
        }

        public SyncEvents SyncEventsHandle
        {
            get { return m_SyncEvents; }
        }

        public int ExitTimeout
        {
            get { return m_ExitTimeout; }
            set{ m_ExitTimeout = value; }

        }

        public int WorkTimeout
        {
            get { return m_WorkTimeout; }
            set { m_WorkTimeout = value; }
        }

        public string ThreadName
        {
            get { return this.m_ThreadName; }
            set { m_ThreadName = value; }
        }


        public class SyncEvents
        {

            public enum EventType : int
            {
                Exist = 0,
                Work = 1,
            }

            public SyncEvents()
            {
                m_ExitEvent = new EventWaitHandle(false, EventResetMode.ManualReset);
                m_WorkEvent = new EventWaitHandle(false, EventResetMode.AutoReset);
                m_EventArray = new EventWaitHandle[2];
                m_EventArray[0] = m_ExitEvent;
                m_EventArray[1] = m_WorkEvent;
            }

            public EventWaitHandle ExitWaitHandle
            {
                get { return m_ExitEvent; }
            }

            public EventWaitHandle WorkWaitHandle
            {
                get { return m_WorkEvent; }
            }

            public EventWaitHandle[] EventHandleArray
            {
                get { return m_EventArray; }
            }

            private EventWaitHandle m_ExitEvent;
            private EventWaitHandle m_WorkEvent;
            private EventWaitHandle [] m_EventArray;
        };

        private void DoWork()
        {
            this.BeforeStart();
            int WaitResult;
            WaitResult = EventWaitHandle.WaitAny(this.SyncEventsHandle.EventHandleArray, m_WorkTimeOut, true);
            while (
                 (WaitResult == (int)SyncEvents.EventType.Work)
                 ||
                 (WaitResult == EventWaitHandle.WaitTimeout)
                )
            {
                if (!m_IsPause)
                {
                    if (!DoProcessor())
                    {
                        this.m_ExitObject.reason = PublicDefineDll.Enums.EExitReason.Finished;
                        break;
                    }
                }
                WaitResult = EventWaitHandle.WaitAny(this.SyncEventsHandle.EventHandleArray, m_WorkTimeOut, true);
            }
            if (WaitResult == (int)SyncEvents.EventType.Exist)
            {
                this.m_ExitObject.reason = PublicDefineDll.Enums.EExitReason.UserAbort;
            }
            this.BeforeExit(this.m_ExitObject);

        }

        protected abstract bool DoProcessor();

        protected virtual void BeforeExit(ExitObject eo)
        {
            System.Diagnostics.Debug.WriteLine(eo.ToString());
        }

        protected virtual void BeforeStart()
        {
            System.Diagnostics.Debug.WriteLine("Thread Start:" + this.ThreadName);
        }

        /// <summary>
        /// 在线程退出信号量有效之前的处理操作，不受退出时限限制
        /// 如果退出出时要做很长的耗时操作，重载这个函数实现
        /// 但由于这个函数很可能是主线程调用，因此要考虑同步和阻塞问题
        /// </summary>
        protected virtual void BeforeStoping()
        {
            System.Diagnostics.Debug.WriteLine("Thread stoping:" + this.ThreadName);
        }

        protected SyncEvents m_SyncEvents;
        protected Thread m_Thread;
        protected int m_ExitTimeout;
        protected int m_WorkTimeout;
        protected bool m_IsPause;
        protected string m_ThreadName;
        protected ExitObject m_ExitObject;
        protected bool m_IsStoping;
  
        public class ExitObject
        {
            public ExitObject()
            {
                this.Reset();
            }
            public void Reset()
            {
                this.exitCode = -1;
                this.reason = PublicDefineDll.Enums.EExitReason.Invalid;
                this.description = string.Empty;
                this.name = string.Empty;
            }

            public override string ToString()
            {
                StringBuilder sb = new StringBuilder();
                sb.Append("ThreadName: ");
                sb.Append(this.name);
                sb.Append("Reason: ");
                sb.Append(this.reason.ToString());
                sb.Append("Description: ");
                sb.Append(this.description);
                sb.Append("ExitCode: ");
                sb.Append(this.exitCode.ToString());
                return sb.ToString();
            }
            public string name;
            public int exitCode;
            public PublicDefineDll.Enums.EExitReason reason;
            public string description;
        }
    }

老夫心好啊。贴的是可以重用的线程类。内部用内核对象实现。可以实现2种模式
1 事件驱动模式：每次调用DoNextStep执行一次.把workTimeOut设置到最大就可以
2 循环模式：每过一定时间，循环执行。
3 用户自己实现 DoProcessor()接口，完成工作。return true 继续 return false 退出

CMyThread : public CBaseProcessor
{
public CMyThread():: base(200, 500){ //200线程退出最大等待时间；//500线程每次执行等待时间
}
protected override bool DoProcessor(){
返回true继续转。
返回false退出。
}
}

[MrGaoGao]

我现在也遇到和楼主相似的问题，请问楼主解决与否？！请指教~~~~~

[happytonice]

好东西不少