C#网络编程基础之进程和线程完整指南-45看点

平时做技术实践时，很多问题不是概念不会，而是细节没串起来。拿“C#网络编程基础之进程和线程”来说，它看着像小点，放到项目里常会牵出环境、配置、兼容性和维护成本。下面按实际采用顺序，把思路、关键写法和容易踩坑的地方讲清楚，便于大家直接对照操作。

从实现思路看，在C#的网络编程里，进程和线程是必备的基础知识，同时也是一个重点，所以我们要好好的掌握一下。

一：概念

首先我们要知道什么是”进程”，什么是“线程”，好，查一下baike。

进程：是一个具有一定独立功能的程序关于某个数据集合的一次活动。它是操作系统动态执行的基本单元，

在传统的操作系统里，进程既是基本的分配单元，也是基本的执行单元。

线程：是"进程"中某个单一顺序的控制流。

关于这两个概念，大家稍微有个印象就行了，防止以后被面试官问到。

二：进程

实际处理时，framework里面对“进程”的基本操作的封装还是蛮好的，能够满足我们真实开发场景下的基本应用。

<1> 拿到进程信息

理解这一步时，framework中给我们拿到进程的方式还是蛮多的，即能够按照Name拿到，也能够按照ID拿到，也能够拿到本地和远程的进程信息。

复制代码代码如下所示:

public Process[] GetProcess(string ip = "")
{
if (string.IsNullOrEmpty(ip))
return Process.GetProcesses();

return Process.GetProcesses(ip);
}

Process process = Process.GetProcessById(Convert.ToInt32(processID));

<2> 启动和停止进程

理解这一步时，其实这个也没啥好说的，不过有一个注意点就是Process中的"kill"和"CloseMainWindow"的区别。

windowMainWindow: 当我们打开的Process是一个有界面的应用程序时，建议采用此方法，它相当于点击了应用程序的关闭按钮，是一个有序的终止应用程序的操作，而不像kill那么暴力。

kill：根据这个单词估计大家都知道啥意思吧，它的作用就是强制关闭我们打开的Process，往往会造成就是我们数据的丢失，所以说在万不得已的情况下不要采用kill，当然在无图形界面的应用程序中，kill是唯一能够结束Process的一个策略。

<3> 进程操作的一个演示：


public class ProgessHelper
 {
  //主操作流程
  public static void MainProcess()
  {
   ProgessHelper helper = new ProgessHelper();

   var result = helper.GetProcess();

   helper.ShowProcess(result.Take(10).ToArray());

   Console.Write("\n请输入您要查看的进程：");

   helper.ShowProcessSingle(Console.ReadLine());

   Console.Write("\n请输入您要开启的程序：\t");

   var name = helper.StartProcess(Console.ReadLine());


   Console.WriteLine("程序已经开启，是否关闭？(0,1)");

   if (Console.ReadLine() == "1")
   {
    helper.StopProcess(name);

    Console.WriteLine("关闭成功。");
   }
  }

  #region 获取进程
  /// 
/// 获取进程
/// 

/// 
/// 
  public Process[] GetProcess(string ip = "")
  {
   if (string.IsNullOrEmpty(ip))
    return Process.GetProcesses();

   return Process.GetProcesses(ip);
  }
  #endregion

  #region 查看进程
  /// 
/// 查看进程
/// 

/// 
  public void ShowProcess(Process[] process)
  {
   Console.WriteLine("进程ID\t进程名称\t物理内存\t\t启动时间\t文件名");

   foreach (var p in process)
   {
    try
    {
     Console.WriteLine("{0}\t{1}\t{2}M\t\t{3}\t{4}", p.Id, p.ProcessName.Trim(), p.WorkingSet64 / 1024.0f / 1024.0f,
                   p.StartTime, p.MainModule.FileName);
    }
    catch (Exception ex)
    {
     Console.WriteLine(ex.Message);
    }
   }
  }
  #endregion

  #region 根据ID查看指定的进程
  /// 
/// 根据ID查看指定的进程
/// 

/// 
  public void ShowProcessSingle(string processID)
  {
   Process process = Process.GetProcessById(Convert.ToInt32(processID));

   Console.WriteLine("\n\n您要查看的进程详细信息如下：\n");

   try
   {
    var module = process.MainModule;

    Console.WriteLine("文件名:{0}\n版本{1}\n描叙{2}\n语言:{3}", module.FileName, module.FileVersionInfo.FileVersion,
                   module.FileVersionInfo.FileDescription,
                   module.FileVersionInfo.Language);
   }
   catch (Exception e)
   {
    Console.WriteLine(e.Message);
   }
  }
  #endregion

  #region 进程开启
  /// 
/// 进程开启
/// 

/// 
/// 
  public string StartProcess(string fileName)
  {
   Process process = new Process();

   process.StartInfo = new ProcessStartInfo(fileName);

   process.Start();

   return process.ProcessName;
  }
  #endregion

  #region 终止进程
  /// 
/// 终止进程
/// 

/// 
  public void StopProcess(string name)
  {
   var process = Process.GetProcessesByName(name).FirstOrDefault();

   try
   {
    process.CloseMainWindow();
   }
   catch (Exception ex)
   {
    Console.WriteLine(ex.Message);
   }
  }
  #endregion
 }

