Task , Thread 学习

最新推荐文章于 2024-03-29 22:32:46 发布
最新推荐文章于 2024-03-29 22:32:46 发布
阅读量540 收藏
点赞数
分类专栏： Thread VS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sui84/article/details/38116609
版权
VS 同时被 2 个专栏收录
87 篇文章 0 订阅
订阅专栏
Thread
2 篇文章 0 订阅
订阅专栏


1.任务StartNew后就开始执行，使用Wait()来确保任务结束后继续 

static void Main(string[] args)
        {
            try
            {
                int numberOfUsers = 100;
                var users = new string[20];
                for (int i = 0; i < 20; i++)
                {
                    users[i] = string.Format("LoadTest{0}", i + 1);
                }

                Task t = Task.Factory.StartNew(() => WriteLog(users[5]));
                Thread.Sleep(5000);
                Console.WriteLine("Is first one start?");
                Task t1 = Task.Factory.StartNew(() => WriteLog(users[6]));
                Thread.Sleep(5000);
                Console.WriteLine("Are they start?");
                Thread.Sleep(5000);
                t1.Wait();
                Console.WriteLine("Will End soon!");
                t.Wait();
                Thread.Sleep(500000000);

            }
            catch (Exception ex)
            {
                Console.WriteLine(string.Format("Time {0}:{1}",DateTime.Now, ex.Message));
                Thread.Sleep(500000000);
            }
        }

        private static void WriteLog(string userName)
        {
            Console.WriteLine(string.Format("Begin Time {0}:ProcessId {2} ThreadId {3} {1}", DateTime.Now, userName, System.Diagnostics.Process.GetCurrentProcess().Id, Thread.CurrentThread.ManagedThreadId));
            Thread.Sleep(5000);
            if (userName == "LoadTest2")
            {
                Thread.Sleep(5000);
                throw new Exception("Lazy!");
            }
            Console.WriteLine(string.Format("End Time {0}:ProcessId {2} ThreadId {3} {1}", DateTime.Now, userName, System.Diagnostics.Process.GetCurrentProcess().Id, Thread.CurrentThread.ManagedThreadId));
        }



执行效果：


使用ThreadPool也是同样效果：

    foreach (string user in users)
    {
        ThreadPool.QueueUserWorkItem(arg =>
        {
            WriteLog(user);
        });
            }

 

2.10个任务一起执行,须注意WriteLog的参数不能直接使用i,因为在实际开始工作的时候i值已经变成了10

Task[] ts = new Task[10];
for(int i=0;i < numberOfUsers ; i++ ) 
{
ts[i] = Task.Factory.StartNew((object obj) => {
   int j = (int)obj;
   WriteLog(users[j]); }, i);
}
Task.WaitAll(ts); 
Console.WriteLine("Will End soon!");
Thread.Sleep(500000000);




3.总共20个人，后10个人接着前面10个人后干活，使用ContinueWith , 其中传的prevTask可以得到前面任务的状态 
static void Main(string[] args)
        {
            try
            {
                int numberOfUsers = 10;
                var users = new string[20];
                for (int i = 0; i < 20; i++)
                {
                    users[i] = string.Format("LoadTest{0}", i + 1);
                }

                Task[] ts = new Task[numberOfUsers];
                for (int i = 0; i < numberOfUsers; i++)
                {
                    ts[i] = Task.Factory.StartNew((object obj) =>
                    {
                        int j = (int)obj;
                        WriteLog(users[j]);
                    }, i).ContinueWith((prevTask) =>
                    {
                        string exp = string.Empty;
                        if (prevTask.Exception!=null )  exp = "Exception:" + prevTask.Exception.Message;
                        Console.WriteLine(string.Format("ID:{0} Status:{1} IsCanceled:{2} IsCompleted:{3} {4}", prevTask.Id, prevTask.Status, prevTask.IsCanceled, prevTask.IsCompleted, exp));
                        WriteLog(users[9 + prevTask.Id]);
                    });
                   
                }
                
                Task.WaitAll(ts);
                Console.WriteLine("Will End soon!");
                Thread.Sleep(500000000);

            }
            catch (Exception ex)
            {
                Console.WriteLine(string.Format("Time {0}:{1}",DateTime.Now, ex.Message));
                Thread.Sleep(500000000);
            }
        }



