Windows 程序开机自启动速度优化，为什么腾讯会议自启动速度那么高？

小小哇牛

已于 2023-08-04 11:54:53 修改

阅读量1.4k

点赞数 2

文章标签：腾讯会议运维 c++ windows

于 2023-04-27 14:48:01 首次发布

本文链接：https://blog.csdn.net/HelloNiGeSB/article/details/130405263

版权

2.2Windows常见的自启动方式的细节分析

三、问题的解决方案

1、为什么腾讯会议Rooms那么快

2.我们是否可以跟腾讯会议一样快

一、问题的说明和定义

这两天有个优化项需要做个技术调研，就是我们项目的开机启动时间比较长，大概20多秒，但对比腾讯会议Rooms，这款软件的自启动就异常的快，用户登录几秒就可以看到程序界面。

拿到任务了，开干吧！！！！！！

二、问题的分析

1.问题初步分析

首先分析猜测慢的原因：

从双击程序图标启动那一刻，到看到界面的过程比较耗时，这个做了验证，在4秒左右（这个可有具体负责的工程师单独优化），相比于二十多秒的启动时间，还是有很多其他因素需要优化的。

操作系统的开机自启动有延迟，本文主要分析的是这种场景的耗时点，以及可能的解决方案。

2.详细的分析：

2.1Windows常见的自启动方式

知己知彼百战百胜，所以第一步，先学习了解Windows系统中自启动的方案都有哪些，常见的方式四个

指定文件夹中放入程序快捷方式，或者启动脚本bat文件。
注册表自启动方式
任务计划程序方式
Windows任务自启动

针对上面四种的详细描述，网上一搜一大把，我这里就不在赘述了，但我想把我在分析过程中，针对这几种方案的差别，做个简单的描述

2.2Windows常见的自启动方式的细节分析

针对第一、二种，没啥好说的，个人感觉，私人电脑自己配置可以这么玩，简单粗暴，但针对一款应用软件的功能，这么做就不是很合适了，不推荐

第三种自启动方式，一共有五个注册表类型可以实现自启动，如下：

HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\Run

表示任何账户每一次登陆到Windows系统都会自动启动在这个项下面注册的程序

HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\CurrentVersion\RunOnce

表示任何账户下一次登陆到Windows系统会自动启动在这个项下面注册的程序，以后就不会自启了

HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run

表示当前账户每一次登陆到Windows系统都会自动启动在这个项下面注册的程序

HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\RunOnce

表示当前账户下一次登陆到Windows系统会自动启动在这个项下面注册的程序，以后就不会自启了

HKEY_LOCAL_MACHINE\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Run

表示程序需要已管理员权限启动

自启动耗时在哪里呢？

1、注册表自启动的程序是在用户登录后，是否可以提到用户登录前呢？这样就可以提升启动速度了。针对Win11来说，是可以的，win11有一个控制选项，设置里面，找账户

“使用我的登录信息在更新后自动完成设置” 该选项保持勾选，即可在用户登录前启动

win10应该没有该选项控制

2、windows操作系统有一个注册表的值StartupDelayInMS，可以控制在用户登录后，延迟若干秒后，在自启动应用程序，该机制主要是为了把计算机资源留给操作系统用，该字段默认是没有的，没有的情况下，操作系统的默认延时未10s，可以加上该字段，然后设置其为0，即可取消这10s的延时HKEY_USERS\S-1-5-21-1084762125-4268433165-138902895-1001\Software\Microsoft\Windows\CurrentVersion\Explorer\Serialize

Serialize项如果没有，需要添加一下，然后再该项下，新增一个DWORD的值StartupDelayInMS，设置16进制为0即可

3、如果自启动项比较多的时候，启动顺序是不可控的，这样肯定会有些排在后面，导致启动比较慢，该问题的解决方案会在后面说

第四种方式就是通过服务启动

网上制作服务的博客很多，不在赘述

windows 把exe 设置成服务运行_exe做成服务_小小的技术员的博客-CSDN博客

