线程篇(一)

 public class ThreadStartTest 
    {
        //无参数的构造函数
        Thread thread = new Thread(new ThreadStart(ThreadMethod));
        //带有object参数的构造函数
        Thread thread2 = new Thread(new ParameterizedThreadStart(ThreadMethodWithPara));
        public ThreadStartTest() 
        {
            //启动线程1
            thread.Start();
            //启动线程2
            thread2.Start(new Parameter { paraName="Test" });
        }
        static void ThreadMethod() 
        {
           //....
        }
        static void ThreadMethodWithPara(object o) 
        {
            if (o is Parameter) 
            {
               // (o as Parameter).paraName.............
            }
        }


    }

    public class Parameter 
    {
        public string paraName { get; set; }
    }

     public static void ShowFatherAndSonThread(Thread grandFatherThread)
        {
            Console.WriteLine("爷爷主线程名：{0}", grandFatherThread.Name);
            Thread brotherThread = new Thread(new ThreadStart(() => { Console.WriteLine("兄弟线程名：{0}", Thread.CurrentThread.Name); }));
            Thread fatherThread = new Thread(new ThreadStart(
                () =>
                {
                    Console.WriteLine("父亲线程名：{0}", Thread.CurrentThread.Name);
                    Thread sonThread = new Thread(new ThreadStart(() =>
                    {
                        Console.WriteLine("儿子线程名：{0}", Thread.CurrentThread.Name);
                    }));
                    sonThread.Name = "SonThread";
                    sonThread.Start();
                }
                    ));
            fatherThread.Name = "FatherThread";
            brotherThread.Name="BrotherThread";
            fatherThread.Start();
            brotherThread.Start();
        }

        public static void ThreadJoin()
        {
            Console.WriteLine("我是爷爷辈线程,子线程马上要来工作了我得准备下让个位给他。");
            Thread t1 = new Thread(
                new ThreadStart
                    (
                     () =>
                     {
                         for (int i = 0; i < 10; i++)
                         {
                             if (i == 0)
                                 Console.WriteLine("我是父亲线层{0}, 完成计数任务后我会把工作权交换给主线程", Thread.CurrentThread.Name);
                             else
                             {
                                 Console.WriteLine("我是父亲线层{0}, 计数值:{1}", Thread.CurrentThread.Name, i);
                             }
                             Thread.Sleep(1000);
                         }
                     }
                    )
                );
            t1.Name = "线程1";
            t1.Start();
            //调用join后调用线程被阻塞
            t1.Join();
            Console.WriteLine("终于轮到爷爷辈主线程干活了");
        }

        public static void ThreadJoin2()
        {
            IList<Thread> threads = new List<Thread>();
            for (int i = 0; i < 3; i++)
            {
                Thread t = new Thread(
                    new ThreadStart(
                        () =>
                        {

                            for (int j = 0; j < 10; j++)
                            {
                                if (j == 0)
                                    Console.WriteLine("我是线层{0}, 完成计数任务后我会把工作权交换给其他线程", Thread.CurrentThread.Name);
                                else
                                {
                                    Console.WriteLine("我是线层{0}, 计数值:{1}", Thread.CurrentThread.Name, j);
                                }

                                Thread.Sleep(1000);
                            }
                        }));
                t.Name = "线程" + i;
                //将线程加入集合
                threads.Add(t);
            }

            foreach (var thread in threads)
            {
                thread.Start();
                //每次按次序阻塞调用次方法的线程
                thread.Join();
            }
        }

  static void Main(string[] args)
        {
            try
            {
                Thread.CurrentThread.Abort();
            }
            catch
            {
                //Thread.ResetAbort();
                Console.WriteLine("主线程接受到被释放销毁的信号");
                Console.WriteLine( "主线程的状态:{0}",Thread.CurrentThread.ThreadState);
            }
            finally
            {
                Console.WriteLine("主线程最终被被释放销毁");
                Console.WriteLine("主线程的状态:{0}", Thread.CurrentThread.ThreadState);
                Console.ReadKey();
            }
}