4.获取UI上的值来控制是否cancel一个任务下面的所有子任务,使用CancellationTokenSource 
static void Main(string[] args)
        {
            try
            {
                int numberOfUsers = 10;
                var users = new string[numberOfUsers];
                for (int i = 0; i < numberOfUsers; i++)
                {
                    users[i] = string.Format("LoadTest{0}", i + 1);
                }
                CancellationTokenSource tokenSource = new CancellationTokenSource();
                CancellationToken  token = tokenSource.Token;
                ConcurrentBag<Task> ts = new ConcurrentBag<Task>();
                Console.WriteLine("Press any key to begin tasks...");
                Console.WriteLine("To terminate the example, press 'c' to cancel and exit...");
                Console.ReadKey();
                Console.WriteLine();


                //Task t = Task.Factory.StartNew(() => WriteLog(users[0], token), token);
                //Console.WriteLine("Task {0} executing", t.Id);
                //ts.Add(t);

                Task t = Task.Factory.StartNew(() =>
                {
                    Task tc;
                    for (int i = 0; i < numberOfUsers; i++)
                    {
                        tc = Task.Factory.StartNew((object obj) =>
                        {
                            int j = (int)obj;
                            WriteLog(users[j], token);
                        }, i, token);
                        ts.Add(tc);
                    }
                },token);
                ts.Add(t);

                if (Console.ReadKey().KeyChar == 'c')
                {
                    tokenSource.Cancel();
                    Console.WriteLine("\nTask cancellation requested.");
                }
                try
                {
                    Task.WaitAll(ts.ToArray());
                }
                catch (AggregateException e)
                {
                    foreach (var v in e.InnerExceptions)
                    {
                        if (v is TaskCanceledException)
                            Console.WriteLine("   TaskCanceledException: Task {0}",
                                              ((TaskCanceledException)v).Task.Id);
                        else
                            Console.WriteLine("   Exception: {0}", v.GetType().Name);
                    } 

                }
                Console.WriteLine("Will End soon!");
                Thread.Sleep(500000000);

            }
            catch (Exception ex)
            {
                Console.WriteLine(string.Format("Time {0}:{1}",DateTime.Now, ex.Message));
                Thread.Sleep(500000000);
            }
        }

        private static void WriteLog(string userName, CancellationToken ct)
        {
            Console.WriteLine(string.Format("Begin Time {0}:ProcessId {2} ThreadId {3} {1}", DateTime.Now, userName, System.Diagnostics.Process.GetCurrentProcess().Id, Thread.CurrentThread.ManagedThreadId));
            if (userName != "LoadTest1" && userName != "LoadTest2" && userName != "LoadTest3")
            {
                Thread.Sleep(5000);
            }
            if (ct.IsCancellationRequested)
            {
                Console.WriteLine(string.Format("Cancel :{0} ThreadId {1}", userName, Thread.CurrentThread.ManagedThreadId));
                ct.ThrowIfCancellationRequested();
            }
            Console.WriteLine(string.Format("End Time {0}:ProcessId {2} ThreadId {3} {1}", DateTime.Now, userName, System.Diagnostics.Process.GetCurrentProcess().Id, Thread.CurrentThread.ManagedThreadId));
        }


5.总共10个任务，每次最多3个任务，每当这3个任务中任何一个完成，就会从后续任务中拿出任务来做 
static void Main(string[] args)
        {
            try
            {
                int numberOfUsers = 10;
                var users = new string[numberOfUsers];
                for (int i = 0; i < numberOfUsers; i++)
                {
                    users[i] = string.Format("LoadTest{0}", i + 1);
                }

                Action[] aArr = new Action[numberOfUsers];
                int j = 0 ;
                for (int i = 0; i < numberOfUsers; i++){
                aArr[i] = new Action(() => WriteLog(users[j++]));
               }

                System.Threading.Tasks.ParallelOptions po = new ParallelOptions();
                po.MaxDegreeOfParallelism = 3;
                
                try
                {
                    System.Threading.Tasks.Parallel.Invoke(po, aArr);
                }
                catch (AggregateException e)
                {
                    foreach (var v in e.InnerExceptions)
                    {
                        if (v is TaskCanceledException)
                            Console.WriteLine("   TaskCanceledException: Task {0}",
                                              ((TaskCanceledException)v).Task.Id);
                        else
                            Console.WriteLine("   Exception: {0}", v.Message);
                    } 

                }
                Console.WriteLine("Will End soon!");
                Thread.Sleep(500000000);

            }
            catch (Exception ex)
            {
                Console.WriteLine(string.Format("Time {0}:{1}",DateTime.Now, ex.Message));
                Thread.Sleep(500000000);
            }
        }


 

