在好例子网,分享、交流、成长!
您当前所在位置:首页C# 开发实例C#语言基础 → 自己学习的线程thread

自己学习的线程thread

C#语言基础

下载此实例
  • 开发语言:C#
  • 实例大小:0.04M
  • 下载次数:33
  • 浏览次数:221
  • 发布时间:2021-02-10
  • 实例类别:C#语言基础
  • 发 布 人:Manb
  • 文件格式:.rar
  • 所需积分:20
 相关标签: 自己学习的

实例介绍

【实例1】

namespace AyncDemo
{
    public partial class FrmAync : Form
    {
        public FrmAync()
        {
            InitializeComponent();
        }

        //同步
        private void btnTest1_Click(object sender, EventArgs e)
        {   this.lblInfo2.Text = ExecuteTask2(20).ToString();
            this.lblInfo1.Text = ExecuteTask1(10).ToString();
           
        }
        //【2】 委托方法
        int ExecuteTask1(int num)
        {
            Thread.Sleep(5000);
            return num * num;
        }
        int ExecuteTask2(int num)
        {
           
            return num * num;
        }

        //异步
        private void btnTest2_Click(object sender, EventArgs e)
        {
            //【3】关联
            MyCalculator myCalculator = ExecuteTask1;
            
            IAsyncResult result = myCalculator.BeginInvoke(10, null, null);
            lblInfo2.Text = ExecuteTask2(20).ToString();
            this.lblInfo1.Text = "正在计算请稍等...";
            int r = myCalculator.EndInvoke(result);
            lblInfo1.Text=r.ToString();
           
        }

        //【1】创建委托
        public delegate int MyCalculator(int num);
    }
}

【实例2】

namespace AsyncCallBackDemo
{
    public partial class FrmAsynCallBack : Form
    {
        
        //【1】 声明委托
        public delegate int MyCalculator(int num, int ms);
        public FrmAsynCallBack()
        {
            InitializeComponent();
            //【3】初始化委托变量
           // this.objMyCal = new MyCalculator(ExecuteTask);
            //Lambda表达式
            this.objMyCal = (num, ms) =>
            {
                System.Threading.Thread.Sleep(ms);
                return num * num;
            };
        }

        //【4】同时执行多个任务
        private void btnExec_Click(object sender, EventArgs e)
        {
            for (int i = 1; i < 11; i )//产生10个任务
            {
                //开始异步执行,并封装回调函数 objMyCal.BeginInvoke(10 * i, 1000 * i, null, i);
                objMyCal.BeginInvoke(10 * i, 1000 * i, MyCallBack, i);
                //最后一个参数 i 给回调函数的字段AsyncState赋值,如果数据很多可以定义成类或结构

                IAsyncResult result= objMyCal.BeginInvoke(10 * i, 1000 * i, MyCallBack, i);

              
                
            }

        }
        //【5】回调函数
        private void MyCallBack(IAsyncResult result)
        {
            int res = objMyCal.EndInvoke(result);

            //异步显示结果:result.AsyncState字段用来封装回调时自定义的参数,object类型
            Console.WriteLine("第{0}个计算结果为:{1}", result.AsyncState.ToString(), res);
        }

        /// <summary>
        /// 【2】根据委托定义一个方法:返回一个数的平方
        /// </summary>
        /// <param name="num">基数</param>
        /// <param name="ms">延迟的时间:秒</param>
        /// <returns></returns>
        private int ExecuteTask(int num, int ms)
        {
            System.Threading.Thread.Sleep(ms);
            return num * num;
        }

        //【3】创建委托变量(因为异步函数和回调函数都要用,所以定义成员变量)
        private MyCalculator objMyCal = null;

    }
}

【实例3】

namespace ThreadTest
{
    public partial class FrmThreadText : Form
    {
        public delegate void Deleage(int a);