static void TestAbort() 
        {
            try
            {
                Thread.Sleep(10000);
            }
            catch 
            {
                Console.WriteLine("线程{0}接受到被释放销毁的信号",Thread.CurrentThread.Name);
                Console.WriteLine("捕获到异常时线程{0}主线程的状态:{1}", Thread.CurrentThread.Name,Thread.CurrentThread.ThreadState);
            }
            finally
            {
                Console.WriteLine("进入finally语句块后线程{0}主线程的状态:{1}", Thread.CurrentThread.Name, Thread.CurrentThread.ThreadState);
            }
        }

Main:
static void Main(string[] args)
        {
         
            Thread thread1 = new Thread(TestAbort);
            thread1.Name = "Thread1";
            thread1.Start();
            Thread.Sleep(1000);
            thread1.Abort();
            thread1.Join();
            Console.WriteLine("finally语句块后，线程{0}主线程的状态:{1}", thread1.Name, thread1.ThreadState);
            Console.ReadKey();
        }

        static void Main(string[] args)
        {
            Thread thread1 = new Thread(TestInterrupt);
            thread1.Name = "Thread1";
            thread1.Start();
            Thread.Sleep(1000);
            thread1.Interrupt();
            thread1.Join();
            Console.WriteLine("finally语句块后，线程{0}主线程的状态:{1}", thread1.Name, thread1.ThreadState);
            Console.ReadKey();
        }
        static void TestInterrupt() 
        {
            try
            {
                Thread.Sleep(3000);
            }
            catch (ThreadInterruptedException e)
            {
                Console.WriteLine("线程{0}接受到被Interrupt的信号", Thread.CurrentThread.Name);
                Console.WriteLine("捕获到Interrupt异常时线程{0}的状态:{1}", Thread.CurrentThread.Name, Thread.CurrentThread.ThreadState);
            }
            finally 
            {
                Console.WriteLine("进入finally语句块后线程{0}的状态:{1}", Thread.CurrentThread.Name, Thread.CurrentThread.ThreadState);
            }
        }

            Thread thread1 = new Thread(TestSuspend);
            Thread thread2 = new Thread(TestSuspend);
            thread1.Name = "Thread1";
            thread2.Name = "Thread2";
            thread1.Start();
            thread2.Start();
            //假设在做一些事情
            
            Thread.Sleep(1000);
            Console.WriteLine("需要主线程帮忙了");
            // throw new NullReferenceException("error!");
            thread1.Resume();
            thread2.Resume();

  static void TestSuspend() 
        {
            Console.WriteLine("Thread:{0} has been suspend!",Thread.CurrentThread.Name);
           //这里讲当前线程挂起
            Thread.CurrentThread.Suspend();
            Console.WriteLine("{0} has been resume", Thread.CurrentThread.Name);
        }

      static void TestSuspend() 
        {
            lock (lockObj)
            {
             。。。。
            }
        } 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Drawing;
using System.Windows.Interop;
using System.Threading;

