private void timer1_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
		{
			DateTime cur_now=System.DateTime.Now;
			int cur_hour=cur_now.Hour;
			int cur_min=cur_now.Minute;
			int cur_sec=cur_now.Second;
		
			pc.CategoryName="Processor";
			pc.CounterName="% Processor Time";
			pc.InstanceName="_Total";
			
//			pc.MachineName="michaeljane";
			float pcv=pc.NextValue();
			label7.Text="CPU利用率："+(pcv).ToString()+" %";
			cpubar.Value=(int)(pcv);
 
			pcmem.CategoryName="Memory";
			pcmem.CounterName="Available MBytes";
			pcmem.InstanceName=null;
 
//			richTextBox1.Text=pcpu.NextValue().ToString()+"\r\n";
			
 
			/*			System.Diagnostics.PerformanceCounter[] mypc; 
			System.Diagnostics.PerformanceCounterCategory mycat = 
				new System.Diagnostics.PerformanceCounterCategory("process");
			// Remove the current contents of the list.
			// Retrieve the counters.
			mypc = mycat.GetCounters();
			// Add the retrieved counters to the list.
			richTextBox1.Text="";
			for (int i = 0; i < mypc.Length; i++) 
			{ 
				richTextBox1.Text+=(mypc[i].CounterName)+"\r\n";
			}
*/
 
//			float cpuLoad = pc.NextValue();
            try
            {
                label7.Text += "\r\n可用內存：" + pcmem.NextValue().ToString() + "M";
            }
            catch (Exception s)
            {
            }
			statusBar1.Text=cur_now.ToString();  //顯示當前時間
			Process[] processes; //定義進程組
			processes = System.Diagnostics.Process.GetProcesses(); //獲得當前進程組
			Process process;  //定義初始進程中間變量
			string _pname,_killstate="";   //定義進程名變量，及進程回收狀態(tài)字符串
			bool _kill=false;  //是否要回收標志變量
			bool _phandle=checkBox2.Checked;
			int _gcSpan;  //時間差變量
			DateTime _pdatetime,_checktime,_stdtime; //進程啟動的時間變量和檢測時間變量
			string[] _rv;    //接受檢測結果的數組
			System.TimeSpan _dd; //時間差的秒數變量
//			string[] _processid=new string[1000];
//			DateTime[] _processLastTime=new DateTime[1000];
//			int[] _processLastMem=new int[1000];
				for(int i = 0;i<processes.Length-1;i++)
				{
					process= processes[i];  //獲得當前進程
					_pname=process.ProcessName.ToLower();  //獲得進程名并轉為小寫
                try
                {
                    _pdatetime = process.StartTime;  //獲得進程的啟動時間
                }catch(Exception e1)
                {
                    continue;
                }
					//				_rv=GetSubValueIndex(listBox1,_pname,"|");  //得到要回收的用戶指定進程
					for(int li=0;li<listBox1.Items.Count;li++)
					{
						_rv=listBox1.Items[li].ToString().Split('|');
						string ref_process=_rv[0].ToLower().Trim();
						int ref_span=int.Parse(_rv[1].ToString());
						string ref_cl=_rv[2].ToLower().Trim();
						float ref_rank=float.Parse(_rv[3].ToString());
						string ref_stdtime=_rv[4].ToLower().Trim();
						string ref_act=_rv[5].ToLower().Trim();
						string[] ref_cmd1=_rv[6].Split('↙');
						string[] ref_cmd2=_rv[7].Split('↙');
						string ref_closetime=_rv[8].Trim();
						//				richTextBox1.Text+=_rv[0]+_rv[1]+"\r\n";
					
						if(ref_process==_pname)  //如果是要回收的進程則進行處理
						{
							//如果在檢測數組沒有找到，則添加到檢測數中
							int _curpoint=System.Array.IndexOf(_processid,process.Id);
							if(_curpoint<0)
							{
								_stdtime=process.StartTime;
								if(ref_stdtime=="bynowtime")
								{
									_stdtime=System.DateTime.Now;
								}
								System.Diagnostics.PerformanceCounter pcm=new System.Diagnostics.PerformanceCounter("Process","% Processor Time",_pname);
                            try
                            {
                                AddArray(process.Id, _stdtime, process.WorkingSet, pcm);
                            }catch(Exception e3)
                            {
 
                            }
								continue;
							}
                        //						richTextBox1.Text+=((System.Diagnostics.PerformanceCounter)_processLastCPU[_curpoint]).NextValue().ToString()+"\r\n";
                        try
                        {
                            float cur_rank = ((System.Diagnostics.PerformanceCounter)_processLastCPU[_curpoint]).NextValue();
                            _checktime = System.DateTime.Now;  //檢測時間為當前時間
                                                               //開始分析CPU策略
                            if (ref_cl == "cpu")
                            {
                                //如果當前進程的CPU占用率沒有超過指定的上限，則重置最后的檢測時間為當前時間，繼續(xù)監(jiān)測。
                                if (cur_rank < ref_rank)
                                {
                                    _processLastTime[_curpoint] = _checktime;
                                }
                            }
                        }catch(Exception e2)
                        {
                            continue;
                        }
							//開始分析memory策略
							if(ref_cl=="memory")
							{
								float _curmem=process.WorkingSet/(1024*1024);
								//							richTextBox1.Text+=_pname+" "+_curmem.ToString()+"\r\n";
								//如果當前進程的內存占用沒有超過指定的上限，則重置最后的檢測時間為當前時間，繼續(xù)監(jiān)測。
								if(_curmem<ref_rank)
								{
									_processLastTime[_curpoint]=_checktime;
								}
							}
							_gcSpan=ref_span;  //得到用戶指定的回收時間差
							_kill=false;
							_pdatetime=_processLastTime[_curpoint]; //得到進程的數組最后指定時間
							_dd=_checktime-_pdatetime;     //時間差以檢測時間 減去 進行啟動時間
							//如果時間差大于回收指定時間則可以回收進程，KILL變量為真
							if(checkBox1.Checked)
							{
								//只回收本程序啟動以后的進程時間
								if((_dd.TotalSeconds>_gcSpan)&&(_starttime<_pdatetime))
								{
									_kill=true;
								}
							}
							else
							{
								if(_dd.TotalSeconds>_gcSpan)
								{
									_kill=true;
								}
							}
							//如果初期標識為可以關閉該進程，并且策略為強制性關閉，則進行內存判斷
							if((_kill)&&(ref_cl=="force"))
							{
								//如果內存有變化，則表示進程仍在活動，則不進行關閉，并更新檢測內容
								int _curmem=process.WorkingSet;
								label6.Text=_curmem.ToString()+"  "+_processLastMem[_curpoint];
								if(_curmem!=_processLastMem[_curpoint])
								{
									_processLastTime[_curpoint]=_checktime;
									_processLastMem[_curpoint]=_curmem;
									_kill=false;
								}
							}
							//如果指定了強制關閉時間，則進行判斷
							string close_tip="";
							if(ref_closetime!="")
							{
								DateTime ref_cls=DateTime.Parse(ref_closetime);
								if((ref_cls.Hour==cur_hour)&&(ref_cls.Minute==cur_min)&&(ref_cls.Second==cur_sec))
								{
									_kill=true;
								    close_tip="強制關閉計劃啟動，計劃時間為："+ref_closetime;
								}
							}
							//如果只回收死進程，而當前進程為激活的窗口的話，則不關閉
							if((_phandle)&&((int)process.MainWindowHandle!=0))
							{
								_kill=false;
							}
 
							//如果可以回收則在文本框中添加回收狀態(tài)，并將進程關閉
							if(_kill)
							{
								if(!process.HasExited)
								{
									if(ref_act=="kill")
									{
										//								MessageBox.Show("has exited");
										_killstate=close_tip+".進程"+_pname+"已被回收，關閉策略為"+ref_cl+"，動作為："+ref_act+"。進程的啟動時間為"+
											_pdatetime.ToString()+"，檢測時間為："+_checktime.ToString()+
											"，現已經超時"+(_dd.TotalSeconds-_gcSpan).ToString()+
											"秒，回收時間單位是"+_gcSpan.ToString()+"秒。"+
											"進程ID："+process.Id.ToString()+
											"進程主窗口句柄："+process.MainWindowHandle.ToString();
										process.Kill();
										richTextBox1.AppendText(_killstate+"\r\n");
									}
									if(ref_act=="command")
									{
										//								MessageBox.Show("has exited");
										string _return="";
										for(int st=0;st<ref_cmd1.GetLength(0);st++)
										{
											_return+=ref_cmd1[st]+" Result:"+WinExec(ref_cmd1[st],0).ToString()+"↙";
										}
										_killstate=close_tip+".進程"+_pname+"已被回收，關閉策略為"+ref_cl+"，動作為："+ref_act+"，執(zhí)行了命令："+
											ref_cmd1+"。返回值為："+_return+"。進程的啟動時間為"+
											_pdatetime.ToString()+"，檢測時間為："+_checktime.ToString()+
											"，現已經超時"+(_dd.TotalSeconds-_gcSpan).ToString()+
											"秒，回收時間單位是"+_gcSpan.ToString()+"秒。"+
											"進程ID："+process.Id.ToString()+
											"進程主窗口句柄："+process.MainWindowHandle.ToString();
										richTextBox1.AppendText(_killstate+"\r\n");
										//										process.Kill();
									}
									//清空當前進程檢測數組元素
									_processid[_curpoint]=0;
									_processLastTime[_curpoint]=_checktime;
									_processLastMem[_curpoint]=0;
									_processLastCPU[_curpoint]=null;
								}//判斷進程是否已經退出
							}
						}//if proecess
						else //如果沒有找到進程名稱，則二次判斷任務是否提供了啟動命令，如果提供，則運行它
						{
						}//end find process name
					}//li
				}//for
			processes = System.Diagnostics.Process.GetProcesses(); //獲得當前進程組
			for(int ali=0;ali<listBox1.Items.Count;ali++)
			{
				_rv=listBox1.Items[ali].ToString().Split('|');
				string ref_process=_rv[0].ToLower().Trim();
				int ref_span=int.Parse(_rv[1].ToString());
				string ref_cl=_rv[2].ToLower().Trim();
				float ref_rank=float.Parse(_rv[3].ToString());
				string ref_stdtime=_rv[4].ToLower().Trim();
				string ref_act=_rv[5].ToLower().Trim();
				string[] ref_cmd1=_rv[6].Split('↙');
				string ref_start_cmd=_rv[7];
				string[] ref_cmd2=_rv[7].Split('↙');
				bool _find=false;
				if(ref_start_cmd!="")
				{
					for(int i = 0;i<processes.Length-1;i++)
				    {
					  process= processes[i];  //獲得當前進程
					  string cur_pname=process.ProcessName.ToLower();  //獲得進程名并轉為小寫
						if(cur_pname==ref_process)
						{
							_find=true;
						}
				    }
					if(!_find)
					{
						string _return="";
						for(int st=0;st<ref_cmd2.GetLength(0);st++)
						{
							_return+=ref_cmd2[st]+" Result:"+WinExec(ref_cmd2[st],0).ToString()+"↙";
						}
						_killstate="進程"+ref_process+"嘗試啟動，關閉策略為"+ref_cl+"，動作為："+ref_act+"，啟動命令為："+
							ref_cmd2+"。返回值為："+_return+"。";
						richTextBox1.AppendText(_killstate+"\r\n");
					}
				}
			}//end for listbox
 
		}