        public FrmThreadText()
        {
            InitializeComponent();

            Task task = new Task(new Action<object>((s) => { textBox1.Text = s.ToString(); }), 1);
            task.Start();


            Task task1 = new Task(delegate (object s) { textBox1.Text = s.ToString(); }, 10);
            task1.Start();

            Action<int> action = new Action<int>(test1);
            action(1);

            Action<int> action1 = delegate (int a) { this.textBox1.Text = a.ToString(); };
            action1(10);

            Action<int> action2 = (a) =>
            {
                this.textBox1.Text = a.ToString();

            };

            action2.Invoke(10);

            textBox1.Invoke(new Action<int>(s => textBox1.Text = s.ToString()), 10);

            textBox1.Invoke(new Action<int>((s) => { textBox1.Text = s.ToString(); }), 10);

            textBox1.Invoke(new Action<int>((s) => { textBox1.Text = s.ToString(); }), 10);

            textBox1.Invoke(new Action<int>(s=> { textBox1.Text = s.ToString(); } ),10);

            textBox1.Invoke((WaitCallback)delegate(object s){ textBox1.Text = s.ToString(); },10);

           

            Deleage deleage1 = new Deleage(test1);

            Deleage deleage2 = delegate (int s) { this.textBox1.Text = s.ToString(); };

            Deleage deleage3 = (s) => { this.textBox1.Text = s.ToString(); };

            Deleage deleage4 = s => this.textBox1.Text = s.ToString();



            void test1(int a)
            {
                this.textBox1.Text = a.ToString();
            }
        }
            private void btnExecute1_Click(object sender, EventArgs e)
        {
            Thread objThread1 = new Thread(delegate()
            {
                for (int i = 1; i <= 20; i )
                {
                    Console.WriteLine(i  "  ");
                    Thread.Sleep(500);
                }                  
            });
            objThread1.IsBackground = true;
            objThread1.Start();
        }

        private void btnExecute2_Click(object sender, EventArgs e)
        {
            Thread objThread2 = new Thread(()=>
            {
                for (int i = 0; i <= 50; i )
                {
                    Console.WriteLine("-----------------a" i "----------------");
                    Thread.Sleep(100);
                }               
            });
            objThread2.IsBackground = true;
            objThread2.Start();
        }
    }
}

【实例4】

namespace _04_CrossThreadVistControl
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void btnExecute1_Click(object sender, EventArgs e)
        {
            int a = 0;
            Thread thread1 = new Thread(() =>
            {
                for (int i = 1; i <= 100; i )
                {
                    a = i;
                    if (lblResult1.InvokeRequired)
                    {
                        //this.lblResult1.Invoke(new Action<int>((s) => { lblResult1.Text = s.ToString(); }), a);
                        this.lblResult1.Invoke((ParameterizedThreadStart)delegate (object s) { lblResult1.Text = s.ToString(); }, a);
                        Thread.Sleep(200);
                        /*
                          public delegate void ThreadStart();
                          public delegate void MethodInvoker();
                          public delegate void WaitCallback(object state);
                          public delegate void ParameterizedThreadStart(object obj);
                          public delegate void AsyncCallback(IAsyncResult ar);                        
                         */
                    }
                }
            });
            thread1.IsBackground = true;
            thread1.Start();

        }

        private void btnExecute2_Click(object sender, EventArgs e)
        {
            int a=0;
            Thread thread2 = new Thread(delegate() {
                for (int i = 1; i <= 100; i )
                {
                    a = i;
                    if (btnExecute2.InvokeRequired)
                    {
                        lblResult2.Invoke(new Action<int>((s)=> { lblResult2.Text = s.ToString(); }),a);
                    }
                    Thread.Sleep(500);
                }          
            });
            thread2.IsBackground = true;
            thread2.Start();
        }
    }
}

【5】

namespace _05_CrossThreadVistDataBase
{
    public partial class FrmDataBase : Form
    {
        public FrmDataBase()
        {
            InitializeComponent();
        }