快看，PPTV真的被我打开了，嗯，8错，Process还是蛮好玩的。

这里需留意一点：

理解这一步时，我们在59行中加上了Try Catch，这是因为每个Process都有一个MainModule属性，但同时不是每一个MainModule都能被C#拿到，

如会出现如下所示的“拒绝访问”。

三：线程

结合项目来看，同样线程的相关操作也已经被framework里面的Thread完美的封装，大大简化了我们的工作量，常用的操作如下所示

<1> 启动线程。
<2> 终止线程。
<3> 暂停线程。
<4> 合并线程。

这个要解释一下，比如：t1线程在执行过程中需等待t2执行完才能继续执行，此时我们就要将t2合同时到t1中去，也就是在t1的代码块中写上t2.Join（）即可。同样Join中也能够加上等待t2执行的时间，不管t2是否执行完毕。

<5> 线程同步

结合项目来看，估计大家也知道，多线程解决了系统的吞吐量和响应时间，同时也给我们留下了比如死锁，资源争用等问题，那么我们如何

在这个场景下，解决这些问题呢？呵呵，Anders Hejlsberg 这位老前辈已经给我们提供了很多的实现同步线程的类，比如Mutex，Monitor，

在这个场景下，Interlocked和AutoResetEvent，当然在实际应用中，我们还是喜欢采用简化版的lock，因为这玩意能够使编程简化，同时使

程序看起来简洁明了。

<6> 同样我也举个例子


public class ThreadHelper
 {
  public static void MainThread()
  {

   ThreadHelper helper = new ThreadHelper(100);

   Thread[] thread = new Thread[20];

   for (int i = 0; i < 20; i++)
   {
    thread[i] = new Thread(helper.DoTransactions);

    thread[i].Name = "线程" + i;

   }

   foreach (var single in thread)
   {
    single.Start();
   }
  }

  int balance;

  object obj = new object();

  public ThreadHelper(int balance)
  {
   this.balance = balance;
  }

  #region 操作
  /// 
/// 操作
/// 

/// 
  public void WithDraw(int amount)
  {
   lock (obj)
   {
    if (balance <= 0)
    {
     Console.WriteLine("哈哈，已经取完了");
     return;
    }

    if (balance >= amount)
    {
     Console.WriteLine("前余额:{0},：{1},还剩余额:{2}", balance, amount, balance - amount);
     balance = balance - amount;
    }
    else
    {
     Console.WriteLine("前余额:{0},：{1},还剩余额:{2}", balance, balance, balance = 0);
    }
   }
  }
  #endregion

  #region 自动操作
  /// 
/// 自动操作
/// 

  public void DoTransactions(object obj)
  {
   int random = new Random().Next(4, 10);

   Thread.Sleep(5000);

   WithDraw(random);
  }
  #endregion
 }

实际处理时，当我们加上lock的时候一切正常，但是当我们把lock去掉的时候，看看线程们会有“争用资源”的现象吗？，在下图中能够看到，出现了如下所示的现象，

当然这不是我想看到的结果，如果在实际应用中会是多么难找的bug。

<8> 线程池

落到代码里，上面的例子中，我新建了20个线程来完成任务，比如在某些实际应用中，Client端的每个请求Server都需新建一个线程来处理，

结合项目来看，那么当线程很多的时候同时不是一件好事情，这会导致过度的采用系统资源而耗尽内存，那么自然就会引入“线程池”。

线程池：是一个在后台执行多个任务的集合，他封装了我们对线程的基本操作，我们能做的就只要把“入口方法”丢给线程池就行了。

特点：线程池有最大线程数限制，大小在不同的机器上是否区别的，当池中的线程都是繁忙状态，后入的方法就会排队，直至池中有空闲的线程来处理。

代码：修改后如下所示：


public static void MainThread()
  {

   ThreadHelper helper = new ThreadHelper(100);

   for (int i = 0; i < 20; i++)
   {
    ThreadPool.QueueUserWorkItem(new WaitCallback(helper.DoTransactions));
   }

   //Thread[] thread = new Thread[20];

//for (int i = 0; i < 20; i++)
//{
// thread[i] = new Thread(helper.DoTransactions);

// thread[i].Name = "线程" + i;

//}

//foreach (var single in thread)
//{
// single.Start();
//}
  }

实际处理时，总的来说，C#适合结合实际项目边做边理解。先抓住核心思路，再逐步补上细节和边界处理，最后效果会更稳定，也更容易复用。