6.总共10个任务，每次最多3个任务，而且每次必须3个一起开始 
static void Main(string[] args)
        {
            try
            {
                int numberOfUsers = 10;
                int maxConcurrent = 3;
                var users = new string[numberOfUsers];
                for (int i = 0; i < numberOfUsers; i++)
                {
                    users[i] = string.Format("LoadTest{0}", i + 1);
                }

                int itemProcessed = 0;
                int loopCnt = 0;
                do
                {
                    List<Task> taskList = new List<Task>();
                    for (int i = 0; i < maxConcurrent; i++)
                    {
                        taskList.Add(Task.Factory.StartNew((object obj) => 
                            {
                                int j = (int)obj;
                                try
                                {
                                    if (loopCnt * maxConcurrent + j < numberOfUsers)
                                    {
                                        WriteLog(users[loopCnt * maxConcurrent + j]);
                                    }
                                }
                                catch (Exception ex)
                                {
                                    Console.WriteLine(string.Format("{0} encounter error :{1}", users[loopCnt * maxConcurrent + j],ex.Message ));
                                }
                            }
                            ,i));
                        Interlocked.Increment(ref itemProcessed);
                    }
                    Task.WaitAll(taskList.ToArray());
                    loopCnt++;
                } while (itemProcessed < numberOfUsers);

                Console.WriteLine("Will End soon!");
                Thread.Sleep(500000000);

            }
            catch (Exception ex)
            {
                Console.WriteLine(string.Format("Time {0}:{1}",DateTime.Now, ex.Message));
                Thread.Sleep(500000000);
            }
        }


7.每次最多３个user一起干活
!wrong

static void Main(string[] args)
        {
            
            ThreadPool.SetMaxThreads(1, 100);

            int numberOfUsers = 10;
            int maxWorkUsers = 3;
            var users = new string[numberOfUsers];
            for (int i = 0; i < numberOfUsers; i++)
            {
                users[i] = string.Format("LoadTest{0}", i + 1);
            }

            var options = new ParallelOptions();
            options.MaxDegreeOfParallelism = maxWorkUsers;
            Parallel.ForEach(users, options,
              (user) =>
              {
                  WriteLog(user);
              });
           Thread.Sleep(500000000);
        }

correct

static void Main(string[] args)
        {
            try
            {
                int numberOfUsers = 10;
                var users = new string[numberOfUsers];
                for (int i = 0; i < numberOfUsers; i++)
                {
                    users[i] = string.Format("LoadTest{0}", i + 1);
                }

                Action[] aArr = new Action[numberOfUsers];
                int j = 0 ;
                for (int i = 0; i < numberOfUsers; i++){
                aArr[i] = new Action(() => WriteLog(users[j++]));
               }

                System.Threading.Tasks.ParallelOptions po = new ParallelOptions();
                po.MaxDegreeOfParallelism = 3;
                
                try
                {
                    System.Threading.Tasks.Parallel.Invoke(po, aArr);
                }
                catch (AggregateException e)
                {
                    foreach (var v in e.InnerExceptions)
                    {
                        if (v is TaskCanceledException)
                            Console.WriteLine("   TaskCanceledException: Task {0}",
                                              ((TaskCanceledException)v).Task.Id);
                        else
                            Console.WriteLine("   Exception: {0}", v.Message);
                    } 

                }
                Console.WriteLine("Will End soon!");
                Thread.Sleep(500000000);

            }
            catch (Exception ex)
            {
                Console.WriteLine(string.Format("Time {0}:{1}",DateTime.Now, ex.Message));
                Thread.Sleep(500000000);
            }
        }

        private static void WriteLog(string userName)
        {
            Console.WriteLine(string.Format("Begin Time {0}:ProcessId {2} ThreadId {3} {1}", DateTime.Now, userName, System.Diagnostics.Process.GetCurrentProcess().Id, Thread.CurrentThread.ManagedThreadId));
            Thread.Sleep(5000);
            if (userName == "LoadTest2")
            {
                Thread.Sleep(5000);
                throw new Exception("Lazy!");
            }
            Console.WriteLine(string.Format("End Time {0}:ProcessId {2} ThreadId {3} {1}", DateTime.Now, userName, System.Diagnostics.Process.GetCurrentProcess().Id, Thread.CurrentThread.ManagedThreadId));
        }


8.多線程改變某值