        private void btnExecute1_Click(object sender, EventArgs e)
        {
            //Thread objThread1 = new Thread(() =>
            //{
            //    Thread.Sleep(3000);
            //    string classCount = _05_CrossThreadVistDataBase.SQLHelper.GetSingleResult("select count(*) from StudentClass").ToString();
            //    this.lblResult1.Invoke(new Action<string>(c => { this.lblResult1.Text = c; }), classCount);
            //});
            //objThread1.IsBackground = true;
            //objThread1.Start();

            Thread objThread1 = new Thread(()=>
            {
                Thread.Sleep(300);
              
                string classCount= _05_CrossThreadVistDataBase.SQLHelper.GetSingleResult("select count(*) from StudentClass").ToString();
                this.lblResult1.Invoke(new Action<string>((c) => { this.lblResult1.Text = c; }), classCount);
            });
            objThread1.IsBackground = true;
            objThread1.Start();
        }

        private void btnExecute2_Click(object sender, EventArgs e)
        {
            Thread objThread2 = new Thread(() =>
            {
                Thread.Sleep(300);
                string stuCount = _05_CrossThreadVistDataBase.SQLHelper.GetSingleResult("select count(*) from Students").ToString();
                this.lblResult2.Invoke(new Action<string>(s => { this.lblResult2.Text = s; }), stuCount);
            });
            objThread2.IsBackground = true;
            objThread2.Start();
        }

        private void btnGetData_Click(object sender, EventArgs e)
        {
            
            Thread objThread3 = new Thread(() =>
            {
                Thread.Sleep(200);
                //string stuCount = DBUtility.SQLHelper.GetSingleResult("select count(*) from Students").ToString();
                //this.lblResult2.Invoke(new Action<string>(s => { this.lblResult2.Text = s; }), stuCount);

                //访问数据库
                DataSet ds = _05_CrossThreadVistDataBase.SQLHelper.GetDataSet("select *  from StudentClass;select StudentName,Gender,PhoneNumber from Students");
                DataTable dt1 = ds.Tables[0];
                DataTable dt2 = ds.Tables[1];

                this.dgv1.Invoke(new Action<DataTable>(c => { this.dgv1.DataSource = c; }), dt1);

                Thread.Sleep(200);
                this.dgv2.Invoke(new Action<DataTable>(s => { this.dgv2.DataSource = s; }), dt2);

            });
            objThread3.IsBackground = true;
            objThread3.Start();
        }
    }
}

【实例6】

namespace _06_ProcessDemo
{
    public partial class FrmProcess : Form
    {
        public FrmProcess()
        {
            InitializeComponent();
        }

        //进程:每一个独立运行的程序都是进程。操作系统有《进程管理模块》管理同时运行的多个程序。
        //进程和线程:一个进程可以包含若干线程。
        //句柄:(Handle)句柄是一个标识符,用于代表操作系统中的各种资源。比如各种窗体、CDI绘制的对象、进程和线程对象、文件等都拥有句柄。
        //句柄使用1:即使进程退出,有很多时候操作系统仍然保持进程句柄。操作系统句柄有限,使用中要节省,比如打开文件后,使用完毕要及时关掉。
        //句柄使用2:句柄可以通过Process对象的Handle属性访问,比如进程退出的代码、时间等。
        //总结提高:拥有图形界面的程序都有一个主窗体,此窗体也对应一个句柄。当主窗体关闭的时候进程也关闭。主窗体一般由主线程负责创建。

        #region 获取本机所有进程
        private System.Diagnostics.Process[] allProcesses = null;
        private void btnGetProcessess_Click(object sender, EventArgs e)
        {
            allProcesses = System.Diagnostics.Process.GetProcesses();//获取本机的所有进程
            this.lbProcess.Items.Clear();
            foreach (System.Diagnostics.Process item in allProcesses)
            {
                this.lbProcess.Items.Add(item.ProcessName);
            }
        }
        #endregion

