详解C#多线程编程之进程与线程

一、 进程

简单来说,进程是对资源的抽象,是资源的容器,在传统操作系统中,进程是资源分配的基本单位,而且是执行的基本单位,进程支持并发执行,因为每个进程有独立的数据,独立的堆栈空间。一个程序想要并发执行,开多个进程即可。

Q1:在单核下,进程之间如何同时执行?

首先要区分两个概念——并发和并行

  • 并发:并发是指在一段微小的时间段中,有多个程序代码段被CPU执行,宏观上表现出来就是多个程序能”同时“执行。
  • 并行:并行是指在一个时间点,有多个程序段代码被CPU执行,它才是真正的同时执行。

所以应该说进程之间是并发执行。对于CPU来讲,它不知道进程的存在,CPU主要与寄存器打交道。有一些常用的寄存器,如程序计数器寄存器,这个寄存器存储了将要执行的指令的地址,这个寄存器的地址指向哪,CPU就去哪。还有一些堆栈寄存器和通用寄存器等等等,总之,这些数据构成了一个程序的执行环境,这个执行环境就叫做”上下文(Context)“,进程之间切换本质就是保存这些数据到内存,术语叫做”保存现场“,然后恢复某个进程的执行环境,也即是”恢复现场“,整个过程术语叫做“上下文切换”,具体点就是进程上下文切换,这就是进程之间能并发执行的本质——频繁的切换进程上下文。这个功能是由操作系统提供的,是内核态的,对应用软件开发人员透明。

二、 线程

进程虽然支持并发,但是对并发不是很友好,不友好是指每开启一个进程,都要重新分配一部分资源,而线程相对进程来说,创建线程的代价比创建进程要小,所以引入线程能更好的提高并发性。在现代操作系统中,进程变成了资源分配的基本单位,而线程变成了执行的基本单位,每个线程都有独立的堆栈空间,同一个进程的所有线程共享代码段和地址空间等共享资源。相应的上下文切换从进程上下文切换变成了线程上下文切换。

三、 为什么要引入进程和线程#

  1. 提高CPU利用率,在早期的单道批处理系统中,如果执行中的代码需要依赖与外部条件,将会导致CPU空闲,例如文件读取,等待键盘信号输入,这将浪费大量的CPU时间。引入多进程和线程可以解决CPU利用率低这个问题。
  2. 隔离程序之间的数据(每个进程都有单独的地址空间),保证系统运行的稳定性。
  3. 提高系统的响应性和交互能力。

四、 在C#中创建托管线程

1. Thread类

在.NET中,托管线程分为:

  • 前台线程
  • 后台线程

一个.Net程序中,至少要有一个前台线程,所有前台线程结束了,所有的后台线程将会被公共语言运行时(CLR)强制销毁,程序执行结束。

如下将在控制台程序中创建一个后台线程

static void Main(string[] args)
{
   var t = new Thread(() =>
   {
     Thread.Sleep(1000);
     Console.WriteLine("执行完毕");
   });
  t.IsBackground = true;
   t.Start();
}

主线程(默认是前台线程)执行完毕,程序直接退出。

2. 有什么问题

直接使用Thread类来进行多线程编程浪费资源(服务器端更加明显)且不方便,举个栗子。

假如我写一个Web服务器程序,每个请求创建一个线程,那么每一次我都要new一个Thread对象,然后传入处理HttpRequest的委托,处理完之后,线程将会被销毁,这将会导致浪费大量CPU时间和内存,在早期CPU性能不行和内存资源珍贵的情况下这个缺点会被放大,在现在这个缺点不是很明显,原因是硬件上来了。

不方便体现在哪呢?

  • 无法直接获取另一个线程内未被捕捉的异常
  • 无法直接获取线程函数的返回值
public static void ThrowException()
{
   throw new Exception("发生异常");
}
static void Main(string[] args)
{
   var t = new Thread(() =>
   {
     Thread.Sleep(1000);
     ThrowException();
   });
  t.IsBackground = false;
   try
   {
     t.Start();
   }
   catch(Exception e)
   {
     Console.WriteLine(e.Message);
   }
}

上述代码将会导致程序奔溃,如下图。

要想直接获取返回值和可以直接从主线程捕捉线程函数内未捕捉的异常,我们可以这么做。

