创建服务程序可以参考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.则导致程序无法正常运行.

一、逻辑分析

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;
}

@描述：一个简单的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
版权声明：本文为博主原创文章，转载请附上博文链接！