该方案的优点是，在计算机启动后，服务会优先启动，无论是否用户登录，缺点是从xp或者win7以后，不支持UI界面的服务，如果将UI程序制作为服务，那么UI部分也是不会启动的，原因可参看[笔记]Windows安全之《二》Session0隔离及相关启动技术_会话隔离_二进制怪兽的博客-CSDN博客

下面是启动指定app的服务程序，可参考

#ifndef UITIL_H
#define UITIL_H

#ifdef WIN32
#include <Windows.h>
#include <wingdi.h>
#include <tlhelp32.h>
#include <WinUser.h>
#include <wtsapi32.h>
#include <UserEnv.h>
#endif

#include <string>

class Uitil
{
public:
    Uitil();

    static std::wstring stringToWString(const std::string &string);

    static HANDLE getCurrentUserToken();

    static bool runProgAsCurUser(HANDLE token, const std::string &progPath, const std::string &progArgs);

    static bool RunProgAsCurUserAdminPrivilege(const std::string &progPath, const std::string &progArgs);
};

#endif // UITIL_H

#include "uitil.h"

#include <iostream>
#include <locale>
#include <codecvt>

Uitil::Uitil()
{
}

std::wstring Uitil::stringToWString(const std::string &string)
{
    std::wstring_convert<std::codecvt_utf8<wchar_t>> cv;

    return cv.from_bytes(string);
}

HANDLE Uitil::getCurrentUserToken()
{
    // 查询sessionID
    PWTS_SESSION_INFO pSessionInfo = 0;
    DWORD dwCount = 0;
    ::WTSEnumerateSessions(WTS_CURRENT_SERVER_HANDLE, 0, 1, &pSessionInfo, &dwCount);
    int session_id = 0;
    for (DWORD i = 0; i < dwCount; ++i)
    {
        WTS_SESSION_INFO si = pSessionInfo[i];
        if (WTSActive == si.State)
        {
            session_id = si.SessionId;
            break;
        }
    }

    ::WTSFreeMemory(pSessionInfo);

    // 查询token
    HANDLE current_token = 0;
    BOOL bRet = ::WTSQueryUserToken(session_id, &current_token);
    if (bRet == FALSE)
    {
        std::cout << "WTSQueryUserToken error, code:" << GetLastError() << std::endl;

        return nullptr;
    }

    HANDLE primaryToken = 0;
    bRet = ::DuplicateTokenEx(current_token, TOKEN_ASSIGN_PRIMARY | TOKEN_ALL_ACCESS, 0, SecurityImpersonation, TokenPrimary, &primaryToken);
    ::CloseHandle(current_token);
    if (bRet == FALSE)
    {
        std::cout << "DuplicateTokenEx error, code:" << GetLastError() << std::endl;

        return nullptr;
    }

    return primaryToken;
}

bool Uitil::runProgAsCurUser(HANDLE token, const std::string &progPath, const std::string &progArgs)
{
    STARTUPINFO StartupInfo = {0};
    PROCESS_INFORMATION processInfo;
    StartupInfo.cb = sizeof(STARTUPINFO);

    auto command = std::string("\"") + progPath + "\"";
    if (!progArgs.empty())
    {
        command += " " + progArgs;
    }

    void* lpEnvironment = NULL;
    BOOL resultEnv = ::CreateEnvironmentBlock(&lpEnvironment, token, FALSE);
    if (!resultEnv)
    {
        std::cout << "CreateEnvironmentBlock error, code:" << GetLastError() << std::endl;

        return false;
    }

    std::cout << "runProgAsCurUser, command:" << command << std::endl;

    // 获取到的hUnfilteredToken就是不受限的token，以token作为CreateProcessAsUser的第一个参数，就可以创建出具有管理员权限，并且属于当前用户的界面程序了，并且这种情况下，不需要加入窗口站。
    BOOL result = ::CreateProcessAsUser(token, 0, const_cast<LPWSTR>(Uitil::stringToWString(command).c_str()), NULL, NULL, FALSE, CREATE_NEW_CONSOLE | NORMAL_PRIORITY_CLASS | CREATE_UNICODE_ENVIRONMENT, lpEnvironment, 0, &StartupInfo, &processInfo);
    if(!result)
    {
        std::cout << "CreateProcessAsUser error, code:" << GetLastError() << std::endl;

        return false;
    }

    if(lpEnvironment != NULL)
    {
        ::DestroyEnvironmentBlock(lpEnvironment);
    }

    return true;
}