        private void lbProcess_Click(object sender, EventArgs e)
        {
            if (this.lbProcess.Items.Count == 0)
            {
                return;
            }
            else
            {
                this.lbModels.Items.Clear();              
            }
            System.Diagnostics.Process currentProcess = allProcesses[this.lbProcess.SelectedIndex];
            try
            {
                //获取当前进程所调用的模块(有些进程会拒绝访问)
                ProcessModuleCollection models = currentProcess.Modules;
                foreach (ProcessModule item in models)
                {
                    this.lbModels.Items.Add(item.FileName);
                }
                //for (int i = 0; i < models.Count; i )
                //{
                //    this.lbModels.Items.Add(models[i].FileName);
                //}
                //显示当前进程的基本信息
                string info = @"进程的唯一标识符(Id):" currentProcess.Id "\r\n\r\n";
                info = "关联进程的本机句柄(Handle):" currentProcess.Handle "\r\n\r\n";
                info = "打开的句柄数(HandleCount):" currentProcess.HandleCount "\r\n\r\n";
                info = "关联进程的基本优先级:" currentProcess.BasePriority "\r\n\r\n";
                info = "进程启动的时间:" currentProcess.StartTime;
                this.txtProcessInfo.Text = info;
            }
            catch (Exception ex)
            {

                MessageBox.Show(ex.Message);
            }
            
        }

        private void btnKill_Click(object sender, EventArgs e)
        {
            if (this.lbProcess.Items.Count == 0 || this.lbProcess.SelectedIndex == -1) return;
            System.Diagnostics.Process currentProcess = allProcesses[this.lbProcess.SelectedIndex];//获取当前选中的进程

            currentProcess.Kill();//立即停止关联的进程
            currentProcess.Close();//释放进程资源

            this.lbProcess.Items.RemoveAt(this.lbProcess.SelectedIndex);
            this.lbModels.Items.Clear();
            this.txtProcessInfo.Clear();
        }
        //开启一个新的进程(如:iexplore.exe;notepad.exe;D:\abc.pptx)
        //在windows环境变量里面没有注册的,需要使用路径

        private void btnStartnew_Click(object sender, EventArgs e)
        {

            System.Diagnostics.Process.Start(this.txtProcessName.Text.Trim());
                
            
           
        }
    }
}

【实例7】


namespace _07_ThreadLock
{
    class Program
    {
        static void Main(string[] args)
        {
            Thread.CurrentThread.Name = "------------------主线程";
            Program objDemo = new Program();

            Thread objNewThread = new Thread(new ThreadStart(objDemo.ActionMethod));
            objNewThread.Name = "子线程";

            objNewThread.Start();//开始子线程,并为该线程执行ActionMethod
            objDemo.ActionMethod();//让主线程执行ActionMethod

            Console.ReadLine();
        }

        private int counter = 0;
        ////被线程调用的方法【未使用线程安全措施】
        //private void ActionMethod()
        //{         
        //        for (int count = 1; count <= 100; count )
        //        {
        //            counter = count;
        //            Console.WriteLine("{0}\t{1}", Thread.CurrentThread.Name, counter);
        //            //Thread.Sleep(80);
        //        }
        //}


        //// //使用线程安全方法
        //private void ActionMethod()
        //{
        //    //    //lock关键字可以确保一次只有一个线程调用它。
        //    //    //lock关键字可以简单理解成代码块的“锁”。
        //    lock (this)
        //    {
        //        for (int count = 1; count <= 100; count )
        //        {
        //            counter = count;
        //            Console.WriteLine("{0}\t{1}", Thread.CurrentThread.Name, counter);
        //            //Thread.Sleep(80);
        //        }
        //    }

        //private void ActionMethod()
        //{
        //    //    //lock关键字可以确保一次只有一个线程调用它。
        //    //    //lock关键字可以简单理解成代码块的“锁”。
        //    lock (this)
        //    {
        //        for (int count = 1; count <= 100; count )
        //        {
        //            counter = count;
        //            Console.WriteLine("{0}\t{1}", Thread.CurrentThread.Name, counter);
        //            //Thread.Sleep(80);
        //        }
        //    }
        //}

