C#开启线程的四种方式

1.异步委托开启线程

    public class Program
    {
        public static void Main(string[] args)
        {
            Action<int, int> a = add;
            a.BeginInvoke(3, 4, null, null);
            Console.WriteLine("执行线程");
            Console.ReadKey();
        }
        static void add(int a, int b)
        {
            Console.WriteLine(a + b);
        }
    }

2.通过Thread类开启线程

    public class Program
    {
        public static void Main(string[] args)
        {
            Thread t1;
            Thread t2;
            t1 = new Thread(SetInfo1);
            t2 = new Thread(SetInfo2);
            t1.Start();
            //线程睡眠
            //t1.Join(1000);
            //挂起线程
            t1.Suspend();
            //继续执行线程
            t1.Resume();
            //结束线程
            //t1.Abort();

            t2.Start();
            Console.ReadKey();
        }
        //奇数线程
        public static void SetInfo1()
        {
            for (int i = 0; i < 100; i++)
            {
                if (i % 2 != 0)
                {
                    Console.WriteLine("奇数为" + i);
                }
            }
        }
        //偶数线程
        public static void SetInfo2()
        {
            for (int i = 0; i < 100; i++)
            {
                if (i % 2 == 0)
                {
                    Console.WriteLine("偶数为" + i);
                }
            }
        }
    }

3.通过线程池开启线程

//线程池可以看做容纳线程的容器;一个应用程序最多只能有一个线程池;ThreadPool静态类通过QueueUserWorkItem()方法将工作函数排入线程池; 每排入一个工作函数,就相当于请求创建一个线程;
    //线程池的作用:
    //1、线程池是为突然大量爆发的线程设计的,通过有限的几个固定线程为大量的操作服务,减少了创建和销毁线程所需的时间,从而提高效率。
    //2、如果一个线程的时间非常长,就没必要用线程池了(不是不能作长时间操作,而是不宜。),况且我们还不能控制线程池中线程的开始、挂起、和中止
    public class Program
    {
        public static void Main(string[] args)
        {
            ThreadPool.QueueUserWorkItem(new WaitCallback(TestThreadPool), new string[] { "hjh" });
            Console.ReadKey();
        }
        public static void TestThreadPool(object state)
        {
            string[] arry = state as string[];//传过来的参数值
            int workerThreads = 0;
            int CompletionPortThreads = 0;
            ThreadPool.GetMaxThreads(out workerThreads, out CompletionPortThreads);
            Console.WriteLine(DateTime.Now.ToString() + "---" + arry[0] + "--workerThreads=" + workerThreads + "--CompletionPortThreads" + CompletionPortThreads);
        }
    }

4.通过任务Task开启线程

public class Program
    {
        public static void Main(string[] args)
        {
            Task task = new Task(DownLoadFile_My);
            task.Start();
            Console.ReadKey();
        }
        static void DownLoadFile_My()
        {
            Console.WriteLine("开始下载...线程ID:"+Thread.CurrentThread.ManagedThreadId);
            Thread.Sleep(500);
            Console.WriteLine("下载完成!");
        }
    }

原文地址:https://www.cnblogs.com/dujian123/p/10876845.html

时间: 2024-10-10 08:25:05

C#开启线程的四种方式的相关文章

Java开启线程的两种方式

------<a href="http://www.itheima.com" target="blank">Java培训.Android培训.ios培训..Net培训</a>.期待与您交流!------ Java开启线程的两种方式: 方式一:成为线程(Thread)的儿子,即继承Thread类简单代码如下:class Student extends Thread{Student(String name){super(name);}public

python并发编程:多线程-开启线程的两种方式

一 threading模块介绍 multiprocess模块完全模仿了threading模块的接口,二者在使用层面,有很大的相似性 二 开启线程的两种方式 方式一 from threading import Thread import time def sayhi(name): time.sleep(2) print("%s say hello" % name) if __name__ == '__main__': t = Thread(target=sayhi, args=('mik

开启线程的两种方式,

'''目录1,开启线程的两种方式*****2,线程和进程的区别*****3,线程对象的其他方法和属性4,守护线程5,互斥锁6,死锁现象与递过锁7,信号量'''#1 开启线程的两种方式import timefrom threading import Thread def dask(name): print('%s is running '%name) time.sleep(1) print('%s is done'%name) t=Thread(target=dask,args=('egon',)

死锁现象与解决方案,开启线程的2种方式,守护线程,线程VS进程,线程互斥锁,信号量

死锁现象与解决方案 from threading import Thread,Lock,active_count import time mutexA=Lock() # 锁1 mutexB=Lock() # 锁2 class Mythread(Thread): def run(self): self.f1() self.f2() def f1(self): mutexA.acquire() print('%s 拿到A锁' %self.name) mutexB.acquire() print('%

7 并发编程-(线程)-开启线程的两种方式

thread/英 /θred/ 美 /θr?d/  线程 1.threading模块介绍 multiprocess模块的完全模仿了threading模块的接口,二者在使用层面,有很大的相似性,因而不再详细介绍 2.开启线程的两种方式 2.1.方式一 from threading import Thread import time def task(name): print(f"{name} is running") time.sleep(2) print(f"{name} i

2-2 开启线程的两种方式

一 threading模块介绍 multiprocess模块的完全模仿了threading模块的接口,二者在使用层面,有很大的相似性,因而不再详细介绍 二 开启线程的两种方式 方式一 from threading import Thread import time def sayhi(name): time.sleep(2) print('%s say hello' %name) if __name__ == '__main__': t=Thread(target=sayhi,args=('eg

C# 中关闭当前线程的四种方式 .

.net类库已经帮助我们实现了窗口的关闭,如果此窗口是系统的主窗口,关闭此窗口即应该退出了整个应用程序.但事实上有时候并不是这样的,关闭窗口,只是停止了当前窗口的消息循环.系统主窗口,实质上是Main函数中开始消息循环的窗口,这个消息循环结束后,Main函数就基本上完成了历史使命,整个应用程序自然就结束了.Application.Exit()方法是终止所有线程上的消息循环,一般情况下,无论在什么地方调用此方法,程序就能退出.但是如果你在程序中加入了某些耗时甚至是死循环的线程,那么即使是消息循环终

创建线程的四种方式

https://www.cnblogs.com/zhou-test/p/9811771.html 原文地址:https://www.cnblogs.com/linliquan/p/11350422.html

java线程实现的四种方式

java多线程的实现可以通过以下四种方式 1.继承Thread类,重写run方法 2.实现Runnable接口,重写run方法 3.通过Callable和FutureTask创建线程 4.通过线程池创建线程 方式1,2不再赘述. 方式3,通过Callable和FutureTask创建线程实现多线程 @Test public void MyCallableTest() throws Exception { //创建线程执行对象 MyCallable myCallable = new MyCalla