bool Uitil::RunProgAsCurUserAdminPrivilege(const std::string &progPath, const std::string &progArgs)
{
    // UAC开启时，当前用户拥有两个token，分别是受限的token和不受限的token。explorer.exe进程的token就属于受限的token。
    // 在服务程序中，可以用下面代码获取到受限的token。
    HANDLE primaryToken = getCurrentUserToken();
    if (primaryToken == 0)
    {
        std::cout << "GetCurrentUserToken error." << std::endl;

        return false;
    }

    // 由此token可以得到不受限的token
    bool isOpenOk = false;
    HANDLE hUnfilteredToken = NULL;
    DWORD dwSize = 0;
    BOOL bRet = ::GetTokenInformation(primaryToken, TokenLinkedToken, (VOID*)&hUnfilteredToken, sizeof(HANDLE), &dwSize);
    if (bRet)
    {
        isOpenOk = runProgAsCurUser(hUnfilteredToken, progPath, progArgs);

        ::CloseHandle(hUnfilteredToken);
    }
    else
    {
        // UAC未开时，继续使用原来的token打开
        std::cout << "GetTokenInformation error and continue open width primary token. code:" << GetLastError() << std::endl;

        isOpenOk = runProgAsCurUser(primaryToken, progPath, progArgs);
    }

    ::CloseHandle(primaryToken);

    return isOpenOk;
}

#include <iostream>
#include <Windows.h>
#include <process.h>
#include <processthreadsapi.h>
#include <tlhelp32.h>
#include <tchar.h>
#include <comutil.h>
#include <cwchar>
#include "ini.h"

#pragma warning(disable:4996)

DWORD FindProcessId(char* processName)
{
	// strip path

	char* p = strrchr(processName, '\\');
	if (p)
		processName = p + 1;

	PROCESSENTRY32 processInfo;
	processInfo.dwSize = sizeof(processInfo);

	HANDLE processesSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, NULL);
	if (processesSnapshot == INVALID_HANDLE_VALUE)
		return 0;

	Process32First(processesSnapshot, &processInfo);
	if (!strcmp(processName, processInfo.szExeFile))
	{
		CloseHandle(processesSnapshot);
		return processInfo.th32ProcessID;
	}

	while (Process32Next(processesSnapshot, &processInfo))
	{
		if (!strcmp(processName, processInfo.szExeFile))
		{
			CloseHandle(processesSnapshot);
			return processInfo.th32ProcessID;
		}
	}

	CloseHandle(processesSnapshot);
	return 0;
}

int main()
{
	ini::iniReader config;
	std::string tmp = _pgmptr;
	tmp = tmp.erase(tmp.find_last_of("\\"));
	bool ret = config.ReadConfig(tmp + "\\config.ini");
	if (ret == false)
	{
		printf("ReadConfig is Error,Cfg=%s", "config.ini");
		return 1;
	}
	std::string apppath = config.ReadString("group1", "path", "");
	std::string appname = config.ReadString("group1", "application", "");

	while (!FindProcessId((char *)appname.c_str())) {
		Sleep(200);
		Uitil::RunProgAsCurUserAdminPrivilege(apppath + appname, "");
		int a = 1;
	}
	
	return 1;
}

#ifndef INI_H_
#define INI_H_
#include <string>
#include <map>
#include<fstream>