private static List<string> testList = new List<string>();
        private static void AddList(string name)
        {
            testList.Add(name);
        }

        static void test2()
        {
            
            int threadcount = 10;
            List<Thread> threads = new List<Thread>();
            for (int i = 0; i < threadcount; i++)
            {
                Thread t = new Thread(delegate(object parameter)
                {
                    EmpServiceDataContext db = new EmpServiceDataContext();
                    int _i = (int)parameter;
                    int index = 0;
                    for( int k = 0 ; k < 20000 ; k++)
                    {
                        if (index % threadcount == _i)
                        {
                            try
                            {
                                AddList("Thread" + k);
                            }
                            catch (Exception ex)
                            {
                            }
                        }
                        index++;
                    }
                });
                t.Name = string.Format("SendEmailThread_{0}", i);
                threads.Add(t);
                t.Start(i);
            }
            foreach (Thread t in threads)
            {
                t.Join();
            }
        }
        
Task t = Task.Factory.StartNew(() => test2());
t.Wait();


9.volatile  和 Interlocked
http://baike.baidu.com/view/608706.htm?fr=aladdin

1）. 并行设备的硬件寄存器（如：状态寄存器）
 
2）. 一个中断服务子程序中会访问到的非自动变量（Non-automatic variables)
 
3）. 多线程应用中被几个任务共享的变量

Interlocked.Decrement(ref JOB_COUNT);


10. ThreadStartStop
如何：创建和终止线程（C# 编程指南）
http://msdn.microsoft.com/zh-cn/library/7a2f3ay4(VS.80).aspx

public class Worker
{
    // This method will be called when the thread is started.
    public void DoWork()
    {
        while (!_shouldStop)
        {
            Console.WriteLine("worker thread: working...");
        }
        Console.WriteLine("worker thread: terminating gracefully.");
    }
    public void RequestStop()
    {
        _shouldStop = true;
    }
    // Volatile is used as hint to the compiler that this data
    // member will be accessed by multiple threads.
    private volatile bool _shouldStop;
}

public class WorkerThreadExample
{
    static void Main()
    {
        // Create the thread object. This does not start the thread.
        Worker workerObject = new Worker();
        Thread workerThread = new Thread(workerObject.DoWork);

        // Start the worker thread.
        workerThread.Start();
        Console.WriteLine("main thread: Starting worker thread...");

        // Loop until worker thread activates.
        while (!workerThread.IsAlive);

        // Put the main thread to sleep for 1 millisecond to
        // allow the worker thread to do some work:
        Thread.Sleep(1);

        // Request that the worker thread stop itself:
        workerObject.RequestStop();

        // Use the Join method to block the current thread 
        // until the object's thread terminates.
        workerThread.Join();
        Console.WriteLine("main thread: Worker thread has terminated.");
    }
}



 

