精华内容
下载资源
问答
  • 2022-03-15 17:40:13

    在windows下创建守护进程A和B ,在其中一个挂掉以后,另一个会把挂掉的拉起来。

    下面展示一些 内联代码片

    这里只列出了A的代码,B和A类似。

    #include<iostream>
    #include<Windows.h>
    #include<tchar.h>
    #include <tlhelp32.h>//声明快照函数的头文件
    
    bool IsProcessRun(const WCHAR * pName)  //查看进程是否运行
    {
    	HANDLE hProcessSnap;
    	HANDLE hProcess;
    	PROCESSENTRY32 pe32;
    	DWORD dwPriorityClass;
    
    	bool bFind = false;
    	// Take a snapshot of all processes in the system.
    	hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    	if (hProcessSnap == INVALID_HANDLE_VALUE)
    	{
    		return false;
    	}
    
    	// Set the size of the structure before using it.
    	pe32.dwSize = sizeof(PROCESSENTRY32);
    
    	// Retrieve information about the first process,
    	// and exit if unsuccessful
    	if (!Process32First(hProcessSnap, &pe32))
    	{
    		CloseHandle(hProcessSnap);          // clean the snapshot object
    		return false;
    	}
    	// Now walk the snapshot of processes, and
    	// display information about each process in turn
    	do
    	{
    		// Retrieve the priority class.
    		dwPriorityClass = 0;
    		if (::wcsstr(pe32.szExeFile, pName) != NULL)
    		{
    			bFind = true;
    			break;
    		}
    	} while (Process32Next(hProcessSnap, &pe32));
    
    	CloseHandle(hProcessSnap);
    	return bFind;
    }
    
    int main()
    {
    	STARTUPINFO si;
    	PROCESS_INFORMATION pi; //进程信息:
    
    	ZeroMemory(&si, sizeof(si));
    	si.cb = sizeof(si);
    	ZeroMemory(&pi, sizeof(pi));
    
    	DWORD dwExitCode;
    	TCHAR szCommandLine[] = L"cmd /c  D://c++//vs2019//test3//Debug//test3.exe";     
    	//Spawn the child process.
    	while (1)
    	{
    		if (IsProcessRun(L"test3.exe"))
    		{
    			Sleep(1000);
    			printf("test3 正在运行\n");
    		}
    		else
    		{
    			printf("test3 未运行\n");                             
    			BOOL fSuccess = CreateProcess(NULL, szCommandLine, NULL, NULL, FALSE,CREATE_NEW_CONSOLE, NULL, NULL, &si, &pi);
    												//CREATE_NEW_CONSOLE 新进程拥有新的终端
    			if (!fSuccess)
    			{
    				std::cout << "子进程创建失败" << std::endl;
    				system("pause");
    				return 0;
    			}
    			std::cout << "子进程信息1" << std::endl;
    			std::cout << "子进程id: " << pi.dwProcessId << std::endl;
    			std::cout << "子线程id: " << pi.dwThreadId << std::endl;
    
    			WaitForSingleObject(pi.hProcess, INFINITE);
    
    			CloseHandle(pi.hProcess);
    			CloseHandle(pi.hThread);
    		}
    	}
    	std::cout << "子进程结束" << std::endl;
    	system("pause");
    	return 0;
    }
    

    感谢大家观看 同时如果发现问题 希望指出 大家一起进步

    更多相关内容
  • 用vs2015 C/C++创建windows守护进程

    千次阅读 2022-04-02 10:07:05
    C/C++创建windows守护进程

    创建服务程序可以参考https://blog.csdn.net/chenyujing1234/article/details/8023816

    此处为调用exe文件,在进程中和前台都可以显示。以下部分为主要代码。

    BOOL Sever::RunProcess(const std::string path)
    {
    	STARTUPINFO si = { 0 };
    	// 进程信息 
    	PROCESS_INFORMATION pi = { 0 };
    
    	si.cb = sizeof(si);
    	// 获得当前Session ID   
    	DWORD dwSessionID = WTSGetActiveConsoleSessionId();
    	HANDLE hToken = NULL;
    	// 获得当前Session的用户令牌        
    	if (::WTSQueryUserToken(dwSessionID, &hToken) == FALSE)
    	{
    		return FALSE;
    	}
    
    	HANDLE hDuplicatedToken = NULL;
    
    	if (DuplicateTokenEx(hToken, MAXIMUM_ALLOWED, NULL, SecurityIdentification, TokenPrimary, &hDuplicatedToken) == FALSE)
    	{
    		return FALSE;
    	}
    
    	// 创建用户Session环境   
    	LPVOID lpEnvironment = NULL;
    
    	if (CreateEnvironmentBlock(&lpEnvironment, hDuplicatedToken, FALSE) == FALSE)
    	{
    		return FALSE;
    	}
    
    	//WCHAR lpszClientPath[MAX_PATH];
    	wchar_t * lpszClientPath = new wchar_t[MAX_PATH];
    	swprintf(lpszClientPath, MAX_PATH,L"%S ", path.c_str());//注意大写S。
    // 	if (GetModuleFileName(NULL, lpszClientPath, MAX_PATH) == 0)
    // 	{
    // 		return FALSE;
    // 	}
    
    	//PathRemoveFileSpec(lpszClientPath); 
    	wcscat(lpszClientPath,L" ");
    
    	fprintf(file, "path! %s\n", lpszClientPath);
    	DWORD dwCreationFlags = NORMAL_PRIORITY_CLASS | CREATE_NEW_CONSOLE | CREATE_UNICODE_ENVIRONMENT;
    	if (CreateProcessAsUser(hDuplicatedToken, lpszClientPath, NULL, NULL, NULL, FALSE, dwCreationFlags, lpEnvironment, NULL, &si, &pi) == TRUE)
    	{
    		fprintf(file, "CreateProcessAsUser ok!\n");
    	}
    	else
    	{
    		fprintf(file, "CreateProcessAsUser false!\n");
    	}
    
    	CloseHandle(pi.hProcess);
    	CloseHandle(pi.hThread);
    	delete[]lpszClientPath;
    	lpszClientPath = NULL;
    	return TRUE;
    }

    注:1.如果服务启动后就自动关闭有可能系统缺少必要的库可以用 DirectX_Repair修复工具进行修复

     

    2.一定不要用远程桌面进行启动。这样通过调用WTSQueryUserToken()在会话上获取用户令牌,错误代码为1008.则导致程序无法正常运行.

    展开全文
  • windows守护进程

    千次阅读 2021-01-12 17:04:03
    1、windows没有fork函数,无法创建僵尸进程,使用打开非子进程的方式打开外部进程---打开外部进程 2、守护进程应该是单例的进程---》单例进程 3、守护进程应该是存在一个子线程不断的判断是否存在守护目标,若不...

    一、逻辑分析

    1、windows没有fork函数,无法创建僵尸进程,使用打开非子进程的方式打开外部进程---打开外部进程

    2、守护进程应该是单例的进程---》单例进程

    3、守护进程应该是存在一个子线程不断的判断是否存在守护目标,若不存在(异常退出)则启动守护目标

    4、当守护目标正常退出时,需要关闭守护进程

    (1)、直接kill掉守护进程(守护进程没有做成病毒进程(系统进程)---记录下这里没找到方法)

    (2)、进程间通讯实现关闭守护进程---有很多的方法博主使用的是命名管道

    二、守护线程

    #pragma once
    
    #include <QThread>
    
    class HiDaemon : public QThread
    {
    	Q_OBJECT
    public:
    	HiDaemon(QObject *parent = nullptr);
    	~HiDaemon();
    
    public slots:
    	void start();
    	void stop();
    
    private:
    	void run();
    
    private:
    	volatile bool			m_bRunning;
    
    	QString					m_strFilePath;
    	QString					m_strProducerName;
    };
    
    #include "HiDaemon.h"
    #include <windows.h>
    #include "tlhelp32.h"
    #include "tchar.h"
    #include "HiDaemonDef.h"
    #include "HiUtils.h"
    #include <QMessageBox>
    
    HiDaemon::HiDaemon(QObject *parent)
    	: QThread(parent)
    	, m_bRunning(false)
    	, m_strProducerName("")  // 这里自定义默认值
    {
    	m_strFilePath = QApplication::applicationDirPath();
    
    	QStringList strList = QApplication::arguments();
    	if (strList.size() > 1)
    	{
    		m_strProducerName = strList.at(1);
    	}
    }
    
    HiDaemon::~HiDaemon()
    {
    }
    
    void HiDaemon::start()
    {
    	if (m_bRunning)
    	{
    		return;
    	}
    	m_bRunning = true;
    
    	QThread::start();
    }
    
    void HiDaemon::stop()
    {
    	m_bRunning = false;
    	wait(1000);
    }
    
    void HiDaemon::run()
    {
    	STARTUPINFOA si;
    	//进程对象
    	PROCESS_INFORMATION pi;
    	//初始化 
    	ZeroMemory(&si, sizeof(si));
    	si.cb = sizeof(si);
    	ZeroMemory(&pi, sizeof(pi));
    
    	//构造cmd执行守护进程的字符串
    	char pCmd[MAX_PATH_NUM] = { 0 };
    
    	{
    		QFileInfo file(m_strFilePath + QDir::separator() + m_strProducerName);
    
    		QString strFilePath = file.filePath();
    		strcat_s(pCmd, strFilePath.toStdString().c_str());
    	}
    	
    	while (m_bRunning)
    	{
    		//检查守护程序是否存在
    		pi.hProcess = GetProcessHandleByName(m_strProducerName);
    
    		if (pi.hProcess == nullptr)
    		{
    			// 创建子进程,判断是否执行成功
    			if (CreateProcessA(NULL, pCmd, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi))
    			{
    				// 创建失败
    			}
    		}
    
    		if (pi.hProcess != nullptr)
    		{
    			//无限等待子进程退出
    			WaitForSingleObject(pi.hProcess, INFINITE);
    			CloseHandle(pi.hProcess);
    			CloseHandle(pi.hThread);
    		}
    		
    
    		Sleep(100);
    	}
    }
    

    二、命名管道实时通讯

    #pragma once
    #include <windows.h>
    #include <QThread>
    
    //
    //HANDLE CreateNamedPipe(
    //	LPCTSTR lpName,								// pipe name
    //	DWORD dwOpenMode,							// pipe open mode
    //	DWORD dwPipeMode,							// pipe-specific modes
    //	DWORD nMaxInstances,						// maximum number of instances
    //	DWORD nOutBufferSize,						// output buffer size
    //	DWORD nInBufferSize,						// input buffer size
    //	DWORD nDefaultTimeOut,						// time-out interval
    //	LPSECURITY_ATTRIBUTES lpSecurityAttributes  // SD
    //  );
    //
    
    class HiNamePipeServer : public QThread
    {
    	Q_OBJECT
    public:
    	HiNamePipeServer(QObject *parent = nullptr);
    	~HiNamePipeServer();
    
    	void start();
    	void stop();
    
    private slots:
    	void onParse();
    
    private:
    	void creatPipe();
    	void run();
    
    signals:
    	void parse();
    	void stopDaemon();
    
    private:
    	HANDLE						 m_pHandle;
    	HANDLE						 m_pEvent;
    	volatile bool				 m_bRunning;
    	char						 m_readbuffer[100];
    	DWORD						 m_readLenth;
    	bool						 m_resetStarted;
    	QString						 m_strFilePath;
    	QString						 m_strProducerName;
    };
    #include "HiNamePipeServer.h"
    #include <windows.h>
    #include <QDebug>
    #include "HiDaemonDef.h"
    #include "HiUtils.h"
    HiNamePipeServer::HiNamePipeServer(QObject *parent)
    	: QThread(parent)
    	, m_bRunning(false)
    	, m_pHandle(nullptr)
    	, m_resetStarted(false)
    {
    	creatPipe();
    	connect(this, &HiNamePipeServer::parse, this, &HiNamePipeServer::onParse, Qt::DirectConnection);
    	m_strFilePath = QApplication::applicationDirPath();
    
    	QStringList strList = QApplication::arguments();
    	if (strList.size() > 1)
    	{
    		m_strProducerName = strList.at(1);
    	}
    }
    
    HiNamePipeServer::~HiNamePipeServer()
    {
    	if (m_pHandle)
    	{
    		CloseHandle(m_pHandle);
    	}
    	CloseHandle(m_pEvent);
    }
    
    void HiNamePipeServer::start()
    {
    	if (m_bRunning)
    	{
    		return;
    	}
    	m_bRunning = true;
    	QThread::start();
    }
    
    void HiNamePipeServer::stop()
    {
    	m_bRunning = false;
    }
    
    void HiNamePipeServer::onParse()
    {
    	QString strMsg = m_readbuffer;
    
    	QStringList paramList = strMsg.split(WRITE_SPACER);
    	if (paramList.size() != 2)
    	{
    		return;
    	}
    	
    	PipeWriteType writeType = PipeWriteType(paramList.at(0).toInt());
    
    	switch (writeType)
    	{
    	case PipeWriteType_ClientExit:
    	{
    		emit stopDaemon();
    		qApp->quit();
    		break;
    	}
    	case PipeWriteType_ClinetRestart:
    	{
    		if (m_resetStarted == false)
    		{
    			m_resetStarted = true;
    			KillProcess(m_strProducerName);
    		}
    		break;
    	}
    	default:
    		break;
    	}
    
    }
    
    void HiNamePipeServer::creatPipe()
    {
    	m_pHandle = CreateNamedPipe(PIPE_NAME, PIPE_ACCESS_DUPLEX, PIPE_TYPE_BYTE | PIPE_READMODE_BYTE, PIPE_MAXINSTANCES, 0, 0, 1000, NULL);
    	if (INVALID_HANDLE_VALUE == m_pHandle)
    	{
    		CloseHandle(m_pHandle);
    		// 创建管道失败
    		m_pHandle = nullptr;
    	}
    }
    
    void HiNamePipeServer::run()
    {
    	// 这里暂时同步调用,可以考虑使用异步设置超时事件
    	while (m_bRunning)
    	{
    		OVERLAPPED  ovlap;
    		ZeroMemory(&ovlap, sizeof(OVERLAPPED));
    		//2. 创建管道连接
    		if (!ConnectNamedPipe(m_pHandle, &ovlap))
    		{
    			if (ERROR_IO_PENDING != GetLastError())
    			{
    				Sleep(100);
    				continue;
    			}
    		}
    
    		// 这个等待可能非常的久
    		if (ReadFile(m_pHandle, m_readbuffer, 100, &m_readLenth, NULL) == TRUE)
    		{
    			emit parse();
    		}
    		DisconnectNamedPipe(m_pHandle);
    	}
    }
    

    管道读取线程是阻塞的

    三、主函数

    #include <stdio.h>
    #include <stdlib.h>
    #include <io.h>
    #include <iostream>
    #include <string>
    #include <QString>
    #include <QApplication>
    #include "HiNamePipeServer.h"
    #include "HiDaemon.h"
    #include <QObject>
    #include "HiSingleApplication.h"
    
    LPCTSTR szAppClassName = TEXT("HiDaemon");
    LPCTSTR szAppWindowName = TEXT("HiDaemon");
    
    
    // HANDLE hProcess = ::OpenProcess(PROCESS_TERMINATE, FALSE, dwProcessID);
    // ::TerminateProcess(hProcess, 0);
    // CloseHandle(hProcess);
    
    using namespace std;
    
    // 隐藏DOS黑窗口
    #ifdef _MSC_VER
    #pragma comment( linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"" )
    #endif
    
    int main(int argc, char* argv[])
    {
    	HiSingleApplication a(argc, argv);
    	// 这里应该传入的产品类型,不同的产品,启动后可能动作不一致
    	QCoreApplication::setOrganizationName("EnlightV");
    	QCoreApplication::setApplicationName("HiDaemon");
    	if (a.isRunning())
    	{
    		return 0;
    	}
    
    	HiDaemon *daemon = new HiDaemon;
    	HiNamePipeServer *server = new HiNamePipeServer;
    
    	QObject::connect(server, &HiNamePipeServer::stopDaemon, daemon, &HiDaemon::stop, Qt::DirectConnection);
    
    	daemon->start();
    	server->start();
    
    	a.exec();
    
    	return 0;
    }

    四、应用程序启动守护进程

    // 获取守护进程句柄
    HANDLE GetProcessHandleByName(const QString &name)
    {
    	HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    	if (INVALID_HANDLE_VALUE == hSnapshot)
    	{
    		return NULL;
    	}
    	PROCESSENTRY32 pe = { sizeof(pe) };
    	BOOL fOk;
    	for (fOk = Process32First(hSnapshot, &pe); fOk; fOk = Process32Next(hSnapshot, &pe))
    	{
    		if (QString::fromWCharArray(pe.szExeFile) == name)
    		{
    			CloseHandle(hSnapshot);
    			return GetProcessHandle(pe.th32ProcessID);
    		}
    	}
    	return NULL;
    }
    
    //tempPath 是自定义的一个可写目录
    void StartDaemon(const QString &tempPath)
    {
    	// 1、检测守护进程是否已经启动了
    	if (GetProcessHandleByName(DAEMON_NAME) != nullptr)
    	{
    		return;
    	}
    
    	QString batFile = tempPath + QDir::separator() + "StartDaemon.bat";
    	if (QFile(batFile).exists())
    	{
    		QFile(batFile).remove();
    	}
    
    	QFile file(batFile);
    	if (file.open(QFile::ReadWrite))
    	{
    		QString strParam = QString("@echo off \n start /d  \"%1\" HiDaemond.exe  \"%2\" \n exit").arg(QCoreApplication::applicationDirPath()).arg(QFileInfo(QCoreApplication::applicationFilePath()).fileName());
    		file.write(strParam.toLocal8Bit());
    		file.close();
    
    		QProcess p;
    		p.start("cmd.exe", QStringList() << "/c" << batFile);
    		if (p.waitForStarted())
    		{
    			p.waitForFinished(2000);
    			return;
    		}
    	}
    	else
    	{
    		QString strAppPath = QApplication::applicationDirPath();
    		QStringList arguments;
    		{
    			QFileInfo file(QApplication::applicationFilePath());
    			arguments.append(file.fileName());
    		}
    		QFileInfo deamonFile(strAppPath + QDir::separator() + DAEMON_NAME);
    		if (deamonFile.exists())
    		{
    			std::wstring operate = QString("runas").toStdWString();//临时提升管理员权限
    			std::wstring path = QCoreApplication::applicationDirPath().toStdWString();
    			std::wstring appName = QFileInfo(QCoreApplication::applicationFilePath()).fileName().toStdWString();;
    			std::wstring file = deamonFile.filePath().toStdWString();
    			int ret = (int)ShellExecute(NULL, operate.c_str(), file.c_str(), appName.c_str(), path.c_str(), SW_SHOWNORMAL);
    		}
    
    	}
    }
    

    五、主端关闭时候,通讯给守护进程自行关闭

    #pragma once
    
    #include <windows.h>
    
    class HiNamePipeClient
    {
    public:
    	static HiNamePipeClient* getInstance();
    	void writeFile(PipeWriteType type,  const QString & param = QString());
    
    protected:
    	HiNamePipeClient();
    	~HiNamePipeClient();
    
    private:
    	bool openPipe();
    
    private:
    	HANDLE  m_pHandle;
    };
    
    inline HiNamePipeClient *pipeClient()
    {
    	return HiNamePipeClient::getInstance();
    }
    #include "HiNamePipeClient.h"
    #include "guard.h"
    
    enum PipeWriteType
    {
    	PipeWriteType_ClientExit = 0,							// 客户端正常退出
    	PipeWriteType_ClinetRestart,							// 客户端重启
    };
    
    HiNamePipeClient* HiNamePipeClient::getInstance()
    {
    	static HiNamePipeClient instance;
    	return &instance;
    }
    
    void HiNamePipeClient::writeFile(PipeWriteType type, const QString & param)
    {
    #if HIRENDER_C_SERIES
    	if (openPipe())
    	{
    		DWORD dwWriteLen = 0;
    		QString strParam = QString("%1#%2").arg((int)type).arg(param);
    		if (WriteFile(m_pHandle, strParam.toStdString().c_str(), strParam.length(), &dwWriteLen, NULL))
    		{
    			// 写入成功
    		}
    		CloseHandle(m_pHandle);
    		m_pHandle = nullptr;	
    	}
    	Sleep(200);
    #endif
    }
    
    HiNamePipeClient::HiNamePipeClient()
    	: m_pHandle(nullptr)
    {
    
    }
    
    HiNamePipeClient::~HiNamePipeClient()
    {
    
    }
    
    bool HiNamePipeClient::openPipe()
    {
    	if (m_pHandle)
    	{
    		CloseHandle(m_pHandle);
    	}
    	if (!WaitNamedPipe(PIPE_NAME, PIPE_TIMEOUT))
    	{
    		// 当前没有可利用的命名管道实例!
    		return false;
    	}
    
    	m_pHandle = CreateFile(PIPE_NAME, GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    	if (INVALID_HANDLE_VALUE == m_pHandle)
    	{
    		// "打开命名管道失败!
    		m_pHandle = NULL;
    		return false;
    	}
    	return true;
    }
    

    六、强制关闭守护进程(提供方法、博主程序中未使用)

    
    bool KillProcess(QString ProcessName)
    {
    	QProcess p;
    	QString c = "taskkill /im " + ProcessName + " /f";    //exeFileName为要杀死的进程名
    	p.execute(c);
    	p.close();
    	return true;
    }

     

    展开全文
  • Qt编写守护进程

    2019-03-02 14:56:06
    本篇文章提供一个软件实现守护进程的办法,原理就是udp通信,单独写个守护进程程序,专门负责检测主程序是否存在,不存在则启动。主程序只需要启动live类监听端口,收到hello就回复ok就行。 为了使得兼容任意程序,...
  • Windows守护进程的一种简单实现

    千次阅读 2019-02-12 12:50:39
    @描述:一个简单的Windows守护进程的例子(C++版本) @作者:kikaylee @日期:2016-05-13 10:30 */   #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;Windows.h&gt; ...

    @描述:一个简单的Windows守护进程的例子(C++版本)
    @作者:kikaylee
    @日期:2016-05-13 10:30
    */

     

    #include <stdio.h>
    #include <stdlib.h>
    #include <Windows.h>
    #include <io.h>
    #include <iostream>

     

    using namespace std;

     

    //隐藏DOS黑窗口
    #pragma comment(linker,"/subsystem:\"windows\"  /entry:\"mainCRTStartup\"" )

     

    //定义路径最大程度
    #define MAX_PATH 4096
    //定义守护进程名称
    #define PROCCESS_NAME "test.exe"
    //定义写入的注册表路径
    #define SELFSTART_REGEDIT_PATH "Software\\Microsoft\\Windows\\CurrentVersion\\Run\\"

     

    //设置本身开机自启动
    BOOL SetSelfStart()
    {
        //获取程序完整名称
        char pName[MAX_PATH]={0};
        GetModuleFileNameA(NULL,pName,MAX_PATH);

     

        //在注册表中写入启动信息
        HKEY hKey=NULL;
        LONG lRet=NULL;
        lRet=RegOpenKeyExA(HKEY_LOCAL_MACHINE,SELFSTART_REGEDIT_PATH,0,KEY_ALL_ACCESS,&hKey);

     

        //判断是否成功
        if(lRet!=ERROR_SUCCESS)
        {
            return FALSE;
        }

     

        lRet=RegSetValueExA(hKey,"testProtect",0,REG_SZ,(const unsigned char*)pName,strlen(pName)+sizeof(char));

     

        //判断是否成功
        if(lRet!=ERROR_SUCCESS)
        {
            return FALSE;
        }

     

        //关闭注册表
        RegCloseKey(hKey);
        return TRUE;
    }

     

    int main()
    {
        //设置程序开机自启动
        if(!SetSelfStart())
        {
            cout<<"守护进程开机自启动失败"<<endl;
            return -1;
        }

     

        STARTUPINFOA si;
        //进程对象
        PROCESS_INFORMATION pi;
        //初始化
        ZeroMemory(&si,sizeof(si));
        si.cb=sizeof(si);
        ZeroMemory(&pi,sizeof(pi));

     

        //获取当前程序的路径
        char pPath[MAX_PATH]={0};
        GetCurrentDirectoryA(MAX_PATH,pPath);

     

        //拼接需要守护的程序
        strcat(pPath,"\\");
        strcat(pPath,PROCCESS_NAME);

     

        //构造cmd执行守护进程的字符串
        char pCmd[MAX_PATH]={0};
        strcat(pCmd,"cmd /c ");
        strcat(pCmd,pPath);

     

        //无限循环,监视守护进程
        do{
            //检查守护程序是否存在
            if(_access(pPath,0)!=-1)
            {
                //创建子进程,判断是否执行成功
                if(!CreateProcessA(NULL,pCmd,NULL,NULL,FALSE,0,NULL,NULL,&si,&pi))
                {
                    cout<<"守护进程启动失败,程序即将退出"<<endl;
                    return -1;
                }

                //启动成功,获取进程的ID
                cout<<"守护进程成功,ID:"<<pi.dwProcessId<<endl;
                //无限等待子进程退出
                WaitForSingleObject(pi.hProcess,INFINITE);
                //如果退出了
                cout<<"守护进程退出了。。。"<<endl;
                //关闭进程和句柄
                CloseHandle(pi.hProcess);
                CloseHandle(pi.hThread);
            }
            else
            {
                cout<<"守护程序不存在"<<endl;
            }
            //睡一下,重启
            Sleep(2000);
        }
        while(true);
        return 0;
    }
    ---------------------
    作者:kikay
    来源:CSDN
    原文:https://blog.csdn.net/kikaylee/article/details/51395360
    版权声明:本文为博主原创文章,转载请附上博文链接!

    展开全文
  • windows创建守护进程的简便方式

    千次阅读 2012-04-05 08:38:04
    这是一篇关于Win下创建守护进程的文章,很入门,为了NAE的邀请码! 前段时间做了一个代理工具,主要功能是将线上assets服务器(单独域名存放css、js或其它文件)指向本地80端口,当请求文件在磁盘上存在则读取,...
  • windows服务守护进程

    千次阅读 2020-04-29 13:55:29
    windows服务守护进程为什么选择用服务来守护进程注册服务双服务互相守护服务启动进程并保活启动进程进程保活 最近做一个项目, 保护我们云电脑中的计费程序等应用程序、脚本,不被用户结束。 综合各种方案,最终选择...
  • Golang创建守护进程

    2021-04-12 19:46:19
    一、 守护进程创建步骤 二、代码实现 func Daemon() { //父进程为init,已经是一个守护进程 if syscall.Getppid() == 1 { fmt.Println("process is already a daemon") } /* *fork 一个子进程 若...
  • 主要介绍了php实现简单的守护进程创建、开启与关闭操作,结合实例形式分析了基于pcntl扩展的php守护进程类定义、启动及关闭等相关操作技巧,需要的朋友可以参考下
  • 守护进程创建

    2019-03-10 08:30:59
    Linux的大多数服务器就是用守护进程实现的。比如,Internet服务器inetd,Web服务器httpd等。同时,守护进程完成许多系统任务。比如,作业规划进程crond,打印进程lpd等。(这里的结尾字母d就是Daemon的意思)1. 使...
  • 守护进程 1、守护进程的特点: 运行周期长,在后台执行,一般不需要和用户进行交互 2、相关概念: 会话:一个终端的打开会伴随着一个会话的建立,当退出终端,会话结束 会话首进程:终端运行的第一个进程 会话首进程...
  • Linux系统下创建守护进程(Daemon)

    万次阅读 多人点赞 2018-07-30 17:29:50
    守护进程(daemon)是指在...守护进程在后台运行,类似于Windows中的系统服务。    编写守护进程程序的要点:   (1)让程序在后台执行。方法是调用fork()产生一个子进程,然后使父进程退出。 (2)调用se...
  • Linux守护进程是Linux的后台服务进程,相当于Windows服务,对于为Linux开发服务程序的朋友来说,Linux守护进程相关技术是必不可少的,因为这个技术不仅仅是为了开发守护进程,还可以拓展到多进程,父子进程文件描述...
  • Unix/Linux中的守护进程(Daemon)类似于Windows中的后台服务进程,一直在后台长时间运行的进程。它通常在系统启动后就运行,没有控制终端,也无法和前台的用户交互,在系统关闭时才结束。Daemon程序一般都作为服务...
  • 使用NSSM配置守护进程 Nginx(Windows

    千次阅读 2021-12-10 21:53:25
    使用NSSM配置守护进程
  • C#守护进程windows服务)

    千次阅读 2019-09-21 03:37:49
    一、创建Windows Service 1、新建一个Windows Service,并将项目名称改为“MyWindowsService”,如下图所示: 2、在解决方案资源管理器内将Service1.cs改为MyService1.cs后并点击“查看代码”图标按钮进入代码...
  • 大多数的解决方法是使用其他进程来守护服务器程序,如果服务器程序挂了,通过守护进程来启动服务器程序。 万一守护进程挂了呢?使用双守护来提高稳定性,守护A负责监控服务器程序与守护B,守护B负责监控守护A,任何...
  • Windows守护进程简单示例

    千次阅读 2018-12-28 15:41:47
    @描述:一个简单的Windows守护进程的例子(C++版本) @作者:kikaylee @日期:2016-05-13 10:30 */ #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;Wind...
  • 首先介绍下守护进程吧,守护进程是一个在后台运行并且不受任何终端控制的进程,守护某个程序异常关闭后,通过守护进程将其自动启动起来。而本文介绍的守护进程为通过检测程序的一些事件或采集的数据,将当前守护进程...
  • 1. Java实现Windows下双守护进程 2. 用2个守护进程互为守护彼此及并守护目标程序。 3. 正确配置后,目标程序就会像杀不死的病毒一样无法关闭,关闭后立即重新启动,但操作系统关机后无效。如若要操作系统开机后自动...
  • Windows编程之双进程守护

    千次阅读 2017-12-26 20:25:39
    Windows编程之双进程守护Windows编程之双进程守护 需求分析 设计原理 相关函数 设计详细 方法1 方法2 项目测试情况 方法1 方法2 总结 需求分析设计实现双进程守护程序,当两个进程同时运行时,关闭其中任意一个,另...
  • 转载自: ... ... 守护进程(daemon)是指在后台运行的,没有控制终端与之相连的进程。它独立于控制终端,周期性地执行某种任务。Linux的大多数服务器就是用守护进程的方式实现的。如web服务器...
  • 近期,中心应用服务无故关闭。在检查系统和应用程序日志无果后采取了进程守护的...2、进程守护批处理.bat 使用时需修改守护进程名称和执行用户(3行)、程序启动路径(6行)vbs脚本运行时会创建wscript.exe进程,该进程...
  • 实现守护进程(1)nohup(2)fork()按步骤创建 (1)nohup nohup ——英文全称 no hang up(不挂起),用于在系统后台不挂断地运行命令,退出终端不会影响程序的运行。 nohup 命令,在默认情况下(非重定向时),会...
  • 天马伴侣 如果你知道什么是,并且对Apache为Windows系统提供的托盘...双击之后,天马伴侣就会使用默认配置文件(config.js)启动服务,并在系统托盘里创建一个小图标。在小图标上右键单击后会出现以下菜单: +---------
  • 因为希望主服务随windows开机启动即启动,所以将守护进程和主进程设计成windows服务。 守护服务于主服务间的通讯方式: 1. socket 2. 管道(分为匿名管道和命名管道) 3. WM_COPYDATA消息  WM_COPYDATA是一种非常...
  • Windows下实现代码: BOOL IsExistProcess(const char* szProcessName) { QDateTime startTime = QDateTime::currentDateTime(); PROCESSENTRY32 processEntry32; HANDLE toolHelp32Snapshot = CreateToolhelp32...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 39,752
精华内容 15,900
关键字:

windows创建守护进程