namespace ini
{
	class iniReader
	{
	public:
		iniReader()
		{
		}
		~iniReader()
		{
		}
		bool ReadConfig(const std::string& filename)
		{
			settings_.clear();
			std::ifstream infile(filename.c_str());//构造默认调用open,所以可以不调用open
			//std::ifstream infile;
			//infile.open(filename.c_str());
			//bool ret = infile.is_open()
			if (!infile) {
				return false;
			}
			std::string line, key, value, section;
			std::map<std::string, std::string> k_v;
			std::map<std::string, std::map<std::string, std::string> >::iterator it;
			while (getline(infile, line))
			{
				if (AnalyseLine(line, section, key, value))
				{
					it = settings_.find(section);
					if (it != settings_.end())
					{
						k_v[key] = value;
						it->second = k_v;
					}
					else
					{
						k_v.clear();
						settings_.insert(std::make_pair(section, k_v));
					}
				}
				key.clear();
				value.clear();
			}
			infile.close();
			return true;
		}

		std::string ReadString(const char* section, const char* item, const char* default_value)
		{
			std::string tmp_s(section);
			std::string tmp_i(item);
			std::string def(default_value);
			std::map<std::string, std::string> k_v;
			std::map<std::string, std::string>::iterator it_item;
			std::map<std::string, std::map<std::string, std::string> >::iterator it;
			it = settings_.find(tmp_s);
			if (it == settings_.end())
			{
				//printf("111");
				return def;
			}
			k_v = it->second;
			it_item = k_v.find(tmp_i);
			if (it_item == k_v.end())
			{
				//printf("222");
				return def;
			}
			return it_item->second;
		}

		int ReadInt(const char* section, const char* item, const int& default_value)
		{
			std::string tmp_s(section);
			std::string tmp_i(item);
			std::map<std::string, std::string> k_v;
			std::map<std::string, std::string>::iterator it_item;
			std::map<std::string, std::map<std::string, std::string> >::iterator it;
			it = settings_.find(tmp_s);
			if (it == settings_.end())
			{
				return default_value;
			}
			k_v = it->second;
			it_item = k_v.find(tmp_i);
			if (it_item == k_v.end())
			{
				return default_value;
			}
			return atoi(it_item->second.c_str());
		}

		float ReadFloat(const char* section, const char* item, const float& default_value)
		{
			std::string tmp_s(section);
			std::string tmp_i(item);
			std::map<std::string, std::string> k_v;
			std::map<std::string, std::string>::iterator it_item;
			std::map<std::string, std::map<std::string, std::string> >::iterator it;
			it = settings_.find(tmp_s);
			if (it == settings_.end())
			{
				return default_value;
			}
			k_v = it->second;
			it_item = k_v.find(tmp_i);
			if (it_item == k_v.end())
			{
				return default_value;
			}
			return atof(it_item->second.c_str());
		}

	private:
		bool IsSpace(char c)
		{
			if (' ' == c || '\t' == c)
				return true;
			return false;
		}

		bool IsCommentChar(char c)
		{
			switch (c)
			{
			case '#':
				return true;
			default:
				return false;
			}
		}

		void Trim(std::string& str)
		{
			if (str.empty())
			{
				return;
			}
			int i, start_pos, end_pos;
			for (i = 0; i < str.size(); ++i) {
				if (!IsSpace(str[i])) {
					break;
				}
			}
			if (i == str.size())
			{
				str = "";
				return;
			}
			start_pos = i;
			for (i = str.size() - 1; i >= 0; --i) {
				if (!IsSpace(str[i])) {
					break;
				}
			}
			end_pos = i;
			str = str.substr(start_pos, end_pos - start_pos + 1);
		}

