VB.net 2010 视频教程 VB.net 2010 视频教程 python基础视频教程
SQL Server 2008 视频教程 c#入门经典教程 Visual Basic从门到精通视频教程
当前位置:
首页 > c#编程 >

  • C#教程之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> 进程操作的一个演示：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
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 获取进程
  /// <summary>
/// 获取进程
/// </summary>
/// <param name="ip"></param>
/// <returns></returns>
  public Process[] GetProcess(string ip = "")
  {
   if (string.IsNullOrEmpty(ip))
    return Process.GetProcesses();
 
   return Process.GetProcesses(ip);
  }
  #endregion
 
  #region 查看进程
  /// <summary>
/// 查看进程
/// </summary>
/// <param name="process"></param>
  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查看指定的进程
  /// <summary>
/// 根据ID查看指定的进程
/// </summary>
/// <param name="processID"></param>
  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 进程开启
  /// <summary>
/// 进程开启
/// </summary>
/// <param name="fileName"></param>
/// <returns></returns>
  public string StartProcess(string fileName)
  {
   Process process = new Process();
 
   process.StartInfo = new ProcessStartInfo(fileName);
 
   process.Start();
 
   return process.ProcessName;
  }
  #endregion
 
  #region 终止进程
  /// <summary>
/// 终止进程
/// </summary>
/// <param name="name"></param>
  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>  同样我也举个例子

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
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 取款操作
  /// <summary>
/// 取款操作
/// </summary>
/// <param name="amount"></param>
  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 自动取款操作
  /// <summary>
/// 自动取款操作
/// </summary>
  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都需要创建一个线程来处理，

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

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

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

代码： 修改后如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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();
//}
  }


相关教程