        //为了方便日常使用,提供了一个方法属性来实现同样的功能。
       // [MethodImpl(MethodImplOptions.Synchronized)]
        private void ActionMethod()
        {
            for (int count = 1; count <= 10; count )
            {
                counter = count;
                Console.WriteLine("{0}\t{1}", Thread.CurrentThread.Name, counter);
                Thread.Sleep(80);
            }
        }
    }

}

【8】

namespace _08_ThreadSafetyDemo
{
    public partial class FrmThreadSafety : Form
    {
        public FrmThreadSafety()
        {
            InitializeComponent();
            //设置属性
            this.backgroundWorker1.WorkerReportsProgress = true;
            this.backgroundWorker1.WorkerSupportsCancellation = true;
        }

        //【1】开始后台要执行的任务        
        private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
        {
            BackgroundWorker bw = sender as BackgroundWorker;
            int result = 0;
            for (int i = 0; i <= 100; i )
            {
                if (bw.CancellationPending)
                {
                    e.Cancel = true;//该结果会被传送到RunWorkerCompleted事件中
                    return;
                }
                result = i;//累加
                //报告进度(同时触发ProgressChanged事件)
                //报告操作进度。调用该方法后,将触发BackgroundWorker. ProgressChanged事件。
                //另外,该方法包含了一个int类型的参数percentProgress,用来表示当前异步操作所执行的进度百分比。
                bw.ReportProgress(i, "已完成了" i.ToString() "%");

                Thread.Sleep((int)e.Argument);//外部传入的参数:200,休眠特定的时间
                e.Result = result;//向外界返回1 2 ...100的值
            }
        }
        //【2】汇报后台工作进展情况
        private void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            this.progressBar1.Value = e.ProgressPercentage;//显示百分比
            lblInfo.Text = e.UserState.ToString();//显示文字信息。
        }
        //【3】后台任务完成
        private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            if (e.Cancelled)
            {
                toolStripStatusLabel1.Text = "用户取消了操作";
                btnStart.Enabled = true;
                return;
            }
            if (e.Error != null)
            {
                toolStripStatusLabel1.Text = e.Error.Message;
                return;
            }
            lblResult.Text = e.Result.ToString();//显示计算结果
            btnStart.Enabled = true;
            toolStripStatusLabel1.Text = "计算完成";
        }
        //开始任务
        private void btnStart_Click(object sender, EventArgs e)
        {
            lblResult.Text = "?";
            lblResult.Refresh();

            //启动线程(参数:200代表线程休眠的时间)
            backgroundWorker1.RunWorkerAsync(200);

            btnStart.Enabled = false;
            toolStripStatusLabel1.Text = "正在工作……";
        }
        //取消任务
        private void btnCancel_Click(object sender, EventArgs e)
        {
            backgroundWorker1.CancelAsync();
        }
        //关闭
        private void btnClose_Click(object sender, EventArgs e)
        {
            this.Close();
        }
    }
}

【实例9】

namespace Async
{
    class Program
    {
        //    class Rectangle
        //    {
        //        // 成员变量
        //        protected double length;
        //        protected double width;
        //        public Rectangle(double l, double w)
        //        {
        //            length = l;
        //            width = w;
        //        }
        //        public double GetArea()
        //        {
        //            return length * width;
        //        }
        //        public void Display()
        //        {
        //            Console.WriteLine("长度: {0}", length);
        //            Console.WriteLine("宽度: {0}", width);
        //            Console.WriteLine("面积: {0}", GetArea());
        //        }
        //    }//end class Rectangle  
        //    class Tabletop : Rectangle
        //    {
        //        private double cost;
        //        public Tabletop(double l, double w) : base(l, w)
        //        { }
        //        public double GetCost()
        //        {
        //            double cost;
        //            cost = GetArea() * 70;
        //            return cost;
        //        }
        //        public void Display()
        //        {
        //            base.Display();
        //            Console.WriteLine("成本: {0}", GetCost());
        //        }
        //    }
        //    class ExecuteRectangle
        //    {
        //        static void Main(string[] args)
        //        {
        //            Tabletop t = new Tabletop(4.5, 7.5);
        //            t.Display();
        //            Console.ReadLine();
        //        }
        //    }