		bool AnalyseLine(const std::string& line, std::string& section, std::string& key, std::string& value)
		{
			if (line.empty())
				return false;
			int start_pos = 0, end_pos = line.size() - 1, pos, s_startpos, s_endpos;
			if ((pos = line.find("#")) != -1)
			{
				if (0 == pos)
				{
					return false;
				}
				end_pos = pos - 1;
			}
			if (((s_startpos = line.find("[")) != -1) && ((s_endpos = line.find("]"))) != -1)
			{
				section = line.substr(s_startpos + 1, s_endpos - 1);
				return true;
			}
			std::string new_line = line.substr(start_pos, start_pos + 1 - end_pos);
			if ((pos = new_line.find('=')) == -1)
				return false;
			key = new_line.substr(0, pos);
			value = new_line.substr(pos + 1, end_pos + 1 - (pos + 1));
			Trim(key);
			if (key.empty()) {
				return false;
			}
			Trim(value);
			if ((pos = value.find("\r")) > 0)
			{
				value.replace(pos, 1, "");
			}
			if ((pos = value.find("\n")) > 0)
			{
				value.replace(pos, 1, "");
			}
			return true;
		}

	private:
		//std::map<std::string, std::string> settings_;
		std::map<std::string, std::map<std::string, std::string> >settings_;
	};
}
#endif

[group1]
path = C:\\Users\\EEO\\source\\repos\\Project2\\Debug\\
application = Project2.exe

三、问题的解决方案

下面就如何优化启动时间，做一个详细的说明

1、为什么腾讯会议Rooms那么快

在观察了腾讯会议的开机自启动现象后，发现他的启动非常稳定，都是在开机登录后，五到十秒间完成自启动，在此同时，其他软件都比较慢，如有道云笔记、企业微信等等，那为什么会有如此现象呢？

为了探究该问题的原因，初步分析了腾讯会议是如何实现自启动的，发现他也是同过注册表实现的，只不过他是在WOW6432Node下面，然后就怀疑莫非在这个节点下比较快

为了验证猜想，制作了一个demo程序，没有任何复杂逻辑，启动后单纯的显示一个窗口，可排除软件自身效率引入的问题干扰，但通过实验发现，启动时间和其他比较慢的程序一样。进一步分析，为了排除那些未知因素，将demo的启动放入腾讯会议的注册表中

结果依然比较慢，那么到底是为什么腾讯会议就启动的比别的软件快呢？还做了其他无用的验证，比如将腾讯会议的启动项和demo调换等等，不在赘述，这些最终都没定位到真实原因。

偶然间发现，在自启动后，将腾讯会议最小化，过个十几二十秒后，腾讯会议会自动再次弹出来，而且这个时间点和其他自启动比较慢的软件的时间点是一致的，所以怀疑其在注册表启动前，通过某种手段已经启动了一次程序，那么是那种手段呢？自启动常见的一共也就上面四种，排查了本地电脑方式一和方式二中没有找到腾讯会议相关的设置，那么剩下方式四了，翻看腾讯会议安装包中的都有哪些exe文件，结合资源管理器中腾讯会议相关的进程，然后再windows服务列表中查找

最终定位到可疑服务

为了验证猜想，将该服务设置为手动启动，然后发现，腾讯会议的启动和其他程序没有什么差别，都很慢，至此，腾讯会议为什么比较快差不多有结论了。

猜测腾讯会议快速自启动的实现方案：通过开机自启的服务，拉起腾讯会议的应用程序，怎么实现的，可参考前文。（至于腾讯会议是否是这么玩的，这个就不清楚了，但能确定的是，肯定和服务有关）

2.我们是否可以跟腾讯会议一样快

可以的，虽然直接将UI程序做成服务，在启动后循环检测目标进程是否启动，没有了尝试启动，已启动就可以退出服务了。为什么要这么做呢，是因为在实际的验证过程中，发现，在登录前试图拉起目标进程总是失败。

小小哇牛

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Windows 程序开机自启动速度优化，为什么腾讯会议自启动速度那么高？

这两天有个优化项需要做个技术调研，就是我们项目的开机启动时间比较长，大概20多秒，但对比腾讯会议Rooms，这款软件的自启动就异常的快，用户登录几秒就可以看到程序界面。拿到任务了，开干吧！！！！！！
复制链接

扫一扫