namespace ImageFlip
{
    /// <summary>
    /// WPF  多线程将图片分割
    /// </summary>
    public partial class MainWindow : Window
    {
        BitmapSource source;
        private object lockObj = new object();
        public MainWindow()
        {
            InitializeComponent();
            //首先获取图片
            Bitmap orginalImage = new Bitmap(@"G:\Picture\Tamriel_4E.png");
            //创建线程1
            Thread t1 = new Thread(new ParameterizedThreadStart
                (
                  obj =>
                  {
                      //WPF中使用多线程的话最后一定要返回UI线程，否则操作界面控件时会报错
                      //BeginInvoke方法便是返回UI线程的方法
                      this.Dispatcher.BeginInvoke((Action)(() => 
                      {
                          //通过Parameter类的属性裁剪图片
                          ClipImageAndBind(obj); 
                          //图片的部分绑定到页面控件
                          this.TestImage1.Source = source;
                          
                      }));
                  }
                ));
            //创建线程2
            Thread t2 = new Thread(new ParameterizedThreadStart
            (
              obj =>
              {
                  //WPF中使用多线程的话最后一定要返回UI线程，否则操作界面控件时会报错
                  //BeginInvoke方法便是返回UI线程的方法
                  this.Dispatcher.BeginInvoke((Action)(() =>
                  {
                      //通过Parameter类的属性裁剪图片
                      ClipImageAndBind(obj);
                      //图片的部分绑定到页面控件
                      this.TestImage2.Source = source;
                      //尝试将线程1的启动逻辑放在线程2所持有的方法中
                     // t1.Start(new Parameter { OrginalImage = orginalImage, ClipHeight = 500, ClipWidth = 500, StartX = 0, StartY = 0 });
                  }));
              }
            ));
         
            t2.Start(new Parameter { OrginalImage = orginalImage, ClipHeight = 500, ClipWidth = 500, StartX = orginalImage.Width - 500, StartY = orginalImage.Height - 500 });
            //尝试下注释掉t2.join方法后是什么情况,其实注释掉之后，两个线程会一起工作，
            //去掉注释后，界面一直到两个图片部分都绑定完成后才出现
            //t2.Join();
            t1.Start(new Parameter { OrginalImage = orginalImage, ClipHeight = 500, ClipWidth = 500, StartX = 0, StartY = 0 });
        }

       /// <summary>
       /// 根据参数类进行剪裁图片，加锁防止共享资源被破坏
       /// </summary>
        /// <param name="para">Parameter类对象</param>
        private void ClipImageAndBind(object para)
        {
            lock (lockObj)
            {
                Parameter paraObject = (para as Parameter);
                source = this.ClipPartOfImage(paraObject);
                Thread.Sleep(5000);
            }
        }

        /// <summary>
        /// 具体裁剪图片，大家不必在意这个方法，关键是线程的使用
        /// </summary>
        /// <param name="para">Parameter</param>
        /// <returns>部分图片</returns>
        private BitmapSource ClipPartOfImage(Parameter para)
        {
            if (para == null) { throw new NullReferenceException("para 不能为空"); }
            if (para.OrginalImage == null) { throw new NullReferenceException("OrginalImage 不能为空"); }
            System.Drawing.Rectangle rect = new System.Drawing.Rectangle(para.StartX, para.StartY, para.ClipWidth, para.ClipHeight);
            var bitmap2 = para.OrginalImage.Clone(rect, para.OrginalImage.PixelFormat) as Bitmap;
            return ChangeBitmapToBitmapSource(bitmap2);
        }

        private BitmapSource ChangeBitmapToBitmapSource(Bitmap bmp)
        {
            BitmapSource returnSource;
            try
            {
                returnSource = Imaging.CreateBitmapSourceFromHBitmap(bmp.GetHbitmap(), IntPtr.Zero, Int32Rect.Empty, BitmapSizeOptions.FromEmptyOptions());
            }
            catch
            {
                returnSource = null;
            }
            return returnSource;
        }

    }
    
    /// <summary>
    /// 参数类
    /// </summary>
    public class Parameter
    {
        public Bitmap OrginalImage { get; set; }
        public int StartX { get; set; }
        public int StartY { get; set; }
        public int ClipWidth { get; set; }
        public int ClipHeight { get; set; }
    }

}

<Window x:Class="ImageFlip.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MainWindow" Height="350" Width="525">
    <Grid>
        <Grid.ColumnDefinitions>
            <ColumnDefinition></ColumnDefinition>
            <ColumnDefinition></ColumnDefinition>
        </Grid.ColumnDefinitions>
        <Image x:Name="TestImage1" Grid.Column="0"></Image>
        <Image x:Name="TestImage2" Grid.Column="1"></Image>
    </Grid>
</Window>