public void 设置配置(M进程监控配置 __配置)
{
lock (_锁)
{
配置 = __配置;
}
}
public B进程监控(M进程监控配置 __配置)
{
配置 = __配置;
Task.Factory.StartNew(() =>
{
var __比较器 = new B比较器();
while (true)
{
lock (_锁)
{
if (配置.列表.Count == 0)
{
_上次存在进程.Clear();
continue;
}
var __本次存在进程 = new List <M进程状态>();
配置.列表.ForEach(k =>
{
var __进程列表 = Process.GetProcessesByName(k.进程名);
if (__进程列表 != null && __进程列表.Length > 0)
{
__进程列表.ToList().ForEach(q =>
{
try
{
var __标识 = string.Format("{0}-{1}", q.Id, q.ProcessName);
var __路径 = "";
if (_路径缓存.ContainsKey(__标识))
{
__路径 = _路径缓存[__标识];
}
else
{
try
{
__路径 = q.MainModule.FileName;
}
catch (Exception)
{
}
_路径缓存[__标识] = __路径;
}
var __状态 = new M进程状态
{
Id = q.Id,
称 = q.ProcessName,
描述 = k.描述,
启动时间 = q.StartTime,
路径 = __路径
};
__状态.内存 = 获取内存使用(__状态.Id, __状态.称);
__状态.线程数 = 获取线程数(__状态.Id, __状态.称);
__状态.CPU = 获取CPU使用率(__状态.Id, __状态.称);
__本次存在进程.Add(__状态);
if (k.内存阈值.HasValue)
{
if (!_内存阈值告警.ContainsKey(__状态.称))
{
_内存阈值告警[__状态.称] = new H阈值告警 <int>(k.内存阈值.Value, (a, b) => a.CompareTo(b), (__告警, __缓存) =>
{
on阈值告警(string.Format("进程 {0} 内存{1}，明细：{2}", __状态.称, __告警 ? "告警" : "告警解除", string.Join(",", __缓存)));
}, 10, 5);
}
_内存阈值告警[__状态.称].阈值 = k.内存阈值.Value;
_内存阈值告警[__状态.称].添加((int)(__状态.内存 / 1024 / 1024));
}
if (k.CPU阈值.HasValue)
{
if (!_CPU阈值告警.ContainsKey(__状态.称))
{
_CPU阈值告警[__状态.称] = new H阈值告警 <int>(k.CPU阈值.Value, (a, b) => a.CompareTo(b), (__告警, __缓存) =>
{
on阈值告警(string.Format("进程 {0} CPU{1}，明细：{2}", __状态.称, __告警 ? "告警" : "告警解除", string.Join(",", __缓存)));
}, 10, 5);
}
_CPU阈值告警[__状态.称].阈值 = k.CPU阈值.Value;
_CPU阈值告警[__状态.称].添加((int)(__状态.CPU));
}
q.Dispose();
}
catch (Exception ex)
{
H日志.记录异常(ex);
}
});
}
});
_上次存在进程.Except(__本次存在进程, __比较器).ToList().ForEach(q => on进程关闭(q.Id, q.称));
__本次存在进程.Except(_上次存在进程, __比较器).ToList().ForEach(q =>
{
if (q.启动时间.AddSeconds(10) > DateTime.Now)
{
on进程开启(q.Id, q.称, q.启动时间);
}
});
_上次存在进程 = __本次存在进程;
}
Thread.Sleep(配置.频率);
}
});
}