        //}

        //class Shape
        //{
        //    public void setWidth(int w)
        //    {
        //        width = w;
        //    }
        //    public void setHeight(int h)
        //    {
        //        height = h;
        //    }
        //    protected int width;
        //    protected int height;
        //}

        //// 派生类
        //class Rectangle : Shape
        //{
        //    public int getArea()
        //    {
        //        return (width * height);
        //    }
        //}

        //class RectangleTester
        //{
        //    static void Main(string[] args)
        //    {
        //        Rectangle Rect = new Rectangle();

        //        Rect.setWidth(5);
        //        Rect.setHeight(7);

        //        // 打印对象的面积
        //        Console.WriteLine("总面积: {0}", Rect.getArea());
        //        Console.ReadKey();
        //    }
        //}

       
            //声明CancellationTokenSource对象
            static CancellationTokenSource cts = new CancellationTokenSource();

            static void Main(string[] args)
            {
                Console.WriteLine("==========取消单个任务==========");

                //将cts.Token传入任务中,在外部通过控制cts实现对任务的控制
                Task.Factory.StartNew(MyTask, cts.Token);

                Console.WriteLine("请按回车键停止");
                Console.ReadLine();

                cts.Cancel();//传达取消请求

                Console.WriteLine("已停止");
                Console.ReadLine();
            }

            static void MyTask()
            {
                //判断任务是否取消,如果取消则跳出本次循环
                while (!cts.IsCancellationRequested)
                {
                    Console.WriteLine("当前时间:" DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff"));
                    Thread.Sleep(1000);
                }
            }
        

    }
    public sealed class Singleton
    {
        public static volatile Singleton instance = null;
        public static readonly object padlock = new object();

        Singleton()
        {
        }

        public static Singleton Instance
        {
            get
            {
                if (instance == null)
                {
                    lock (padlock)
                    {
                        if (instance == null)
                        {
                            instance = new Singleton();
                        }
                    }
                }
                return instance;
            }
        }
    }
}

标签: 自己学习的

实例下载地址

自己学习的线程thread

不能下载?内容有错? 点击这里报错 + 投诉 + 提问

好例子网口号:伸出你的我的手 — 分享

网友评论

发表评论

(您的评论需要经过审核才能显示)

查看所有2条评论>>

小贴士

感谢您为本站写下的评论,您的评论对其它用户来说具有重要的参考价值,所以请认真填写。

  • 类似“顶”、“沙发”之类没有营养的文字,对勤劳贡献的楼主来说是令人沮丧的反馈信息。
  • 相信您也不想看到一排文字/表情墙,所以请不要反馈意义不大的重复字符,也请尽量不要纯表情的回复。
  • 提问之前请再仔细看一遍楼主的说明,或许是您遗漏了。
  • 请勿到处挖坑绊人、招贴广告。既占空间让人厌烦,又没人会搭理,于人于己都无利。

关于好例子网

本站旨在为广大IT学习爱好者提供一个非营利性互相学习交流分享平台。本站所有资源都可以被免费获取学习研究。本站资源来自网友分享,对搜索内容的合法性不具有预见性、识别性、控制性,仅供学习研究,请务必在下载后24小时内给予删除,不得用于其他任何用途,否则后果自负。基于互联网的特殊性,平台无法对用户传输的作品、信息、内容的权属或合法性、安全性、合规性、真实性、科学性、完整权、有效性等进行实质审查;无论平台是否已进行审查,用户均应自行承担因其传输的作品、信息、内容而可能或已经产生的侵权或权属纠纷等法律责任。本站所有资源不代表本站的观点或立场,基于网友分享,根据中国法律《信息网络传播权保护条例》第二十二与二十三条之规定,若资源存在侵权或相关问题请联系本站客服人员,点此联系我们。关于更多版权及免责申明参见 版权及免责申明

;
报警