图像处理中，有很多算法由于其内在的复杂性是天然的耗时大户，加之图像本身蕴涵的数据量比一般的对象就大，因此，针对这类算法，执行速度的提在很大程度上依赖于硬件的性能，现在流行的CPU都是至少2核的，稍微好点的4核，甚至8核，因此，如果能充分利用这些资源，必将能发挥机器的强大优势，为算法的执行效果提升一个档次。

     在单核时代，多线程程序的主要目的是防止UI假死，而一般情况下此时多线程程序的性能会比单线程的慢，这种情况五六年前是比较普遍的，所有哪个时候用VB6写的图像程序可能比VC6的慢不了多少。可在多核时代，多线程的合理利用可以使得程序速度线性提升。

     在一般的编程工具中，都有提供线程操作的相关类。比如在VS2010中，提供了诸如System.Threading、System.Threading.Tasks等命名空间，方便了大家对多线程程序的编制。但是直接的使用Threading类还是很不方便，为此，在C#的几个后续版本中，加入了Parallel这样的并行计算类，在实际的编码中，配合Partitioner.Create方法，我们会发现这个类特别适合于图像处理中的并行计算，比如下面这个简单的代码就实现去色算法的并行计算：

private void Desaturate(Bitmap Bmp)

{

    if (Bmp.PixelFormat == PixelFormat.Format24bppRgb)

    {

        BitmapData BmpData = Bmp.LockBits(new Rectangle(0, 0, Bmp.Width, Bmp.Height), ImageLockMode.ReadOnly, Bmp.PixelFormat);

        Parallel.ForEach(Partitioner.Create(0, BmpData.Height), (H) =>

        {

            int X, Y, Width, Height, Stride;

            byte Red, Green, Blue, Max, Min, Value;

            byte* Scan0, CurP;

            Width = BmpData.Width; Height = BmpData.Height; Stride = BmpData.Stride; Scan0 = (byte*)BmpData.Scan0;

            for (Y = H.Item1; Y < H.Item2; Y++)

            {

                CurP = Scan0 + Y * Stride;

                for (X = 0; X < Width; X++)

                {

                    Blue = *CurP; Green = *(CurP + 1); Red = *(CurP + 2);

                    if (Blue > Green)

                    {

                        Max = Blue;

                        Min = Green;

                    }

                    else

                    {

                        Max = Green;

                        Min = Blue;

                    }

                    if (Red > Max)

                        Max = Red;

                    else if (Red < Min)

                        Min = Red;

                    Value = (byte)((Max + Min) >> 1);

                    *CurP = Value; *(CurP + 1) = Value; *(CurP + 2) = Value;

                    CurP += 3;

                }

            }

        });

        Bmp.UnlockBits(BmpData);

    }

　　去色的原理就是取彩色图像RGB通道最大值和最小值的平均值作为新的三通道的颜色值。
    做个速度比较：

   图像大小     单线程时间/ms     多线程时间/ms 
   1024*768          5                  2 
   1600*1200         15                 8 
   4000*3000         117                60 
 
   去色是轻量级的数字图像算法，但是再多核CPU上依然能够发挥多线程的速度优势。 

   我们在看看复杂点的算法的例子，这里我们举一个缩放模糊的例子。

public static void ZoomBlur(Bitmap Bmp, int SampleRadius = 100, int Amount = 100, int CenterX = 256, int CenterY = 256)

{

    int Width, Height, Stride;

    BitmapData BmpData = Bmp.LockBits(new Rectangle(0, 0, Bmp.Width, Bmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb);

    Width = BmpData.Width; Height = BmpData.Height; Stride = BmpData.Stride;



    byte* BitmapClone = (byte*)Marshal.AllocHGlobal(BmpData.Stride * BmpData.Height);

    CopyMemory(BitmapClone, BmpData.Scan0, BmpData.Stride * BmpData.Height);



    Parallel.ForEach(Partitioner.Create(0, Height, Height / Environment.ProcessorCount), (H) =>

    {

        int SumRed, SumGreen, SumBlue,Fx, Fy, Fcx, Fcy;

        int X, Y, I;

        byte* Pointer, PointerC;

        uint* Row, RowP;

        Fcx = CenterX << 16 + 32768;

        Fcy = CenterY << 16 + 32768;



        Row = (uint*)Marshal.AllocHGlobal(SampleRadius * 4);

        for (Y = H.Item1; Y < H.Item2; Y++)

        {

            Pointer = (byte*)BmpData.Scan0 + Stride * Y;

            Fy = (Y << 16) - Fcy;

            RowP = Row;

            for (I = 0; I < SampleRadius; I++)

            {

                Fy -= ((Fy >> 4) * Amount) >> 10;

                *RowP = (uint)(BitmapClone + Stride * ((Fy + Fcy) >> 16));

                RowP++;

            }

            for (X = 0; X < Width; X++)

            {

                Fx = (X << 16) - Fcx;

                SumRed = 0; SumGreen = 0; SumBlue = 0;

                RowP = Row;

                for (I = 0; I < SampleRadius; I++)

                {

                    Fx -= ((Fx >> 4) * Amount) >> 10;

                    PointerC = (byte*)*RowP + ((Fx + Fcx) >> 16) * 3;       // *3不需要优化，编译器会变为lea eax,[eax+eax*2]        

                    SumBlue += *(PointerC);

                    SumGreen += *(PointerC + 1);

                    SumRed += *(PointerC + 2);

                    RowP++;

                }

                *(Pointer) = (byte)(SumBlue / SampleRadius);

                *(Pointer + 1) = (byte)(SumGreen / SampleRadius);

                *(Pointer + 2) = (byte)(SumRed / SampleRadius);

                Pointer += 3;

            }

        }

        Marshal.FreeHGlobal((IntPtr)Row);

    });

    Marshal.FreeHGlobal((IntPtr)BitmapClone);           // 释放掉备份数据

    Bmp.UnlockBits(BmpData);

}

 其中的CopyMemory函数声明如下：

[DllImport("Kernel32.dll", EntryPoint = "RtlMoveMemory", SetLastError = true)]
internal static extern void CopyMemory(byte* Dest, byte* src, int Length);
      
我们看看速度提升：

图像大小  单线程时间（ms）  多线程时间(ms)    PS用时(s) 
1024*768      926                556             0.7 
1600*1200     2986              1214             1.5 
4000*3000     21249              6047            7.2 


   从上图中可以看到，图像越大，单线程和多线程之间的时间比例就越大，也越能发挥多线程的优势。

   源码及更多分析详见：http://www.cnblogs.com/Imageshop/p/3344103.html
   

 *********作者： laviewpbt 时间： 2013.9.28  联系QQ:  33184777  转载请保留本行信息*********