白馬酒涼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
万年历SQL Server中实现
白马酒凉
04-25 2081
using System; using System.Collections.Generic; using System.Linq; using System.Text; using Common.Data; using Common.BLL; namespace Common { #region ChineseCalendarException /// /// 中国日
【Darwin学习笔记】之TaskThread
莫问收获、敢问耕耘
01-28 3909
学习TaskThread主要有三个类要关注： TaskTreadPool： 任务线程池 TaskThread：任务线程 Task: 任务 1. TaskThreadPool Darwin运行着一个或者多个任务（Task）线程，并将他们统一在线程池TaskThreadPool中管理。任务线程从事件线程中接收RTSP和RTP请求，然后把请求传递到恰当的服务器模块进行处理，把数据包发送
Task和thread区别和使用
u014312720的博客
07-14 4478
c#之task与thread区别及其使用 1.什么是thread 当我们提及多线程的时候会想到thread和threadpool，这都是异步操作，threadpool其实就是thread的集合，具有很多优势，不过在任务多的时候全局队列会存在竞争而消耗资源。thread默认为前台线程，主程序必须等线程跑完才会关闭，而threadpool相反。 总结：threadpool确实比thread性能优，但是两者都没有很好的api区控制，如果线程执行无响应就只能等待结束，从而诞生了task任务。 2.什么是task t
Task详解
sunxiaopengsun的专栏
01-23 4277
Task类中GetEvents函数返回当前除了kAlive外的所有事件标识，同时清除fEvents中处kAlive之外的所有其他标识。 class A { private: public: A() { fEvents = 0; } typedef unsigned int EventFlags; EventFlags fEvents; enum { kAliv
Task类的学习
气氛组，yyds
05-26 1008
Task类的学习
C# Task任务详细讲解
laizhixue的博客
03-29 1783
请注意，在上面的示例中，Task.CurrentId.IsCancellationRequested 是不正确的用法，因为 Task.CurrentId 是一个只读的属性，它表示当前正在执行的任务的 ID，而不是 CancellationToken。虽然 Task.Run 是更现代和推荐的方式来创建和启动任务，但了解 Task.Factory 也是很有用的，因为它提供了更多的配置选项。Task task1 = Task.Run(() => DoWork("任务A", 2000));
RTThread学习资料
最新发布
06-10
本套“RTThread学习资料”是为开发者提供的一系列关于RTThread的学习资源，旨在帮助初学者快速掌握这一操作系统的核心概念和实际应用。 RTThread的主要特点包括： 1. **实时性**：作为一款实时操作系统，RTThread...
RTTHREAD.rar
04-17
1. **任务（Task）管理**：任务是RTThread中最基本的执行单元，通过rt_thread_create()函数创建，rt_thread_start()启动。 2. **信号量（Semaphore）与互斥锁（Mutex）**：用于线程间同步和资源保护，信号量用于计数...
Task
04-01
【标题】：Task 在Java编程领域中，"Task"通常指的是一个待完成的工作单元，它可能是程序中的一个...通过对这些知识点的学习和实践，我们可以提升Java并发编程的能力，为复杂的分布式系统提供稳定且高效的解决方案。
java Task
07-31
在Java编程领域，任务处理（Task）是一个关键概念，它涉及到多线程、并发和异步执行等核心技能。...通过学习和实践这些文件中的代码，开发者能深化对Java并发编程的理解，提升编写高效、稳定代码的能力。
线程学习源码
11-02
本主题将深入探讨“线程学习源码”中的核心概念，旨在帮助你逐步掌握线程知识。 一、线程基础 在C#中，线程由System.Threading命名空间中的Thread类表示。一个进程可以有多个线程，每个线程都有自己的执行路径。...
Crystal Report中文顯示亂碼
白马酒凉
08-13 2600
1.首先要確定該中文字體在OS裏有沒有安裝 C:\WINDOWS\Fonts 這個
VS字符串时间转换用法
白马酒凉
04-07 2036
1.把hundred year表示的时间转换成普通时间，当然也可以用ToOADate()得到该日期的hundred year时间    System.DateTime.FromOADate(double.Parse("41340"))    {3/7/2013 12:00:00 AM} 2.把字符串转换成datatime DateTime dt = Convert.ToDateTime
MVC 元数据验证
白马酒凉
09-25 1363
ASP.NET MVC 3 Validation - 正则表达式验证RegularExpressionAttribute之日期验证 http://blog.csdn.net/jackvs/article/details/6701186   C#中Dictionary的用法 http://jingyan.baidu.com/article/9989c7460ab872f648ecfeed.h
Active Directory 常用属性
白马酒凉
10-25 1319
1.获取DirectoryEntry string str = string.Empty; string strPath = @LDAP://testDomain.com.mo; string ad = "testAD"; System.DirectoryServices.DirectorySearcher sea = new System.DirectoryServices.Directo
AjaxControlToolkit的使用
白马酒凉
07-25 1230
1.在页面上加ScriptManager控件,不然编译不过  asp:ScriptManager ID="ScriptManager1" runat="server">        asp:ScriptManager> 2.在Web.config上定义namespace,tagPrefix,不然在设计页面上添加控件识别不了,如图 当然,后天添加还是可以的,当然,后台添加还是可以的.
监控某进程内存占用异常
白马酒凉
11-20 1216
1.利用tasklist命令把以T开头的进程PID值和占用内存的信息 --------------------->>d:\test.txt echo %time% >>d:\test.txt tasklist /fi "IMAGENAME eq T*" /fo list >>d:\test.txt echo  --------------------->>d:\test.txt 相关介绍
Unable to find the requested .Net Framework Data Provider
白马酒凉
04-29 1023
换了个系统后发现VS2010和VS2012都有同样问题，
动态menu导航条以及treeview树
白马酒凉
08-02 996
1.menu表数据 2.在后台生成html内容后，前台利用nav-h.css生成menu导航条，利用Jquery的treeview插件生成menu树 前台coding: .menu{ margin:10px 0 0px; position:absolute; right:20px; z-index:99;}
c# task和thread区别
11-22
它在计算机科学和软件开发领域有着广泛的应用，因为它具有简洁而灵活的语法规则，易于学习和使用。 C语言广泛应用于嵌入式系统开发，操作系统的编写，以及其他需要高效性能的应用程序。它能够直接访问计算机的底层...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值