新建一个MyTask.cs文件,内容如下

using System;
using System.Threading;
namespace ConsoleApp1
{
   public class MyTask
   {
     private Thread _thread;
     private Action _action;
     private Exception _innerException;
    public MyTask()
     {
    }
     public MyTask(Action action)
     {
       _action = action;
     }
     protected virtual void Excute()
     {
       try
       {
         _action();
       }
       catch(Exception e)
       {
         _innerException = e;
       }

     }
     public void Start()
     {
       if (_thread != null) throw new InvalidOperationException("任务已经开始");
       _thread = new Thread(() => Excute());
       _thread.Start();
     }
     public void Start(Action action)
     {
       _action = action;
       if (_thread != null) throw new InvalidOperationException("任务已经开始");
       _thread = new Thread(() => Excute());
       _thread.Start();
     }
    public void Wait()
     {
       _thread.Join();
       if (_innerException != null) throw _innerException;
     }
   }
  public class MyTask<T> : MyTask
   {
     private Func<T> _func { get; }
     private T _result;
     public T Result {

       private set => _result = value;
       get
       {
         base.Wait();
         return _result;
       }
     }
     public MyTask(Func<T> func)
     {
       _func = func;
     }
    public new void Start()
     {
       base.Start(() =>
       {
         Result = _func();
       });
     }
  }
}

简单的包装了一下(不要在意细节),我们便可以实现我们想要的效果。

测试代码如下

public static void ThrowException()
{
   throw new Exception("发生异常");
}
public static void Test3()
{
   MyTask<string> myTask = new MyTask<string>(() =>
   {
     Thread.Sleep(1000);
     return "执行完毕";
   });
  myTask.Start();
  try
   {
     Console.WriteLine(myTask.Result);
   }
   catch (Exception e)
   {
     Console.WriteLine(e.Message);
   }
}
public static void Test2()
{
   MyTask<string> myTask = new MyTask<string>(() =>
   {
     Thread.Sleep(1000);
     ThrowException();
     return "执行完毕";
   });
  myTask.Start();
  try
   {
     Console.WriteLine(myTask.Result);
   }
   catch(Exception e)
   {
     Console.WriteLine(e.Message);
   }
}
public static void Test1()
{
   MyTask myTask = new MyTask(() =>
   {
     Thread.Sleep(1000);
     ThrowException();
   });
   myTask.Start();
  try
   {
     myTask.Wait();
   }
   catch (Exception e)
   {
     Console.WriteLine(e.Message);
   }
}
static void Main(string[] args)
{
   Test1();
   Test2();
   Test3();
}

可以看到,我们可以通过简单包装Thread对象,便可实现如下效果

  • 直接读取线程函数返回值
  • 直接捕捉线程函数未捕捉的异常(前提是调用了Wait()函数或者Result属性)

这是理解和运用Task的基础,Task功能非常完善,但是运用好Task需要掌握许多概念,下篇文章再说。

以上就是详解C#多线程编程之进程与线程的详细内容,更多关于C#多线程编程 进程与线程的资料请关注我们其它相关文章!

(0)

