多线程和进度条的使用

Question

参考了这篇文章，基本可以实现。
但在更新进度条时，是在线程执行结束以后调用，假如说线程执行时间相同，进度更新看起来会很均匀，假如时间不定，如何处理？
而且多个线程执行并更新进度条，那肯定会有冲突，我的想法是，在主程序中设一计数值，记录完成数量，然后根据这个值得到进度情况。希望是能每秒更新进度条，该如何处理？难道是定时器？http://blog.csdn.net/nihongyuan/archive/2009/01/14/3773687.aspx
第二步：定义一个代理，用于更新ProgressBar的值（Value）        //更新进度列表
        private delegate void SetPos(int ipos);  
 第三步：进度条值更新函数（参数必须跟声明的代理参数一样）
        private void SetTextMessage(int ipos)
        {
            if (this.InvokeRequired)
            {
                SetPos setpos = new SetPos(SetTextMessage);
                this.Invoke(setpos, new object[] { ipos});
            }
            else
            {
                this.label1.Text = ipos.ToString() + "/100";
                this.progressBar1.Value = Convert.ToInt32(ipos);
            }
        }
第四步：函数实现        private void button1_Click(object sender, EventArgs e)
        {
            Thread fThread = new Thread(new ThreadStart(SleepT));//开辟一个新的线程
            fThread.Start();
        }
第五步：新的线程执行函数：        private void SleepT()
        {
            for (int i = 0; i < 500; i++)
            {
                System.Threading.Thread.Sleep(100);//没什么意思，单纯的执行延时
                SetTextMessage(100 * i / 500);
            }
        }

Answer 1

时间或这工作量实在无法估计，那么进度条也没什么意义，可以换成Loading...的那种动画。
多线程处理的话，设个公共变量比如value，每个线程完成一件事的时候就
lock(value)
{
value++;
}
value可以是一个自定义类型，值变化时就去跟新进度条。

Answer 2

delegate void HandleInterfaceUpdateDelegate();  //委托，此为重点 
        HandleInterfaceUpdateDelegate interfaceUpdateHandle; 
      Thread td; 
        public formMain() 
        { 
            InitializeComponent(); 
            interfaceUpdateHandle = new HandleInterfaceUpdateDelegate(StartPro); //实例化委托对象 
        } 
在你进行操作的方法里第一句加上： 
this.Invoke(interfaceUpdateHandle);//用指定的参数列表执行指定的委托 最后一行加上： 
td.Abort(); 
这是相关的方法。 
private void chang() 
        { 
            ProcessBar obj = new ProcessBar();注:ProcessBar是你放置图片的窗口 
            obj.ShowDialog(); 
        }         
        public void StartPro() 
        { 
            td= new Thread(chang); 
            td.Start(); 
        } 

Answer 3

http://topic.csdn.net/u/20090804/15/1fdb9202-22bf-47b8-8650-3f9596d82ff3.html

Answer 4

修改后的代码private int ComplentCount = 0;
        //更新进度列表
        private delegate void SetPos();  
         private void SetTextMessage()
        {
            if (this.InvokeRequired)
            {
                SetPos setpos = new SetPos(SetTextMessage);
                this.Invoke(setpos);
            }
            else
            {
                //this.label1.Text = ipos.ToString() + "/100";
                //this.progressBar1.Value = Convert.ToInt32(ipos);                if (ComplentCount < 20)
                {
                    this.label1.Text = ComplentCount.ToString();
                    progressBar1.Maximum = 20;
                    progressBar1.Value = ComplentCount;
                }
            }
        }        private void button1_Click(object sender, EventArgs e)
        {
            Thread fThread = new Thread(new ThreadStart(SleepT));//开辟一个新的线程
            fThread.Start();
        }        private void SleepT()
        {
            Random random = new Random(10);
            int t = random.Next(10);
            System.Threading.Thread.Sleep(t*100);//没什么意思，单纯的执行延时                lock ((object)ComplentCount)
                {
                    ComplentCount++;
                } 
                SetTextMessage();
        }@libinguest
你的方法也没错，但更新进度条的方法，使用了新线程，更新主界面可能有问题。
当然不同方案有不同的实现方法。

Answer 5

异步回调的话不如用BackGroundWorker
有报告进度int数的属性举个简单的例子using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using System.Threading;namespace ConsoleBackgroundworker
{
    class Program
    {
        static BackgroundWorker bw;        static void Main()
        {
            bw = new BackgroundWorker();
            bw.WorkerReportsProgress = true;
            bw.WorkerSupportsCancellation = true;
            bw.DoWork += bw_DoWork;
            bw.ProgressChanged += bw_ProgressChanged;
            bw.RunWorkerCompleted += bw_RunWorkerCompleted;
            bw.RunWorkerAsync("Hello to worker");
            Console.WriteLine("Press Enter in the next 5 seconds to cancel");
            Console.ReadLine();
     
   
            if (bw.IsBusy)
                bw.CancelAsync();
            Console.ReadLine();
        }        static void bw_DoWork(object sender, DoWorkEventArgs e)
        {
            for (int i = 0; i <= 100; i += 1)
            {
                if (bw.CancellationPending)
                {
                    e.Cancel = true; return;
                }
                bw.ReportProgress(i);
                Thread.Sleep(100);
                e.Result = i;  
            }
             // 传递给 RunWorkerCopmleted 
        }        static void bw_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            if (e.Cancelled)
                Console.WriteLine("You cancelled!");
            else if (e.Error != null)
                Console.WriteLine("Worker exception: " + e.Error.ToString());
            else
            {
                Console.WriteLine("Complete - "+ e.Result);      // 从 DoWork 
            }
        }        static void bw_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            //Console.WriteLine("Reached " + e.ProgressPercentage + "%");
            Console.Write("{0,3}\b\b\b", e.ProgressPercentage);
               //Console.Write("{0,6}%", e.ProgressPercentage);
        }
    }
}

Answer 6

用BackgroundWorker似乎不错，少了对线程的直接操作。
似乎更傻瓜些。刚刚接触线程，慢慢学习。