相关推荐

  • 实例代码讲解c# 线程(下)

    前言 实例代码讲解c# 线程(上) 使用Mutex类 class Program { static void Main(string[] args) { const string MutexName ="CSharpThreadingCookbook"; using (var m = new Mutex(false, MutexName)) { if (!m.WaitOne(TimeSpan.FromSeconds(5), false)) { Console.WriteLine(&qu

  • C# 线程相关知识总结

    初识线程 线程是一个独立的运行单元,每个进程内部都有多个线程,每个线程都可以各自同时执行指令.每个线程都有自己独立的栈,但是与进程内的其他线程共享内存.但是对于.NET的客户端程序(Console,WPF,WinForms)是由CLR创建的单线程(主线程,且只创建一个线程)来启动.在该线程上可以创建其他线程. 图: 线程工作方式 多线程由内部线程调度程序管理,线程调度器通常是CLR委派给操作系统的函数.线程调度程序确保所有活动线程都被分配到合适的执行时间,线程在等待或阻止时 (例如,在一个独占锁

  • C# 多线程对资源读写时如何控制的方法

    1.多个线程对同一个队列进行读写操作,要注意进行读写控制,某个线程在读取的时候,不允许其它线程读.写:某个线程在写的时候,不允许其它线程进行读写. 2.对字典进行读写时,进行独占式访问定义一个字典,再定义用于指定用于对此字典进行读写控制的ReaderWriterLockSlim对象 ReaderWriterLockSlim类的说明 如下图所示,在读取前,执行EnterReadLock()进入读取锁定模式,读完后,执行ExitReadLock()退出读取模式.如果是要写入,则执行该锁定对象的Ent

  • 实例代码讲解c# 线程(上)

    简介 过去普通计算机只有计算单元,却不能同时执行多个任务.然而操作系统却已经可以同时运行多个应用程序,即实现了多任务的概念.为了防止一个应用程序控制CPU而导致其他应用程序和操作系统本身永远被挂起这一可能情况,操作系统不得不使用某种方式 将物理计算单元分割为一些虚拟的进程,并给予每个程序一定量的计算能力.此外,操作系统必须始终能够优先访问CPU,并能调整不同程序访问CPU的优先级.线程正是这一概念的实现.可以认为线程是一个虚拟进程,用于独立运行一个特定的程序. (请记住线程会消耗大量的操作系统资

  • C# 多线程编程技术基础知识入门

    什么是进程? 当一个程序开始运行时,它就是一个进程,进程包括运行中的程序和程序所使用到的内存和系统资源.而一个进程又是由多个线程所组成的. 什么是线程? 线程是程序中的一个执行流,每个线程都有自己的专有寄存器(栈指针.程序计数器等),但代码区是共享的,即不同的线程可以执行同样的函数. 什么是多线程? 多线程是指程序中包含多个执行流,即在一个程序中可以同时运行多个不同的线程来执行不同的任务,也就是说允许单个程序创建多个并行执行的线程来完成各自的任务. 多线程是指程序中包含多个执行流,即在一个程序中

  • 深入分析C# 线程同步

    上一篇介绍了如何开启线程,线程间相互传递参数,及线程中本地变量和全局共享变量区别. 本篇主要说明线程同步. 如果有多个线程同时访问共享数据的时候,就必须要用线程同步,防止共享数据被破坏.如果多个线程不会同时访问共享数据,可以不用线程同步. 线程同步也会有一些问题存在: 性能损耗.获取,释放锁,线程上下文建切换都是耗性能的. 同步会使线程排队等待执行. 线程同步的几种方法: 阻塞 当线程调用Sleep,Join,EndInvoke,线程就处于阻塞状态(Sleep使调用线程阻塞,Join.EndIn

  • 详解C#多线程编程之进程与线程

    一. 进程 简单来说,进程是对资源的抽象,是资源的容器,在传统操作系统中,进程是资源分配的基本单位,而且是执行的基本单位,进程支持并发执行,因为每个进程有独立的数据,独立的堆栈空间.一个程序想要并发执行,开多个进程即可. Q1:在单核下,进程之间如何同时执行? 首先要区分两个概念--并发和并行 并发:并发是指在一段微小的时间段中,有多个程序代码段被CPU执行,宏观上表现出来就是多个程序能"同时"执行. 并行:并行是指在一个时间点,有多个程序段代码被CPU执行,它才是真正的同时执行. 所

  • 详解Java多线程编程中CountDownLatch阻塞线程的方法

    直译过来就是倒计数(CountDown)门闩(Latch).倒计数不用说,门闩的意思顾名思义就是阻止前进.在这里就是指 CountDownLatch.await() 方法在倒计数为0之前会阻塞当前线程. CountDownLatch是一个同步辅助类,在完成一组正在其他线程中执行的操作之前,它允许一个或多个线程一直等待. CountDownLatch 的作用和 Thread.join() 方法类似,可用于一组线程和另外一组线程的协作.例如,主线程在做一项工作之前需要一系列的准备工作,只有这些准备工

  • 详解Linux多线程编程(不限Linux)

    前言 线程?为什么有了进程还需要线程呢,他们有什么区别?使用线程有什么优势呢?还有多线程编程的一些细节问题,如线程之间怎样同步.互斥,这些东西将在本文中介绍.我在某QQ群里见到这样一道面试题: 是否熟悉POSIX多线程编程技术?如熟悉,编写程序完成如下功能: 1)有一int型全局变量g_Flag初始值为0: 2) 在主线称中起动线程1,打印"this is thread1",并将g_Flag设置为1 3) 在主线称中启动线程2,打印"this is thread2"

  • 详解Java多线程编程中的线程同步方法

    1.多线程的同步: 1.1.同步机制: 在多线程中,可能有多个线程试图访问一个有限的资源,必须预防这种情况的发生.所以引入了同步机制:在线程使用一个资源时为其加锁,这样其他的线程便不能访问那个资源了,直到解锁后才可以访问. 1.2.共享成员变量的例子: 成员变量与局部变量: 成员变量: 如果一个变量是成员变量,那么多个线程对同一个对象的成员变量进行操作,这多个线程是共享一个成员变量的. 局部变量: 如果一个变量是局部变量,那么多个线程对同一个对象进行操作,每个线程都会有一个该局部变量的拷贝.他们

  • 详解Java多线程编程中线程的启动、中断或终止操作

    线程启动: 1.start() 和 run()的区别说明 start() : 它的作用是启动一个新线程,新线程会执行相应的run()方法.start()不能被重复调用. run() : run()就和普通的成员方法一样,可以被重复调用.单独调用run()的话,会在当前线程中执行run(),而并不会启动新线程! 下面以代码来进行说明. class MyThread extends Thread{ public void run(){ ... } }; MyThread mythread = new

  • 详解Java多线程编程中互斥锁ReentrantLock类的用法

    0.关于互斥锁 所谓互斥锁, 指的是一次最多只能有一个线程持有的锁. 在jdk1.5之前, 我们通常使用synchronized机制控制多个线程对共享资源的访问. 而现在, Lock提供了比synchronized机制更广泛的锁定操作, Lock和synchronized机制的主要区别: synchronized机制提供了对与每个对象相关的隐式监视器锁的访问, 并强制所有锁获取和释放均要出现在一个块结构中, 当获取了多个锁时, 它们必须以相反的顺序释放. synchronized机制对锁的释放是

  • 详解Java多线程编程中LockSupport类的线程阻塞用法

    LockSupport是用来创建锁和其他同步类的基本线程阻塞原语. LockSupport中的park() 和 unpark() 的作用分别是阻塞线程和解除阻塞线程,而且park()和unpark()不会遇到"Thread.suspend 和 Thread.resume所可能引发的死锁"问题. 因为park() 和 unpark()有许可的存在:调用 park() 的线程和另一个试图将其 unpark() 的线程之间的竞争将保持活性. 基本用法 LockSupport 很类似于二元信号

  • 详解Java多线程与并发

    一.进程与线程 进程:是代码在数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位. 线程:是进程的一个执行路径,一个进程中至少有一个线程,进程中的多个线程共享进程的 资源. 虽然系统是把资源分给进程,但是CPU很特殊,是被分配到线程的,所以线程是CPU分配的基本单位. 二者关系: 一个进程中有多个线程,多个线程共享进程的堆和方法区资源,但是每个线程有自己的程序计数器和栈区域. 程序计数器:是一块内存区域,用来记录线程当前要执行的指令地址 . 栈:用于存储该线程的局部变量,这些局部变量是

  • 详解Java网络编程

    一.网络编程 1.1.概述 1.计算机网络是通过传输介质.通信设施和网络通信协议,把分散在不同地点的计算机设备互连起来,实现资源共享和数据传输的系统.网络编程就就是编写程序使联网的两个(或多个)设备(例如计算机)之间进行数据传输.Java语言对网络编程提供了良好的支持,通过其提供的接口我们可以很方便地进行网络编程. 2.Java是 Internet 上的语言,它从语言级上提供了对网络应用程 序的支持,程序员能够很容易开发常见的网络应用程序. 3.Java提供的网络类库,可以实现无痛的网络连接,联

  • 详解Java并发编程基础之volatile

    目录 一.volatile的定义和实现原理 1.Java并发模型采用的方式 2.volatile的定义 3.volatile的底层实现原理 二.volatile的内存语义 1.volatile的特性 2.volatile写-读建立的happens-before关系 3.volatile的写/读内存语义 三.volatile内存语义的实现 1.volatile重排序规则 2.内存屏障 3.内存屏障示例 四.volatile与死循环问题 五.volatile对于复合操作非原子性问题 一.volati

随机推荐