消息系统(上)

前言

这是对上一篇消息系统的重置和补充，之前的消息系统在使用上并不灵活，使用起来过于死板，于是参考了Lyra的消息系统并对原有的项目进行改进。

在新的消息系统中，将使用充分使用C++模板函数和UScriptStruct的特性，使得消息统统能够支持更灵活的定义和数据传递。

项目使用UE版本为5.2。

消息系统概述

消息系统的一个重要特性就是可以降低代码的耦合度，使代码更加简洁。
在UE中，如果当一个对象需要向另一个对象想要对另一个对象的某些变化做出响应，一般而言可以使用使用虚幻的委托来实现这个功能，但美中不足的是我们依然需要先在两个对象间建立联系随后绑定一方的委托，这依然带来了代码耦合度的提升。所以为了进一步优化我们的代码，我们便可以使用消息系统，当一个对象需要对一些变化做出响应时，就只需要监听一条特定的消息，等待消息的发起者将消息广播给所有监听者即可，这样一来我们便不用关系消息的发起者是谁，只需要处理消息发送过来的数据即可。

为了实现上述描述的消息系统，我们需要实现以下功能：

  1. 提供消息的监听功能
  2. 消息的发起者能够将消息发送给所有监听者
  3. 消息系统能够将消息发起者发送的数据传递给所有监听者
  4. 在监听者不需要时能够及时对消息进行解绑

为了方便管理我们的消息，所以我们可以先创建一个消息子系统用于管理所有的消息，之后所有的功能都将在这个类里实现。

注册消息

注册消息的目的是能够监听消息的变化并处理一些数据，所以我们需要一个注册的消息通道和一个接收到的数据类型，在UE中，我们使用FGameplayTag来作为消息通道，使用UStruct来作为绑定的数据类型。

因为我们可以知道这个监听者的回调函数应该长这样：

1
2
3
4
void Callback(FGameplayTag Channel, const FSomeStruct& SomeStruct)
{
    //...
}

为了能匹配通道类型和数据类型，我们将这个回调函数作为观察者注册进消息系统，当进行广播时由消息系统来调用这个回调函数。
这样我们的注册函数的样子大致如下：

1
void Register(FGameplayTag Channel, class SomeClass* Owner, void(SomeClass::*Callback)(FGameplayTag, const FSomeStruct&));

为了能够对类型进行匹配，我们将其改为模板函数，并在这个函数中对传进来的参数进行一些处理，在这一步对消息数据的类型进行解析同时将回调函数进行注册：

1
2
3
// 这个的Owner不一定会是UObject类型，只是UE中大多数的类都是使用UObject的，所以这里使用UObject作为默认类型
template<typename FMessageStructType, typename Owner = UObject>
void RegisterListener(FGameplayTag Channel, Owner* Owner, void(Owner::*Callback)(FGameplayTag, const FMessageStructType&));

对回调函数进行注册

先看代码：

1
2
3
4
5
6
7
8
9
10
11
12
template<typename FMessageStructType, typename Owner = UObject>
void RegisterListener(FGameplayTag Channel, Owner* Owner, void(Owner::*Callback)(FGameplayTag, const FMessageStructType&))
{
    TWeakObjectPtr<Owner> WeakOwner(Owner);
    auto ReceivedCallback = [WeakOwner, Callback](FGameplayTag Channel_, const FMessageStructType& MessagePayload)
    {
        if(WeakOwner.Get())
        {
            (WeakOwner.Get()->*Callback)(Channel_, MessagePayload);
        }
    };
}

这一步我们先创建了一个Owner的弱引用并在lambda表达式中捕获，并且在函数体中执行Owner的回调函数，在这一步需要确保回调函数的参数和数据类型能够匹配。

对数据的类型进行解析

这一步我们需要对回调函数进一步封装，使之能够获取正确的数据类型：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
template<typename FMessageStructType, typename Owner = UObject>
void RegisterListener(FGameplayTag Channel, Owner* Owner, void(Owner::*CallbackFunction)(FGameplayTag, const FMessageStructType&))
{
    TWeakObjectPtr<Owner> WeakOwner(Owner);
    auto ReceivedCallback = [WeakOwner, CallbackFunction](FGameplayTag Channel_, const FMessageStructType& MessagePayload)
    {
        if(WeakOwner.Get())
        {
            (WeakOwner.Get()->*Callback)(Channel_, MessagePayload);
        }
    };

    auto Thunk = [Callback = MoveTemp(ReceivedCallback)](FGameplayTag Channel_, const void* MessagePayloadData)
    {
        // 先将数据进行一次类型转换随后解引用，便能得到我们想要的类型
        Callback(Channel_, *reinterpret_cast<const FMessageStructType*>(MessagePayloadData));	
    };
}

在这一步我们定义了一个Thunk函数，这个函数的主要作用是将发送过来的数据转化为与回调函数类型匹配的数据

在这一步完成后我们便完成了对注册内容的初步解析，随后我们需要将解析的内容保存在消息系统中，所以我们使用一个结构体来对消息进行保存：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
USTRUCT()
struct FGameplayMessageListenerData
{
	GENERATED_BODY()
public:
	/** 回调函数 */
	TFunction<void(FGameplayTag, const UScriptStruct*, const void*)> ReceivedCallback;

	/** 消息的结构体类型 */
	TWeakObjectPtr<const UScriptStruct> StructType = nullptr;

	/** 是否是合法的消息结构体 */
	bool bValidStructType = false;
};

有了存储的结构以后还需要让消息系统持有这个结构体，已知一个通道可以存储多个监听，又有多个消息通道，所以选择使用TMap的key来存储所有的消息通道，用一个数组来存储所有该消息通道下的监听者。为了便于使用，需要将数组进行一层包装：

1
2
3
4
5
6
7
/**
 * Wrapper，主要保存消息通道监听者的列表
 */
struct FChannelListenerList
{
	TArray<FGameplayMessageListenerData> ListenerDatas;
};
1
2
3
4
5
6
7
8
UCLASS()
class PROJECT_API UGameplayMessageSubsystem:UGameInstanceSubsystem
{
    GENERATED_BODY()

protected:
    TMap<FGameplayTag, FChannelListenerList> Listeners;
}

随后我们将解析的内容保存进这个结构体并由消息系统持有：

1
2
3
4
5
6
7
8
9
10
11
12
13
void RegisterListener_Internal(FGameplayTag Channel, TFunction<void(FGameplayTag, const void*)>&& Callback, const UScriptStruct* StructType)
{
    // 查找改通道的监听者列表，没有者创建
	FChannelListenerList& List = Listeners.FindOrAdd(Channel);

	// 在数组尾部创建一个默认的对象并获取
	FGameplayMessageListenerData& Data = List.ListenerDatas.AddDefaulted_GetRef();

	// 设置数据
	Data.ReceivedCallback = MoveTemp(Callback);
	Data.StructType = StructType;
	Data.bValidStructType = StructType != nullptr;
}

直到这一步我们便完成了消息的注册功能，接下来将消息进行广播。

广播消息

这一步就比较简单，广播消息时只需要设置消息的通道和发送的数据即可，在消息系统内部会对数据进行处理，对外提供如下方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
template<typename FMessageStructType>
void BroadcastMessage(FGameplayTag Channel, const FMessageStructType& MessagePayload)
{
    // 获取消息的结构体类型
	const UScriptStruct* StructType = FMessageStructType::StaticStruct();
	// 调用消息广播
	BroadcastMessage_Internal(Channel, StructType, &MessagePayload);
}

void BoradcastMessage_Internal(FGameplayTag Channel, const UScriptStruct* StructType, const void* MessagePayloadData)
{
    // 先查找该通道的所有消息
	if (const FChannelListenerList* List = Listeners.Find(Channel))
	{
		// 安全处理，防止在调用时某一个消息被解绑（移除）
		TArray<FGameplayMessageListenerData> CopyedData(List->ListenerDatas);
		for (const FGameplayMessageListenerData& ListenerData:CopyedData)
		{
			// 判断数据类型不合法或类型不匹配则进行解绑
			if (ListenerData.bValidStructType == false || !StructType->IsChildOf(ListenerData.StructType.Get()))
			{
				// 不合法则对该消息进行解绑
				UE_LOG(LogGameplayMessage, Warning, TEXT("消息的结构体类型不匹配"))
				continue;
			}
			
			// 调用回调函数
			ListenerData.ReceivedCallback(Channel, StructType, MessagePayload);
		}
	}
}

从消息的注册到广播可以发现对回调的处理是由内及外和由外及内的，在注册时，我们对回调函数进行封装处理使之变成广播时易于调用的类型，在广播时又逐层解析调用真正的回调函数。这一切都发生在Thunk函数中，这个函数便是消息系统能够支持任意类型数据结构的基石之一。

对消息的解绑

当一个对象不在需要监听消息时便需要对消息进行解绑。

当下的问题时，我们只在消息注册时保存了这份消息，而注册者却什么都不知道，所以在注册成功后我们需要返回一个句柄，当注册者不再需要监听时便通过这个句柄来解除绑定，所以我们需要一个句柄结构体同时对现有的一些结构体进行一些小小的修改：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
USTRUCT(BlueprintType)
struct FGameplayMessageHandle
{
	GENERATED_BODY()

	friend UGameplayMessageSubsystem;
public:
	FGameplayMessageHandle(){}

	FGameplayMessageHandle(UGameplayMessageSubsystem* InSubsystem, FGameplayTag InChannel, uint64 InHandleID):
	GameplayMessageSubsystem(InSubsystem), Channel(InChannel), HandleId(InHandleID){}

	bool IsValid() const { return HandleId != 0; }

	// 解绑方法，主要用于提供蓝图支持
	void Unregister();
protected:
	/** 持有的消息系统，蓝图支持 */
	UPROPERTY(Transient)
	TWeakObjectPtr<UGameplayMessageSubsystem> GameplayMessageSubsystem;

	/** 消息通道 */
	UPROPERTY(Transient)
	FGameplayTag Channel;
	
	/** 唯一的表示id */
	uint64 HandleId;
};

// 对FGameplayMessageListenerData进行修改，同样增加一个handleid
USTRUCT(BlueprintType)
struct FGameplayMessageListenerData
{
    //...

    // 新增的字段
    uint64 HandleId;
};

UCLASS()
class PROJECT_API UGameplayMessageSubsystem:UGameInstanceSubsystem
{
    //...
protected:
    // 新增的字段
    uint64 HandleCounter = 0;
};

// 修改Register方法，返回一个结构体即可，具体代码会在最后提供

在Handle和Data这两个结构体中都包含一个HandleId，这个id由消息系统分配并由Handle和Data各自持有一份，在解绑时通过对比HandleId来确认是否为同一个注册的消息。

我们对外提供解绑方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
void Unregister(FGameplayMessageHandle& Handle)
{
    // 检查句柄的合法性
    if (!Handle.IsValid())
	{
		return;
	}

    // 找到消息通道的监听者列表
	if (FChannelListenerList* List = Listeners.Find(Handle.Channel))
	{
		// 找到下标
		int32 Index = List->ListenerDatas.IndexOfByPredicate([&Handle](const FGameplayMessageListenerData& CheckedData){ return CheckedData.HandleId == Handle.HandleId; });
		// 根据下标移除，在之前我们在广播时对数组进行拷贝避免了线程安全问题
		if (Index != -1)
		{
			List->ListenerDatas.RemoveAtSwap(Index);
		}

		// 如果该通道没有使用者则清除该通道
		if (List->ListenerDatas.IsEmpty() == true)
		{
			Listeners.Remove(Handle.Channel);
		}
	}
}

在Handle中我们同样提供了解绑的方法，该方法对消息系统提供的解绑方法进行了一次封装，这样在解绑时我们可以直接调用这个Handle中的Unregister方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void Unregister()
{
    if(HandleId == 0)
    {
        return;
    }

  	if (UGameplayMessageSubsystem* MessageSubsystem = GameplayMessageSubsystem.Get())
	{
		MessageSubsystem->Unregister(*this);
		GameplayMessageSubsystem.Reset();
		Channel = FGameplayTag::EmptyTag;
		HandleId = 0;
	}
}

至此我们便完成了消息系统的三个基本功能，接下来我们可以在一个类中进行测试：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
USTRUCT(BlueprintType)
struct FTestMessageStruct
{
    GENERATED_BODY()
public:
    UPROPERTY(BlueprintReadOnly)
    int32 TestData;
}

// 声明一个Tag，在头文件中
UE_DECLARE_GAMEPLAY_TAG_EXTERN(PlayerTestTag);

// 在头文件中定义这个Tag
UE_DEFINE_GAMEPLAY_TAG_COMMENT(PlayerTestTag, "PlayerTestTag.Tag", "this is a test tag");

UCLASS()
class PROJECT_API ATestPlayer:public ACharacter
{
    //...

    FGameplayMessageHandle TestHandle;

    UFUNCTION(BlueprintCallable)
    void TestRegister()
    {
        // 获取消息系统
        if(UWorld* World = this->GetWorld())
        {
            if(UGameplayMessageSubsystem* MessageSubsystem = UGameInstance::GetSubsystem<UGameplayMessageSubsystem>(World->GetGameInstance()))
            {
                TestHandle = MessageSubsystem->Register(PlayerTestTag, this, &ATestPlayer::TestMessageCallback);
            }
        }
    }

    UFUNCTION(BlueprintCallable)
    void TestUnregister()
    {
        TestHandle.Unregister();
    }

    UFUNCTION(BlueprintCallable)
    void TestBroadcast()
    {
        // 获取消息系统
        if(UWorld* World = this->GetWorld())
        {
            if(UGameplayMessageSubsystem* MessageSubsystem = UGameInstance::GetSubsystem<UGameplayMessageSubsystem>(World->GetGameInstance()))
            {
                FTestMessageStruct TestMessage;
                TestMessage.TestData = 114514;
                MessageSubsystem->Broadcast(PlayerTestTag, TestMessage);
            }
        }
    }
}

我们在蓝图中分别调用这几个函数进行测试，可以看到消息正常发送和接受。

总结

这里我们实现了在C++中使用消息系统，但UE并不只有C++，消息系统需要同样支持蓝图调用才算完整，后面我们会对消息系统进行蓝图支持。

暂时完整的代码

代码中对获取方法提供了封装，使之更易于调用。
此外我们还可以使用宏对注册和广播进行封装，使之更加简洁易用，不过这里并未提供。
提供的代码与上文中的代码略有不同，主要在于参数传递时有一个UScriptStruct*类型的参数，这个是用于提供蓝图支持的，暂时可以忽略。

头文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
// Fill out your copyright notice in the Description page of Project Settings.

#pragma once

#include "CoreMinimal.h"
#include "GameplayTagContainer.h"
#include "Subsystems/GameInstanceSubsystem.h"
#include "GameplayMessageSubsystem.generated.h"

class UAsyncAction_ListenForGameplayMessage;
class UGameplayMessageSubsystem;

/*
 * 创建消息监听时返回的句柄
 */
USTRUCT(BlueprintType)
struct FGameplayMessageHandle
{
	GENERATED_BODY()

	friend UGameplayMessageSubsystem;
public:
	FGameplayMessageHandle(){}

	FGameplayMessageHandle(UGameplayMessageSubsystem* InSubsystem, FGameplayTag InChannel, uint64 InHandleID):
	GameplayMessageSubsystem(InSubsystem), Channel(InChannel), HandleId(InHandleID){}

	bool IsValid() const { return HandleId != 0; }

	// 解绑方法，主要用于提供蓝图支持
	void Unregister();
protected:
	/** 持有的消息系统，蓝图支持 */
	UPROPERTY(Transient)
	TWeakObjectPtr<UGameplayMessageSubsystem> GameplayMessageSubsystem;

	/** 消息通道 */
	UPROPERTY(Transient)
	FGameplayTag Channel;
	
	/** 唯一的表示id */
	uint64 HandleId;
};

/**
 * 保存消息监听者持有的数据
 */
USTRUCT()
struct FGameplayMessageListenerData
{
	GENERATED_BODY()
public:
	/** 回调函数 */
	TFunction<void(FGameplayTag, const UScriptStruct*, const void*)> ReceivedCallback;

	/** 消息的结构体类型 */
	TWeakObjectPtr<const UScriptStruct> StructType = nullptr;

	/** 是否是合法的消息结构体 */
	bool bValidStructType = false;

	/** 唯一的表示id，由Handle和Data各自保存一份用于查找 */
	uint64 HandleId;
};

/**
 * Wrapper，主要保存消息通道监听者的列表
 */
struct FChannelListenerList
{
	TArray<FGameplayMessageListenerData> ListenerDatas;
};

DECLARE_LOG_CATEGORY_EXTERN(LogGameplayMessage, Log, All);

UCLASS()
class PROJECT_CTF_API UGameplayMessageSubsystem : public UGameInstanceSubsystem
{
	GENERATED_BODY()
	// 提供蓝图支持
	friend UAsyncAction_ListenForGameplayMessage;
public:
	virtual bool ShouldCreateSubsystem(UObject* Outer) const override;

	virtual void Initialize(FSubsystemCollectionBase& Collection) override;

	virtual void Deinitialize() override;

	static UGameplayMessageSubsystem* Get(const UObject* WorldContext);
	
	/// 对外提供的注册方法
	/// @tparam FMessageStructType 消息的数据类型
	/// @tparam Owner 消息的注册者
	/// @param Channel 消息的通道
	/// @param OwnerObject 注册者
	/// @param CallbackFunction 接收到消息的回调
	/// @return 监听的handle
	template<typename FMessageStructType, typename Owner = UObject>
	FGameplayMessageHandle RegisterListener(FGameplayTag Channel, Owner* OwnerObject, void(Owner::*CallbackFunction)(FGameplayTag, const FMessageStructType&));

	/// 清理绑定
	/// @param Handle 创建监听时返回的唯一句柄
	void Unregister(FGameplayMessageHandle& Handle);

	/// 广播一条消息
	/// @tparam FMessageStructType 消息结构体类型
	/// @param Channel 消息通道
	/// @param MessagePayload 消息数据
	template<typename FMessageStructType>
	void BroadcastMessage(FGameplayTag Channel, const FMessageStructType& MessagePayload);
protected:
	/// 实际完成注册的函数
	/// @param Channel 消息通道
	/// @param Callback 回调函数
	/// @param StructType 消息数据类型
	/// @return 监听的handle
	FGameplayMessageHandle RegisterListener_Internal(FGameplayTag Channel, TFunction<void(FGameplayTag, const UScriptStruct*, const void*)>&& Callback, const UScriptStruct* StructType);

	/// 广播消息的内部实现，便于蓝图支持
	/// @param Channel 消息通道
	/// @param StructType 具体的消息类型
	/// @param MessagePayload 消息数据
	void BroadcastMessage_Internal(FGameplayTag Channel, const UScriptStruct* StructType, const void* MessagePayload);
	
	/** 持有所有 通道-监听者 */
	TMap<FGameplayTag, FChannelListenerList> Listeners;

	/** 标识Handle计数器，用于分配唯一id */
	uint64 HandleCounter = 0;
};

template <typename FMessageStructType, typename Owner>
FGameplayMessageHandle UGameplayMessageSubsystem::RegisterListener(FGameplayTag Channel, Owner* OwnerObject,
	void(Owner::* CallbackFunction)(FGameplayTag, const FMessageStructType&))
{
	TWeakObjectPtr<Owner> WeakOwner(OwnerObject);
	auto ReceivedCallback = [WeakOwner, CallbackFunction](FGameplayTag Channel_, const FMessageStructType& MessagePayload)
	{
		// 检查注册者是否有效
		if (WeakOwner.Get())
		{
			(WeakOwner.Get()->*CallbackFunction)(Channel_, MessagePayload);
		}
	};

	/**
	 * 转换函数，将消息的发起者传入的参数转为符合条件类型并回调
	 * 其中StructType用于提供蓝图支持，便于在蓝图中使用监听回调
	 */
	auto ThunkCallback = [Callback = MoveTemp(ReceivedCallback)](FGameplayTag Channel_, const UScriptStruct* MessageStructType, const void* MessagePayloadData)
	{
		Callback(Channel_, *reinterpret_cast<const FMessageStructType*>(MessagePayloadData));	
	};

	// 获取消息数据的类型
	const UScriptStruct* MessageStructType = FMessageStructType::StaticStruct();

	// 返回内部实现
	return RegisterListener_Internal(Channel, ThunkCallback, MessageStructType);
}

template <typename FMessageStructType>
void UGameplayMessageSubsystem::BroadcastMessage(FGameplayTag Channel, const FMessageStructType& MessagePayload)
{
	// 获取消息的结构体类型
	const UScriptStruct* StructType = FMessageStructType::StaticStruct();
	// 调用消息广播
	BroadcastMessage_Internal(Channel, StructType, &MessagePayload);
}

源文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
// Fill out your copyright notice in the Description page of Project Settings.

#include "GameplayMessageSubsystem.h"

DEFINE_LOG_CATEGORY(LogGameplayMessage);

void FGameplayMessageHandle::Unregister()
{
	if (UGameplayMessageSubsystem* MessageSubsystem = GameplayMessageSubsystem.Get())
	{
		MessageSubsystem->Unregister(*this);
		GameplayMessageSubsystem.Reset();
		Channel = FGameplayTag::EmptyTag;
		HandleId = 0;
	}
}

bool UGameplayMessageSubsystem::ShouldCreateSubsystem(UObject* Outer) const
{
	return true;
}

void UGameplayMessageSubsystem::Initialize(FSubsystemCollectionBase& Collection)
{
	Listeners.Reset();
	Super::Initialize(Collection);
}

void UGameplayMessageSubsystem::Deinitialize()
{
	Listeners.Reset();
	Super::Deinitialize();
}

UGameplayMessageSubsystem* UGameplayMessageSubsystem::Get(const UObject* WorldContext)
{
	if (IsValid(WorldContext);UWorld* World = WorldContext->GetWorld())
	{
		return UGameInstance::GetSubsystem<UGameplayMessageSubsystem>(World->GetGameInstance());
	}
	return nullptr;
}

FGameplayMessageHandle UGameplayMessageSubsystem::RegisterListener_Internal(
	FGameplayTag Channel,
	TFunction<void(FGameplayTag, const UScriptStruct*, const void*)>&& Callback,
	const UScriptStruct* StructType)
{
	// 查找改通道的监听者列表，没有者创建
	FChannelListenerList& List = Listeners.FindOrAdd(Channel);

	// 创建一个默认的对象并获取
	FGameplayMessageListenerData& Data = List.ListenerDatas.AddDefaulted_GetRef();

	// 设置数据
	Data.ReceivedCallback = MoveTemp(Callback);
	Data.StructType = StructType;
	Data.bValidStructType = StructType != nullptr;
	Data.HandleId = ++HandleCounter;
	
	// 创建handle并返回
	return FGameplayMessageHandle(this, Channel, Data.HandleId);
}

void UGameplayMessageSubsystem::Unregister(FGameplayMessageHandle& Handle)
{
	if (!Handle.IsValid())
	{
		return;
	}

	if (FChannelListenerList* List = Listeners.Find(Handle.Channel))
	{
		// 找到下标
		int32 Index = List->ListenerDatas.IndexOfByPredicate([&Handle](const FGameplayMessageListenerData& CheckedData){ return CheckedData.HandleId == Handle.HandleId; });
		// 根据下标移除
		if (Index != -1)
		{
			List->ListenerDatas.RemoveAtSwap(Index);
		}

		// 如果该通道没有使用者则清除该通道
		if (List->ListenerDatas.IsEmpty() == true)
		{
			Listeners.Remove(Handle.Channel);
		}
	}
}

void UGameplayMessageSubsystem::BroadcastMessage_Internal(FGameplayTag Channel, const UScriptStruct* StructType,
	const void* MessagePayload)
{
	// 先查找该通道的所有消息
	if (const FChannelListenerList* List = Listeners.Find(Channel))
	{
		// 安全处理，防止在调用时某一个消息被解绑（移除）
		TArray<FGameplayMessageListenerData> CopyedData(List->ListenerDatas);
		for (const FGameplayMessageListenerData& ListenerData:CopyedData)
		{
			// 判断数据类型不合法或类型不匹配则进行解绑
			if (ListenerData.bValidStructType == false || !StructType->IsChildOf(ListenerData.StructType.Get()))
			{
				// 不合法则对该消息进行解绑
				UE_LOG(LogGameplayMessage, Warning, TEXT("消息的结构体类型不匹配"))
				continue;
			}
			
			// 调用回调函数
			ListenerData.ReceivedCallback(Channel, StructType, MessagePayload);
		}
	}
}


展开全文 >>

UE消息系统（上）：无参消息广播

前言

消息系统允许对象之间进行通信而不需要知道对象的具体类型，只需要接受消息的对象完成注册即可接收从各个地方发送来的消息从而执行相关的逻辑。

与UE中的委托类似，但是使用委托在绑定时仍需要知道具体的对象，而消息则不需要，所以使用消息能更进一步完成解耦。

基本的实现方式

可以采取与委托类似的方式，不同的是可以将绑定的信息存储在一个容器中，当消息被发送时就从容器中查找相应的委托并执行逻辑。

定义最基本的结构体

首先在这个容器中存储了一个委托，其次需要一个唯一的标识符，所以相应的应该还有一个ID。

消息的最基本结构体定义完成后，还需要知道消息的具体类型，采用FGameplayTag作为消息类型的标识符。

定义委托：

1
DECLARE_DYNAMIC_DELEGATE(FMessageDelegate);

所以消息结构体的基本构成为：

1
2
3
4
5
6
7
8
9
10
11
12
struct FGameplayMessageListenerHandle
{
public:
    FGameplayMessageListenerHandle()
    {

    }

    FMessageDelegate MessageDelegate;
    int64 HandleID;
    FGameplayTag Channel;
};

消息的存储容器

有了消息的基本结构体后，就需要一个容器来存放这些消息。之前定义了FGameplayTag作为消息类型，一个消息同时有一组接收者，因而采取map的形式维护消息类型与接收者之间的映射关系。

1
2
3
4
5
6
7
8
9
10
11
12
struct FGameplayMessageHandleWarpper
{
public:
    FGameplayMessageHandleWarpper()
    {

    }

    TArray<FGameplayMessageListenerHandle> Events;
};

TMap<FGameplayTag, FGameplayMessageHandleWarpper> Messages;

每个消息的唯一标识ID

使用一个静态成员变量作为标识ID，没当调用注册函数时就为其注册的Handle分配一个HandleID。

消息本身应提供的方法

同时消息本身应该具有合法性判断、解绑、委托执行的方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
struct FGameplayMessageListenerHandle
{
public:
    bool IsValid() const { return HandleID > 0; }
    // 稍后实现
    void Unregister();
protected:
    void Broadcast()
    {
        if(HandleID > 0)
        {
            MessageDelegate.ExecuteIfBound();
        }
    }
};

消息系统的实现

消息系统在整个游戏中明显应该只存在一份，所以采用UE的子系统来实现，同时让消息结构体中持有一份该系统的弱引用：

1
2
3
4
5
6
7
8
9
class UMessageSubsystem:public UGameInstanceSubsystem
{
public:
    bool ShouldCreateSubsystem(UObject* Outer) const override { return true; }

    TMap<FGameplayTag, FGameplayMessageHandleWarpper> Messages;

    static TAtomic<int64> HandleID;
};

对于C++的实现

消息的注册

我们提供一个模板方法来完成对消息的注册，为了完成消息的注册，我们需要一些注册的基本信息：注册的消息类型、注册者以及注册的委托函数，所以需要三个基本参数：FGameplayTag、UserObject、Function。

最终提供一个静态方法完成注册：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
template<typename UserClass>
FGameplayMessageHandle RegisterGameplayMessageListener(UObject* WorldContextObject, FGameplayTag Channel, UObject* UserObject, FName FunctionName)
{
    if (IsValid(WorldContextObject))
	{
		if (UWorld* World = WorldContextObject->GetWorld())
		{
			if (UGameInstance* GameInstance = World->GetGameInstance())
			{
				if (UMessageSubsystem* MessageSubsystem = GameInstance->GetSubsystem<UMessageSubsystem>(GameInstance))
				{
					FGameplayMessageListenerHandle MessageHandler;
                    // 为其分配ID
					MessageHandler.HandleID = ++MessageHanderAlloc;
					// 完成委托的绑定
                    MessageHandler.MessageDelegate.BindUFunction(Register, FunctionName);
					// 确定消息类型
                    MessageHandler.Channel = Channel;
                    // 让该消息持有消息系统
					MessageHandler.Subsystem = MessageSubsystem;
					MessageSubsystem->Messages.FindOrAdd(Channel).Nodes.Add(MessageHandler);
					return MessageHandler;
				}
			}
		}
	}
	
	return FGameplayMessageListenerHandle{};
}

消息的执行

在消息执行时只需要传入一个消息类型即可完成消息的发送，同样将其定义为静态方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
void BroadcastMessage(UObject* WorldContextObject, FGameplayTag Channel)
{
	if (IsValid(WorldContextObject))
	{
		if (UWorld* World = WorldContextObject->GetWorld())
		{
			if (UGameInstance* GameInstance = World->GetGameInstance())
			{
				if (UMessageSubsystem* MessageSubsystem = GameInstance->GetSubsystem<UMessageSubsystem>(GameInstance))
				{
					if (FMessageHandleWarpper* HandleWarpper = MessageSubsystem->Messages.Find(Channel))
					{
						for (FGameplayMessageListenerHandle& Handler : HandleWarpper->Events)
						{
							Handler.Boardcast();
						}
					}
				}
			}
		}
	}
}

消息的解绑

直接对对象持有的消息本身进行解绑，之前我们对消息结构体中定义了Unregister方法，现在只需要实现该方法即可：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
void FGameplayMessageListenerHandle::Unregister()
{
    if (HandleID > 0)
	{
		if (UMessageSubsystem* MessageSubsystem = Subsystem.Get())
		{
			if (FMessageHandleWarpper* HandleWarpper = MessageSubsystem->Messages.Find(Channel))
			{
                // 提供线程安全的移除方法
				int32 MatchIndex = HandleWarpper->Events.IndexOfByPredicate([this](const FGameplayMessageListenerHandle& Handler) {return Handler.HandleID == HandleID; });
			
				if (MatchIndex != INDEX_NONE)
				{
					HandleWarpper->Events.RemoveAtSwap(MatchIndex);
				}

				if (HandleWarpper->Events.IsEmpty())
				{
					MessageSubsystem->Messages.Remove(Channel);
				}
			}
		}
	} 
}

对于蓝图实现

蓝图与C++实现最大的区别在于无法直接使用FGameplayMessageHandle这个结构体，在蓝图与C++的交互中，结构体会以值传递的方式传递，即使定义了以引用的方式传递，在蓝图中的结构体进入C++时仍然会拷贝出一个副本，此时无法保证操作的一致性；而类类型在蓝图与C++的交互中是以引用的方式传递，此时可以保证操作的一致性，所以需要对消息结构在做一层类封装。

1
2
3
4
5
6
7
8
9
class UGameplayMessageAction: public UObject
{
public:
    FGameplayMessageListenerHandle ListenerHandler;

    // 用于给蓝图提供注册消息的方法，这也是不选用结构体的另一个原因：蓝图无法调用结构体中的方法
	UFUNCTION(BlueprintCallable, Category = "Message")
	void Unregister();
};

蓝图消息的注册

同样提供静态方法进行注册，不同的是这次不传入函数名而是直接传入一个事件引脚，当发送消息时直接通过蓝图事件来执行，此时便不再需要传入UserObject：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
UFUNCTION(BlueprintCallable, Category = "Message")
UGameplayMessageAction* K2_RegisterGameplayMessageListener(UObject* WorldContextObject, FGameplayTag Channel, const FMessageDelegate& EventDelegate)
{
	UGameplayMessageAction* Action = nullptr;
	if (IsValid(WorldContextObject))
	{
		if (UWorld* World = WorldContextObject->GetWorld())
		{
			if (UGameInstance* GameInstance = World->GetGameInstance())
			{
				if (UMessageSubsystem* MessageSubsystem = GameInstance->GetSubsystem<UMessageSubsystem>(GameInstance))
				{
					Action = NewObject<UGameplayMessageAction>();
					if (Action)
					{				
						Action->ListenerHandler.HandleID = ++MessageHanderAlloc;
						Action->ListenerHandler.MessageDelegate = EventDelegate;
						Action->ListenerHandler.Channel = Channel;
						Action->ListenerHandler.Subsystem = MessageSubsystem;
						MessageSubsystem->Messages.FindOrAdd(Channel).Events.Add(Action->ListenerHandler);
					}
				}
			}
		}
	}
	return Action;
}

蓝图消息的执行与C++消息的执行方式相同，直接调用BroadcastMessage即可。

蓝图消息的解绑

在注册消息时我们使用一个MessageAction接收返回值，并使用它的完成消息解绑：

1
2
3
4
void UGameplayMessageAction::Unregister()
{
    ListenerHandler.Unregister();
}

完整的代码

头文件部分：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
DECLARE_DYNAMIC_DELEGATE(FMessageDelegate);

USTRUCT(BlueprintType)
struct FGameplayMessageListenerHandle
{
public:
	friend UMessageSubsystem;

	FGameplayMessageListenerHandle():HandleID(-1)
	{

	}

	FGameplayMessageListenerHandle(UMessageSubsystem* _Subsystem, FGameplayTag _Channel, int64 _HandleID) :Subsystem(_Subsystem), Channel(_Channel), HandleID(_HandleID)
	{

	}

	void Unregister();
	bool IsValid() { return HandleID > 0; }

	FMessageDelegate MessageDelegate;
	TWeakObjectPtr<UMessageSubsystem> Subsystem;
	FGameplayTag Channel;
	int64 HandleID; 
protected:
	void Boardcast();
};

USTRUCT()
struct FMessageHandleWarpper
{
public:
    // 用于结束游戏时清理消息
	void Clear()
	{
		for (FGameplayMessageListenerHandle& Handler : Events)
		{
			Handler.Unregister();
		}
	}

	TArray<FGameplayMessageListenerHandle> Events;
};

UCLASS(BlueprintType)
class UGameplayMessageAction :public UObject
{
public:
	FGameplayMessageListenerHandle ListenerHandler;

	UFUNCTION(BlueprintCallable, Category = "Message")
	void Unregister();
};

/**
 * 
 */
UCLASS()
class UMessageSubsystem : public UGameInstanceSubsystem
{
	GENERATED_BODY()
	
public:
	bool ShouldCreateSubsystem(UObject* Outer) const override { return true; }

	virtual void Initialize(FSubsystemCollectionBase& Collection);

	virtual void Deinitialize();

	template<class UserClass>
	static FGameplayMessageListenerHandle RegisterGameplayMessageListener(UObject* WorldContextObject, FGameplayTag Channel, UObject* Register, FName FunctionName);

	UFUNCTION(BlueprintCallable, Category = "Message", meta = (WorldContext = "WorldContextObject"))
	static UGameplayMessageAction* K2_RegisterGameplayMessageListerner(UObject* WorldContextObject, FGameplayTag Channel, const FMessageDelegate& EventDelegate);

	UFUNCTION(BlueprintCallable, Category = "Message", meta = (WorldContext = "WorldContextObject"))
	static void BroadcastMessage(UObject* WorldContextObject, FGameplayTag Channel);

	static TAtomic<int64> MessageHanderAlloc;

	UPROPERTY()
	TMap<FGameplayTag, FMessageHandleWarpper> Messages;
};

template<class UserClass>
inline FGameplayMessageListenerHandle UMessageSubsystem::RegisterGameplayMessageListener(UObject* WorldContextObject, FGameplayTag Channel, UObject* Register, FName FunctionName)
{
	if (IsValid(WorldContextObject))
	{
		if (UWorld* World = WorldContextObject->GetWorld())
		{
			if (UGameInstance* GameInstance = World->GetGameInstance())
			{
				if (UMessageSubsystem* MessageSubsystem = GameInstance->GetSubsystem<UMessageSubsystem>(GameInstance))
				{
					FGameplayMessageListenerHandle MessageHandler;
					MessageHandler.HandleID = ++MessageHanderAlloc;
					MessageHandler.MessageDelegate.BindUFunction(Register, FunctionName);
					MessageHandler.Channel = Channel;
					MessageHandler.Subsystem = MessageSubsystem;
					MessageSubsystem->Messages.FindOrAdd(Channel).Nodes.Add(MessageHandler);
					return MessageHandler;
				}
			}
		}
	}
	
	return FGameplayMessageListenerHandle{};
}

源文件部分：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

TAtomic<int64> UMessageSubsystem::MessageHanderAlloc = -1;

void UMessageSubsystem::Initialize(FSubsystemCollectionBase& Collection)
{
	Super::Initialize(Collection);
	MessageHanderAlloc = 0;
}

void UMessageSubsystem::Deinitialize()
{
	for (auto& Pair : Messages)
	{
		Pair.Value.Clear();
	}

	Messages.Empty();
	MessageHanderAlloc = -1;
}

UGameplayMessageAction* UMessageSubsystem::K2_RegisterGameplayMessageListerner(UObject* WorldContextObject, FGameplayTag Channel, const FMessageDelegate& EventDelegate)
{
	UGameplayMessageAction* Action = nullptr;
	if (IsValid(WorldContextObject))
	{
		if (UWorld* World = WorldContextObject->GetWorld())
		{
			if (UGameInstance* GameInstance = World->GetGameInstance())
			{
				if (UMessageSubsystem* MessageSubsystem = GameInstance->GetSubsystem<UMessageSubsystem>(GameInstance))
				{
					Action = NewObject<UGameplayMessageAction>();
					if (Action)
					{				
						Action->ListenerHandler.HandleID = ++MessageHanderAlloc;
						Action->ListenerHandler.MessageDelegate = EventDelegate;
						Action->ListenerHandler.Channel = Channel;
						Action->ListenerHandler.Subsystem = MessageSubsystem;
						MessageSubsystem->Messages.FindOrAdd(Channel).Events.Add(Action->ListenerHandler);
					}
				}
			}
		}
	}
	return Action;
}

void UMessageSubsystem::BroadcastMessage(UObject* WorldContextObject, FGameplayTag Channel)
{
	if (IsValid(WorldContextObject))
	{
		if (UWorld* World = WorldContextObject->GetWorld())
		{
			if (UGameInstance* GameInstance = World->GetGameInstance())
			{
				if (UMessageSubsystem* MessageSubsystem = GameInstance->GetSubsystem<UMessageSubsystem>(GameInstance))
				{
					if (FMessageHandleWarpper* HandleWarpper = MessageSubsystem->Messages.Find(Channel))
					{
						for (FGameplayMessageListenerHandle& Handler : HandleWarpper->Events)
						{
							Handler.Boardcast();
						}
					}
				}
			}
		}
	}
}

void FGameplayMessageListenerHandle::Unregister()
{
	if (HandleID > 0)
	{
		if (UMessageSubsystem* MessageSubsystem = Subsystem.Get())
		{
			if (FMessageHandleWarpper* HandleWarpper = MessageSubsystem->Messages.Find(Channel))
			{
				int32 MatchIndex = HandleWarpper->Events.IndexOfByPredicate([this](const FGameplayMessageListenerHandle& Handler) {return Handler.HandleID == HandleID; });
			
				if (MatchIndex != INDEX_NONE)
				{
					HandleWarpper->Events.RemoveAtSwap(MatchIndex);
				}

				if (HandleWarpper->Events.IsEmpty())
				{
					MessageSubsystem->Messages.Remove(Channel);
				}
			}
		}
	}
}

void FGameplayMessageListenerHandle::Boardcast()
{
	if (HandleID > 0)
	{
		MessageDelegate.ExecuteIfBound();
	}
}

void UGameplayMessageAction::Unregister()
{
	ListenerHandler.Unregister();
}

测试

使用默认的主角类进行测试，在C++中提供以下函数并绑定一些按键进行：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
   FGameplayMessageListenerHandle TestListenerHandler;

UFUNCTION(BlueprintCallable)
void TestAddListener()
   {
       TestListenerHandler = UETMessageSubsystem::RegisterGameplayMessageListener<AMainCharacter>(this, YourTestTag, this, "TestMessageFunc");
   }

UFUNCTION(BlueprintCallable)
void TestBroadcastListener()
   {      
    UETMessageSubsystem::BroadcastMessage(this, YourTestTag);
   }

UFUNCTION(BlueprintCallable)
void TestUnregisterListener()
   {
       TestListenerHandler.Unregister();
   }

UFUNCTION()
void TestMessageFunc()
   {
   	UE_LOG(LogTemp,Warning,TEXT("TestMessageFunc"));    
   }

在蓝图中则直接可以搜索K2_RegisterGameplayMessageListerner和BroadcastMessage进行绑定和广播，直接调用Action的Unregister()函数即可取消监听。

后续

后续会增加消息的参数传递功能，使其能够携带任意数量的参数进行传递。

展开全文 >>

增强输入与GAS

前言

前文介绍了GAS与增强输入的基本使用，本文将介绍如何将输入与GA进行绑定来完成解耦和扩展。

前置准备

绑定方法

技能与输入的绑定方法，查看BindAction的函数声明，可以看到在后面有一次额外的参数包，在绑定时可以将Tag做为参数在绑定时传入：

1
BindAction(IA, TriggerEvent, UserObject, BindFunc, Tag);

在触发影响的IA时就可以获取到对应的Tag:

1
2
3
4
void BindFunc(FGameplayTag Tag)
{
    //...
}

在初始化时可以通过将Tag和GA进行绑定，在触发输入时通过Tag来查找对应的GA。

技能的初始化

初始化时需要将GA和Tag进行绑定，所以考虑将对应关系放入一张数据表中，在玩家进行初始化时读入这张表完成绑定。

其基本的数据结构应包含一个GA和一个TagContainer，一个技能可能会有几种触发方式，所以提供Container来存储多个Tag。

1
2
3
4
5
6
7
8
9
10
11
12
USTRUCT(BlueprintType)
struct FAbilityAction
{
    GENERATED_BODY()

    // 使用Ability的CDO进行初始化
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Ability")
    TSubclassOf<FGameplayAbility> Ability;

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Ability")
    FGameplayTagContainer Tags;
};

同时提供基本的表结构：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
UCLASS()
class PROJECTE_API UAbilityAsset : public UDataAsset
{
    GENERATED_BODY()

public:
    UAbilityAsset(const FObjectInitilizer& Initializer):Super(Initializer)
    {

    }

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Ability")
    TArray<FAbilityAction> Abilities;
};

输入的初始化

同样使用数据表来存储输入关系，基本应该包含一个Tag和一个IA，其中Tag用于查找对应的GA。

所以输入的基本数据结构为：

1
2
3
4
5
6
7
8
9
10
11
USTRUCT(BlueprintType)
struct FInputAction
{
    GENERATED_BODY()

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    FGameplayTag Tag;

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    TObjectPtr<UInputAction> Action;
};

输入的表结构，其中提供查找方法和一个映射上下文：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
UCLASS()
class PROJECTE_API UInputAsset : public UDataAsset
{
    GENERATED_BODY()
public:
    UInputAsset(const FObjectInitilizer& Initializer):Super(Initializer)
    {

    }

    const UInputAction* FindInputActionByTag(FGameplayTag Tag) const
    {
        UInputAction* InputAction = nullptr;
        if(Tag.IsValid())
        {
            for(const FInputAction& IA: Actions)
            {
                if(IA.Action.Get() && IA.Tag == Tag)
                {
                    InputAction = IA.Action;
                    break;
                }
            }
        }

        return InputAction;
    }

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    TArray<FInputAction> Actions;

    UPROPERTY(EdtiAnywhere, BlueprintReadOnly, Category = "Input")
    TObjectPtr<UInputMappingContext> InputMappingContext;
};

实现输入与GA的绑定

准备好两张表后就可以准备完成初始化与绑定了！

GA的初始化

在GameplayAbility的实例GameplayAbilitySpec中包含一个DynamicAbilityTag的TagContainer，使用其来查找对应的GA。

绑定函数：

1
2
3
4
5
6
7
8
9
10
void InitializeAbility()
{
    // 假设已经读取到了UAbilityAsset--->AbilityAsset
    for(FAbilityAction& GameplayAbilityAction: AbilityAsset->Abilities)
    {
        FGameplayAbilitySpec GameplayAbilitySpec = FGameplayAbilitySpec(GameplayAbilityAction.Ability);
        GameplayAbilitySpec.DynamicAbilityTags = GameplayAbilityAction.Tags;
        GiveAbility(GameplayAbilitySpec);
    }
}

输入的初始化

在绑定中，将输入分为两种，一种为GA输入；另一种为本地输入，包括玩家的基本移动等，所以在绑定时要对其进行区分，所以输入表中需要对结构进行改进，增加一个用于区分是否为技能的bool值；此外技能同样有长按与单次触发的类型，所以再增加一个bool值进行区分。

改进后的结构应为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
USTRUCT(BlueprintType)
struct FInputAction
{
    GENERATED_BODY()

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    FGameplayTag Tag;

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    TObjectPtr<UInputAction> Action;

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    bool bAbilityInput;

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    bool bTriggerEvent;
};

为了确保绑定可以通用，考虑将其作为增强输入组件的模板成员函数。对于本地输入的初始化只要从输入表中拿到对应的IA完成绑定即可；对于技能输入则需要增加一个扩展参数包。

所以玩家的本地输入绑定函数应为：

1
2
3
4
5
6
7
8
9
template<class UserClass, typename FuncType>
void BindNativeAction(const UInputAsset* InputAsset, const FGameplayTag& InputTag, ETriggerEvent TriggerEvent, UserClass* UserObject, FuncType InputFunc)
{
    check(InputAsset);
    if(const UInputAction* IA = InputAsset->FindInputActionByTag(InputTag))
    {
        BindAction(IA, TriggerEvent, UserObject, InputFunc);
    }
}

绑定技能的输入为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
template<class UserClass, typename Press, typename Release>
void BindAbilityAction(const UInputAsset* InputAsset, UserClass* UserObject, Press PressFunc, Relase ReleaseFunc, TArray<uint32>& BindHandles)
{
    check(InputAsset);
    for(const FInputAction& IA: InputAsset->Actions)
    {
        if(IA.Action.Get() && IA.bAbilityInput)
        {
            if(PressFunc)
            {
                if(IA.bTriggerEvent)
                {
                    BindHandles.Add(BindAction(IA.Action, ETriggerEvent::Triggered, PressFunc, PressFunc, IA.Tag).GetHandle());
                }
                else
                {
                    BindHandles.Add(BindAction(IA.Action, ETriggerEvent::Started, PressFunc, ReleaseFunc, IA.Tag).GetHandle());
                }
            }
            
            if(ReleaseFunc)
            {
                BindHandles.Add(BindAction(IA.Action, ETriggerEvent::Completed, ReleaseFUnc, IA.Tag).GetHandle());
            }
        }
    }
}

触发IA与GA

对于玩家的本地输入，可以直接调用BindNativeAction进行绑定，有多少绑定多少，对于GA的绑定则只需要一次。

当IA触发以后则需要根据对应的Tag去寻找对应的GA，提供两个函数用来处理技能输入的按下与抬起：

在GAS中的处理

首先在ASC中提供两个函数用来处理技能输入的按下与抬起：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
void ProcessAbilityPressInput(FGameplayTag InputTag)
{
    if(FGameplayAbilitySpec& AbilitySpec:GetActivatableAbilities())
    {
        if(AbilitySpec.DynamicAbilityTags.HasTag(InputTag))
        {
            AbilitySpec.Ability->ActivateAbility(AbilitySpec);
        }
    }
}

void ProcessAbilityReleaseInput(FGameplayTag InputTag)
{
    for (FGameplayAbilitySpec& AbilitySpec : GetActivatableAbilities())
    {
        if (AbilitySpec.DynamicAbilityTags.HasTag(InputTag))
        {
            AbilitySpecInputRelease(AbilitySpec);
        }
    }
}

在输入组件中的处理

随后可以在玩家的输入组件中调用这两个函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void OnAbilityPressd(FGameplayTag InputTag)
{
    // 认为已经提供了相应的获取ASC的方法
    if(UProjectAbilitySystemComponent* ASC = GetAbilitySystemComponent())
    {
        ASC->ProcessAbilityPressInput(InputTag);
    }
}

void OnAbilityReleased(FGameplayTag InputTag)
{
    if(UProjectAbilitySystemComponent* ASC = GetAbilitySystemComponent())
    {
        ASC->ProcessAbilityReleaseInput(InputTag);
    }
}

最终绑定

最终在增强输入中提供初始化函数SetPlayerInput:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
void SetPlayerInput()
{
    ACharacter* OwnerCharacter = Cast<ACharacter>(GetOwner());
    if(!IsValid(OwnerCharacter))
    {
        return;
    }

    if (APlayerController* LocalPC = Cast<APlayerController>(OwnerCharacter->Controller))
    {
        if (UEnhancedInputLocalPlayerSubsystem* LPSubsystem = ULocalPlayer::GetSubsystem<UEnhancedInputLocalPlayerSubsystem>(LocalPC->GetLocalPlayer()))
        {
            if (InputAsset->InputMappingContext.Get())
            {
                LPSubsystem->ClearAllMappings();
                LPSubsystem->AddMappingContext(InputAsset->InputMappingContext,0);
            }
        }

        //BindNativeAction完成本地输入绑定

        BindAbilityAction(InputAsset, this, &ThisClass::OnAbilityPressd, &ThisClass::OnAbilityReleased, AbilityInputHandles);
    }
}

最终完成了IA与GA的绑定

管理GameplayTag

参考lyra工程使用namespace作为Tag管理，同样我们也提供一个名为GameplayTags的namespace：

1
2
3
4
5
6
7
8
namespace GameplayTags
{
    // 在头文件中这样声明
	PROJECTET_API UE_DECLARE_GAMEPLAY_TAG_EXTERN(CharacterInputTag_Move);

    // 在cpp文件中这样定义，可以编辑器中外部使用
	UE_DEFINE_GAMEPLAY_TAG_COMMENT(CharacterInputTag_Move, "CharacterInput.Move", "Character Movement Input Tag");
}

使用ini管理资产文件

以上是直接将资产挂载在玩家身上，并不方便管理，所以可以考虑使用全局配置项来进行管理。

用UDeveloperSettings作为父类创建名为ProjectAssetSettings的子类，注意需要在uproject文件中新加一条”DeveloperSettings”的配置。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
UCLASS(config = Game, defaultconfig, meta = (DisplayName = "Game Asset Config"))
class PROJECTET_API UProjectAssetSettings : public UDeveloperSettings
{
	GENERATED_BODY()
public:
	virtual FName GetCategoryName() const
    {
        return FName{ TEXT("Game Asset Config") };
    }

	virtual FName GetContainerName() const
    {
        return FName{ TEXT("Project") };
    }

    // 用于获取读取配置的方法，一般在游戏运行时不修改游戏配置，所以返回const
	UFUNCTION(BlueprintPure)
	static const UProjectAssetSettings* GetProjectAssetSettings()
    {
        const UProjectAssetSettings* Settings = GetDefault<UProjectAssetSettings>();
        return Settings;
    }

    //如果想要修改的话可以使用GetMutableDefault<UProjectAssetSettings>()来返回一个可修改的配置文件

    // 将输入资产与技能资产迁至这里，这里一般不会使用硬引用，ini文件加载时机很早，使用硬引用会导致读入的类为空
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Input")
    TSoftObjectPtr<UInputAsset> InputAsset;

    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = "Ability")
    TSoftObjectPtr<UAbilitAsset> AbilityAsset;
};

总结

通过以上步骤，我们将输入与技能进行了绑定，并且通过namespace管理Tag和ini文件管理了输入与技能的资产。

展开全文 >>

常用的排序算法

总结常用的排序算法

主要包括冒泡排序、堆排序、归并排序、快速排序四个。

冒泡排序

冒泡排序是一种很简单的原地排序算法，在每一轮遍历都将最大的元素（或者最小）放在数组的末尾
过程为：

  1. 比较相邻的元素，如果第一个比第二个大，就交换它们两个
  2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数
  3. 针对所有的元素重复以上的步骤，除了最后一个
  4. 重复步骤1~3，直到排序完成
    平均时间复杂度：O(n^2)
1
2
3
4
5
6
7
8
9
10
11
void BubbleSort(vector<int>& nums)
{
    int n = nums.size();
    for(int i = 0; i < n ;i++){
        for(int j = 0; j < n - i - 1; j++){
            if(nums[j] > nums[j + 1]){
                swap(nums[j], nums[j + 1]);
            }
        }
    }
}

堆排序

堆排序是一种原地排序算法，依赖于堆实现
过程为：

  1. 将原数组调整为大顶堆（或小顶堆）
  2. 交换堆顶与数组末尾元素，再将剩余元素调整为大顶堆
  3. 不断重复步骤2直到数组有序
    每次调整堆的时间复杂度位O(logn)，一共需要调整n次，总时间复杂度位O(nlogn)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
void Heapfiy(vector<int>& nums,int n,int i)
{
    int largest=i;
    int left=2*i+1;
    int right=2*i+2;
    while (true) {
        if (left < n && nums[left] > nums[largest]) {
            largest = left;
        }

        if (right < n && nums[right] > nums[largest]) {
            largest = right;
        }

        if (largest == i) {
            break;
        }

        swap(nums[i], nums[largest]);
        i = largest;
        left = 2 * i + 1;
        right = 2 * i + 2;
    }
}

void HeapSort(vector<int>& nums)
{
    int n=nums.size();
    // 构造大顶堆
    // 从最后一个非叶子节点开始
    for(int i=n/2-1;i>=0;i--){
        Heapfiy(nums,n,i);
    }

    // 交换堆顶元素并调整堆
    for(int i=n-1;i>=0;i--){
        swap(nums[0],nums[i]);
        Heapfiy(nums,i,0);
    }   
}

归并排序

归并依赖于递归操作
过程为：

  1. 将原数组分为左右两个子数组
  2. 将数组递归分为左右两个子数组
  3. 将左右两个子数组合并有有序数组
    评价时间复杂度为O(nlogn)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
void Merge(vector<int>& nums,int left,int mid,int right)
{
    vector<int> temp(right-left+1);
    int i=left;
    int j=right;
    int k=0;
    while(i<=left && j<=right){
        // 将两个数组合并为一个有序数组
        if(nums[i]<=nums[j]){
            temp[k]=nums[i];
            i++;
        }else{
            temp[k]=nums[j];
            j++;
        }
        k++;
    }

    while(i<=left){
        temp[k++]=nums[i++];
    }

    while(j<=right){
        temp[k++]=nums[j++];
    }

    for(int t=0;t<k;t++){
        nums[left+t]=temp[t];
    }
}

void MergeSort(vector<int>& nums,int left,int right)
{
    if(left>=right){
        return;
    }
    int mid=left+(right-left)/2;
    MergeSort(nums,left,mid);
    MergeSort(nums,mid+1,right);
    Merge(nums,left,mid,right);
}

快速排序

快排是最常用的排序算法之一
过程为：

  1. 选择一个基准值（一般为第一个或最后一个），将原数组分为两个数组
  2. 比基准值小的元素放在基准值左边，比基准值大的元素放在右边
  3. 递归调用左右两个子数组，重复上述步骤
    平均时间复杂度为O(nlogn)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
int partition(vector<int>& nums,int left,int right)
{
    int base=nums[left];
    while(left<right){
        while(left<right && nums[right]>=base){
            right--;
        }
        nums[left]=nums[right];
        while(left<right && nums[left]<=base){
            left++;
        }
        nums[right]=nums[left];
    }
    nums[left]=base;
    return left;    
}


void QuickSort(vector<int>& nums,int left,int right)
{
    if(left<right){
        int pos=partition(nums,left,right);
        QuickSort(nums,left,pos-1);
        QuickSort(nums,pos+1,right);       
    }
}

展开全文 >>

C++多线程入门：完善线程池

上一章我们制作了一个简单的线程池，本次将使用智能指针来管理创建的对象：各种任务和创建的线程

使用shared_ptr来管理任务和线程

首先对线程池中进行修改：

  1. 将BaseTask*替换为std::shared_ptr< BaseTask >
  2. 将线程池中的std::thread*替换为std::shared_ptr< std::thread >
  3. 对AddTask的逻辑稍加修改

具体改动：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
//void AddTask(BaseTask* Task);
void AddTask(std::shared_ptr<BaseTask> Task);

//BaseTask* GetTask();
std::shared_ptr<BaseTask> GetTask();

//std::vector<std::thread*> ThreadPool;
std::vector<std::shared_ptr<std::thread>> ThreadPool;

//std::list<BaseTask*> TaskList;
std::list<std::shared_ptr<BaseTask>> TaskList;

void Start()
{
    //...
    //auto th = new std::thread(&BaseThreadPool::Run,this);	
    auto th = std::make_shared<std::thread>(&BaseThreadPool::Run,this);
    //...
}

void Exit()
{
    //...
    //智能指针可以帮助我们自动释放资源，所以这里就不在需要我们手动释放
    //std::unique_lock<std::mutex> Lock(mtx);
	//for (auto& th : ThreadPool) {
	//	delete th;
	//	th=nullptr;
	//}
}

在其它地方因为我们使用了auto自动类型推导，所以并不需要有太大变化。

希望异步获取任务的运行结果

对BaseTask类做出修改，增加promise变量以及Set和Get函数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <future>
class BaseTask
{
public:
    //...

    void SetValue(int val)
    {
        p.set_value(val);
    }

    auto GetValue()->int
    {
        return p.get_future().get();
    }

private:
    std::promise<int> p;
};

在main中进行测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
int main()
{
    BaseThreadPool pool;
	pool.Init(4);
	pool.Start();

	// 使用智能指针管理对象
	auto t = make_shared<TestTask>();
	t->name="Name01";
	pool.AddTask(t);
	auto t2 = make_shared<TestTask>();
	t2->name = "Name02";
	pool.AddTask(t2);
	auto t3 = make_shared<TestTask>();
	t3->name = "Name03";
	pool.AddTask(t3);
	auto t4 = make_shared<TestTask>();
	t4->name = "Name04";
	pool.AddTask(t4);
	std::this_thread::sleep_for(3000ms);
	cout << "Task1 ret = " << t.get()->GetValue() << endl;
	cout << "Task2 ret = " << t2.get()->GetValue() << endl;
	
	pool.Exit();

	cout << "Task3 ret = " << t3.get()->GetValue() << endl;
	cout << "Task4 ret = " << t4.get()->GetValue() << endl;
	auto t5 = make_shared<TestTask>();
	pool.AddTask(t2);
	getchar();
	return 0;
}

总结

至此就完成了一个功能相对完善的线程池并尽可能的减少了内存泄漏的问题。

展开全文 >>

C++多线程入门：简单的线程池

很多时候我们并不会频繁的申请线程，而是采用线程池的方式，将任务加入到线程池中等待线程池中的空闲线程去处理该任务。

声明线程池基类

一个线程池应包括如下几个基本功能：

  1. 线程池初始化
  2. 启动所有线程
  3. 线程池入口

稍后为其增加添加任务的功能。

对于上述3个功能，提供如下实现：
直接将文件声明为hpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include <thread>
#include <vector>

class BaseThreadPool
{
public:
    void Init(int Num)；

    void Start();

private:
    void Run();

    int ThreadNum;
    std::mutex mtx;
    std::vector<Thread*> ThreadPool;
};

void BaseThreadPool::Init(int Num)
{
    std::unique_lock<std::mutex> Lock(mtx);
    ThreadNum=Num;
}

void BaseThreadPool::Start()
{
    std::unique_lock<std::mutex> Lock(mtx);
    if(ThreadNum<=0){
        return;
    }else if(!ThreadPool.empty()){
        return;
    }

    for(int i=0;i<ThreadNum;i++){
        auto th = new std::thread(&BaseThreadPool::Run,this);
        ThreadPool.push_back(th);
        th->detach();
    }
}

void BaseThreadPool::Run()
{
    using namespace std;
    cout << "Thread Run" << endl;

    cout << "Thread Exit" << endl;
}

至此完成了线程池的基本框架。
在Start函数中对线程数为0和线程池为空两种情况进行了处理，为了方便这里直接返回。

提供任务基类

提供一个任务基类，所有需要多线程调用的任务都需要继承自该类，由于该类并不需要实例，所以将其声明为抽象类。

1
2
3
4
5
6
7
8
9
class BaseTask
{
public:
    virtual void TaskRun() = 0;
    virtual ~BaseTask()
    {

    }
};

在需要继承的类中重写TaskRun以完成相应逻辑。

对线程池基类稍加改进

有了相应的任务类后为线程池类增加AddTask和GetTask方法：
使用list来存储所有任务，std::list<BaseTask*> TaskList
同时希望在增加一个任务后线程能立刻做出回应，所以再使用一个条件变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include "BaseTask.h"
#include <list>
#include <condition_vatiable>

void AddTask(BaseTask* Task)
{
	std::unique_lock<std::mutex> Lock(mtx);
	TaskList.push_back(Task);
	Lock.unlock();
	cv.notify_one();
}

BaseTask* GetTask()
{
	std::unique_lock<std::mutex> Lock(mtx);
	if (TaskList.empty()) {
		cv.wait(Lock);;
	}
	// 防止多次通知导致为空
	if (TaskList.empty()) {
		return nullptr;
	}
	auto task = TaskList.front();
	TaskList.pop_front();
	return task;
}

在完成对任务的添加和获取后需要对Run进行一些修改以便能够执行相应任务：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
void BaseThreadPool::Run()
{
	using namespace std;
	cout << "Thread Run" << endl;
	while (true) {
		auto Task=GetTask();
		if (!Task) {
			continue;
		}
		try
		{
			Task->TaskRun();
		}
		catch (...)
		{
			// 处理异常，防止一个线程运行错误导致整个线程退出
		}
	}
	cout << "Thread Exit" << endl;
}

简单测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <iostream>
#include <string>
#include "BaseThreadPool.h"

class TestTask:public BaseTask
{
public:
	virtual int TaskRun() override
	{
		std::cout << name << " Task Run" << std::endl;
		return 0;
	}

	std::string name;
};

int main()
{
	BaseThreadPool pool;
	pool.Init(4);
	pool.Start();

	TestTask t;
	t.name="Name01";
	pool.AddTask(&t);

	getchar();
	return 0;
}

更进一步完善线程池的功能

线程池不会一直运行下去，有时候需要结束并清空线程池，这时就需要未线程池增加一个退出功能。
未线程池增加bool变量bExit和设置bExit的函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
void Exit()
{
	bExit=true;
	std::cout << "Exit" << std::endl;
	cv.notify_all();
	for(auto& th:ThreadPool){
		if(th.joinable()){
			th->join();
		}
	}
	std::unique_lock<std::mutex> Lock(mtx);
	for (auto& th : ThreadPool) {
		delete th;
		th=nullptr;
	}
}

bool bExit;

先设置bExit为true并通知所有线程退出，让线程去处理相应逻辑。
遍历所有线程池中的线程处理待办的任务
随后清空线程池

主要退出逻辑完成后还需要完善其它逻辑

首先当设置线程池退出后就不应该再有新的任务增加进来，所以我们对AddTask做出处理：

1
2
3
4
5
6
7
8
9
void AddTask()
{
	// 加锁逻辑
	if(bExit){
		// 额外处理，比如直接抛弃任务
		return;
	}
	//...
}

修改GetTask和Run

GetTask修改与AddTask类似：

1
2
3
4
5
6
7
8
9
void GetTask()
{
	// 这里是wait逻辑，Exit后进行了一次通知
	if(TaskList.empty()){
		return nullptr;
	}
	// 这里有一个相同的逻辑，可以公用一个
	//...
}

之前Run是一个死循环，这里将循环条件改为bExit即可

1
2
3
4
5
6
7
8
void Run()
{
	//...
	while(bExit){
		//...
	}
	//...
}

获取正在运行的线程数量

使用原子变量来存储正在运行的线程数量，原子变量本身就是线程安全的，所以可以直接改变值。
在使用时需要使用atomic头文件。
提供一个int类型原子变量和一个Get函数获取正在运行线程数：

1
2
3
4
5
#include <atomic>

std::atomic<int> RunningTaskNum{0};

void GetRunningTaskNum() { RunningTaskNum; }

在线程Run函数中，在线程执行前令RunningTaskNum自增（前置自增），并在任务结束后自减。

总结

通过提供任务基类和线程池基类实现了一个简单的线程池，后面我们会使用智能指针等技术对已有的线程池进行优化。

展开全文 >>

C++多线程入门：并行计算

假如现在有一很长的字符串需要进行base16编码，如果使用单线程所耗费时间会很多，所以为了解决耗时的问题采用并行计算的方式来编码。

base16编码

将一个字节8位拆分成两个4位，四位表示最大值位0x0f，将拆分到的字节映射到0-f中。
基本原理：

1
2
3
4
5
6
7
8
9
10
static const char base16[]="0123456789abcdef";
void Base16Encode(const unsigned char* indata,unsigned char* outdata,int size)
{
    for(int i=0;i<size;i++){
        char a=base16[char[i]>>4];
        char b=base16[char[i]&0x0f];
        outdata[2*i]=a;
        outdata[2*i+1]=b;
    }
}

使用C++17提供的并行计算方法

C++17提供了for_each的方式来进行并行遍历，使用时需要包含execution头文件。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <execution>
#include <chrono>
void ForEachBase16Encode()
{
    vector<unsigned char> indata(1024*1024*10);
    int n=indata.size();
    for(int i=0;i<n;i++){
        indata[i]=i%256;
    }
    vector<unsigned char> outdate(n);
    auto starttime=system_clock::now();
    for_each(std::execution::par,indata.begin(),indata.end(),[&](unsigned char& ch)
    {
        char a=base16[ch>>4];
        char b=base16[ch&0x0f];
        int adr=&ch-indata.begin();
        outdate[adr*2]=a;
        outdate[adr*2+1]=b;
    });
    auto endtime=system_clock::now();
    millseconds durationtime=duration_cast<millseconds>(endtime-starttime);
    cout << "cost time = "<< durationtime;
}

上述是使用foreach并行计算的简单案例，记录前后时间的差值作为运行时间。
给for_each的第一个参数设置位std::execution::par即可使用for_each来做并行计算，后面部分与一般for_each遍历无异。
中间使用lambda函数（也可以用仿函数）来处理编码，虽然可以并行计算提高效率，但由于函数调用依然会带来性能开销（可能会有多大百万次的调用，如果数据量够大的话）。

直接使用多线分块计算

直接使用Base16Encode作为子线程进行并行计算，并提供ThreadBase16Encode作为线程入口：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
void ThreadBase16Encode(const vector<unsigned char>& indata,vector<unsigned char>& outdata)
{
    int size=indata.size();
    int threadnum=std::thread::hardware_concurrency();
    int percount=size/threadnum;
    if(size<=threadnum){
        threadnum=1;
        percount=size;
    }

    unsigned char* iadr=(unsigned char*)indata.data();
    unsigned char* oadr=(unsigned char*)outdata.data();

    vector<thread> vth(threadnum);
    for(int i=0;i<threadnum;i++){
        int adroffset=i*percount;
        int tempcount=percount;
        if(threadnum>1 && i==threadnum-1){
            tempcount=percount+size%percount;
        }
        vth[i]=thread(Base16Encode,iadr+adroffset,tempcount,oadr+((long long)adroffset*2));
        vth[i].detach();
    }
    getchar();
}

threadnum获取计算机最大核心数，也即可使用的最大线程数
percount获取数据块的大小并用于计算地址的偏移量
随后对特殊情况进行处理，如果数据量小于线程数，则开一个线程进行计算
通过data()获取到indata和oudata的首地址作为参数传入子线程
随后声明线程数组开始进行分块计算：

  1. 获取每个线程分到数据块的地址偏移量
  2. 获取每块数据大小并对最后一块数据进行处理 <—可能会有分完块后的额外数据
  3. 传入参数并执行线程

总结

使用了两种方法进行并行计算：C++17的foreach和C++11的多线程，两者各有优点：

  1. 使用foreach可能会更方便一些，但会由于函数调用带来一些额外的性能开销，并且一些编译器可能不支持C++17
  2. 使用C++11的多线程计算会稍有麻烦，但好在只需要调用几次函数，在性能上会有不错的提升，尤其是数据量非常大的时候

展开全文 >>

C++多线程入门：线程异步

使用异步

异步中提供了一个名为promise的模板类，用于传输异步变量。
使用时需要包含future头文件。

promise包含以下特性：

  1. 通过模板的方式存储变量值，并通过创建对象的future来获取结果。
  2. promise使用set_value来设置变量的值，且只能使用一次。
  3. future使用get方法以阻塞的方式获取promise设置的值。

通过一个异步设置字符串的案例来熟悉：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <iostream>
#include <string>
#include <thread>
#include <future>
using namespace std;

void ThreadFuture(promise<string>& p)
{
    this_thread::sleep_for(2000ms);
    cout << "BeginSetValue" << endl;
    p.set_value("SetPromiseValue");
    this_thread::sleep_for(2000ms);
    cout << "EndSetValue" << endl;
}

void test()
{
    // 异步传输变量存储
    promise<string> p;
    // 用来获取值
    auto f = p.get_future();
    thread th(ThreadFuture,ref(p));
    th.detach();
    cout << "Get = " << f.get();
    getchar();   
}

观察上述案例的执行结果：
首先出现”Get = “然后程序被阻塞等待异步运行结果；随后是”BeginSetValue”；接着打印SetPromiseValue，在p被赋值后立刻打印出来；最后才是”EndSetValue”。

将函数的运行与结果分离

对于一些情况，我们希望函数的运行与返回值是分离的，这时就需要使用函数打包调用。
函数打包主要使用packaged_task来实现。

提供以下案例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
void FuncPackage(int index)
{
    cout << "Pack index = " << index << endl;
    this_thread::sleep_for(1000ms);
    return "Pack Func";   
}

void test()
{
    package_task<string(int)> task(FuncPackage);
    auto ans=task.get_future();
    thread th(move(task),100);
    th.detach();
    cout << "BeginTask" << endl;
    ans.wait_for(2000ms);
    cout << "Get Ans = " << ans.get() << endl;
    getchar();
}

package_task中模板类型为返回值和括号中的参数类型
观察上述执行结果：
先是打印”Pack index = 100”；而后是”BeginTask”；等待之后打印”Get Ans = Pack Func”。

但上述代码解决了基本需求，但也确实存在一些问题：比如打包的函数执行因为某些原因花费了许多时间，但get方法却一直等待结果可能会导致死锁等问题，所以需要对延时情况做一些处理：
我们不直接wait_for，而是改用循环多次查询运行结果来处理延时以供参考

1
2
3
4
5
6
7
8
9
10
11
12
// 处理延时情况，防止一直阻塞
for(int i=0;i<10;i++){
    if(ans.wait_for(150ms)!=future_status::ready){
        continue;
    }
}

if(ans.wait_for(150ms)==future_status::timeout){
    cout << "timeout" << endl;
}else{
    cout << "Get Ans = " << ans.get() << endl;
}

使用async实现异步

Aysnc异步提供了两种方法：创建子线程与不创建子线程。

不创建子线程异步

不创建子线程需要创建时提供launch::deferred来实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void ThreadNoCreate(int index)
{
    cout << "Begin Async " << this_thread::get_id() << endl;
    this_thread::sleep_for(2000ms);
    return "Return Async";
}

void test()
{
    cout << "Thread id = " << this_thread::get_id() << endl;
    auto Async = async(launch::deferred,TestAsync,10);
    cout << "Begin get : " << Async.get() << endl;
    cout << "end" << endl;
    getchar();
}

使用index只是为了提供有参数情况参考，不具有意义。
通过打印两个线程id发现实际是在同一个线程中执行的。

创建子线程

创建子线程时async提供的默认方法，只需要把launch::deferred省去即可：

1
2
3
4
5
6
7
8
9
void test()
{
    cout << "Thread id = " << this_thread::get_id() << endl;
    auto Async_create = async(TestAsync,11);
    this_thread::sleep_for(2000ms);
    cout << "Begin get : " << Async_create.get() << endl;
    cout << "end" << endl;
    getchar();    
}

除了线程id不同外，两者最终执行效果没什么差别。

总结

主要介绍了三种实现异步的方式：

  1. 通过promise与future来实现。
  2. 通过打包函数实现。
  3. 使用aysnc实现，其中aysnc提供了创建子线程与不创建子线程两种方式。

展开全文 >>

C++多线程入门：使用条件变量

使用条件变量

在实际应用中使用生产者-消费者模型。
例如有一个消息队列，我们有一个消息产生线程，作为生产者；有多个读取线程，作为消费者。

对于之前的小型案例中模拟了这一过程；在读取线程中直接使用锁来和sleep来等待消息队列中产生消息，自然会由于sleep产生延时，为了减少延时改用条件变量。

生产线程使用条件，通常使用以下步骤：

  • 准备信号变量：std::condition_variable cv
  • 获得锁，通常为unique_lock
  • 对消息队列进行修改
  • 释放锁并通知读取线程，通知可以使用one或者all来通知一个或多个线程

对于读取线程，通常也有如下几个步骤：

  • 获得共享锁
  • 等待信号变量，等待使用wait函数，通常有默认形式和lambda表达式两种
  • 处理消息

实例

现在提供一个写入线程和多个读取线程，使用条件变量来实现此功能

准备

先声明锁、条件变量以及一个消息队列和若干头文件

1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>
#include <mutex>
#include <thread>
#include <list>
#include <string>
#include <sstream>
#include <condition_variable>
using namespace std;

list<string> msg;
mutex mtx;
condition_variable cv;

写入线程

直接上代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
void ThreadWrite()
{
    for(int i=0;i<50;i++){
        stringstream ss;
        ss << "msg : " << i+1;
        unique_lock<mutex> lock(mtx);
        msg.push_back(ss.str());
        lock.unlock();
        cv.notify_all();
        //cv.notify_one(); // 通知其中一个读入线程
        this_thread::sleep_for(100ms);
    }
}

cv.notify_one()用于通知一个读取线程
cv.notify_all()用于通知所有读取线程

读取线程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void ThreadRead(int ThreadId)
{
    while(true){
        unique_lock<mutex> lock(mtx);
        cv.wait(lock); 
        // 等待阻塞信号
        // 获取信号后，lock锁定
        // 使用lambda 只要表达式返回的true，wait就不会阻塞
        // cv.wait(lock,[ThreadId](){return !msg.empty();});
        while(!msg.empty()){
            cout << "id = " << ThreadId << " read msg : " << msg.front() << endl;
            msg.pop_front();
            this_thread::sleep_for(200ms);
        }
    }
}

启动线程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void test()
{
    thread wth(ThreadWrite);
    wth.detach();
    for(int i=0;i<3;i++){
        thread th(ThreadRead,i+1);
        th.detach();
    }
    getchar();
}

int main()
{
    test();
}

修改之前案例

之前的小型案例中并未使用条件变量，所以将该案例稍加修改，使用条件变量来处理消息

新增额外变量

使用条件变量首先要包含condition_variable头文件

在MsgServer的头文件中增加条件变量

1
std::condition_variable cv;

修改写入线程

在写入完数据后，将锁释放并通知线程

1
2
3
4
5
6
7
8
9
10
11
12
void MsgServer::SendMsg(std::string Msg)
{
	using namespace std;
	unique_lock<mutex> Lock(Mtx);
	if (CurrentLength >= MaxQueueLength) {
		return;
	}
	MsgQueue.push(Msg);
	CurrentLength++;
	Lock.unlock();
	cv.notify_one();
}

修改读取线程

1
2
3
4
5
6
7
8
// 处理最大延时
//this_thread::sleep_for(100ms);
//改用信号变量处理延时问题，产生消息后会立刻相应
//但是做线程退出时要做一些额外处理 当消息发送完成后发现没有退出，会在wait阻塞
//...
unique_lock<mutex> lock(Mtx);
cv.wait(lock);  
//...

以上是一般形式，但当写入线程写入万所有消息后读取线程会一直阻塞不会退出运行，所以要对退出条件做出一些修改：
首先要重写ThreadStop函数，在stop时发送一条通知；在wait时使用lambda表达式获取退出条件：

1
2
3
4
5
6
7
8
9
10
virtual void ThreadStop()
{
    SetExit();
    cv.notify_all();
    Wait();
}

//...
cv.wait(lock,[this](){return !MsgQueue.empty() || GetIsExit();});
//...

SetExit是额外增加的函数，用于设置bExit为true。
之后再做测试便发现写入线程写入完消息后便会自动退出。

小结

主要介绍了条件变量的使用方法和应用场景。
相比与之前的使用锁的方式，使用条件变量减少了处理消息时的延迟，但相应的也应注意线程的退出条件修改，否则会造成线程一直阻塞。

展开全文 >>

C++多线程入门：小型案例

模拟线程通信

使用队列模拟两个线程间的通信，根据之前所学，提供一个线程基类，同时提供一个Msg派生类。
为了方便编写，将声明与定义写在一起。

线程基类

命名为BaseThread.hpp：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
#pragma once
#include <thread>

class BaseThread
{
public:
	BaseThread():bExit(false)
    {

    }

	virtual void ThreadStart()
    {
        bExit = false;
	    th = std::thread(&BaseThread::Main,this);
    }

	virtual void ThreadStop()
    {
        bExit=true;
        Wait();
    }

	// 等待线程退出-阻塞式
	virtual void Wait()
    {
        if (th.joinable()) {
            th.join();
        }
    }

	bool GetIsExit() { return bExit; }

	virtual ~BaseThread()
    {

    }

private:
	// 逻辑入口
	virtual void Main() = 0;

	bool bExit;
	std::thread th;
};

提供Msg派生类

同样声明为MsgServer.hpp：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#pragma once
#include "BaseThread.h"
#include <string>
#include <queue>
#include <mutex>
#include <iostream>
class MsgServer : public BaseThread
{
public:
	MsgServer():MaxQueneLength(20),CurrentLength(0)
    {

    }

	// 给当前线程发送消息,在主线程中访问
	void SendMsg(std::string Msg)
    {
        using namespace std;
        unique_lock<mutex> Lock(Mtx);
        // 也可以使用一个缓冲区来来临时存放数据
        if (CurrentLength >= MaxQueueLength) {
            return;
        }
        MsgQueue.push(Msg);
        CurrentLength++;
    }
private:
	virtual void Main() override
    {
        using namespace std;
        cout << "Start" << endl;
        while (!GetIsExit()) {
            // 处理最大延时
            this_thread::sleep_for(100ms);
            unique_lock<mutex> lock(Mtx);
            if (MsgQueue.empty()) {
                continue;
            }
            while (!MsgQueue.empty()){
                cout << "RecvMsg = " << MsgQueue.front() << endl;
                MsgQueue.pop();
                CurrentLength--;
            }
	    }
    }

	// 设置消息队列
	std::queue<std::string> MsgQueue;

	std::mutex Mtx;

	size_t MaxQueueLength;
	size_t CurrentLength;
};

进行测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include "MsgServer.hpp"
#include <sstream>
using namespace std;
int main()
{
	MsgServer msgServer;
	msgServer.ThreadStart();
	/*for (int i = 0; i < 15; i++) {
		std::stringstream ss;
		ss << "MsgId = " << i;
		msgServer.SendMsg(ss.str());
		this_thread::sleep_for(100ms);
	}*/
	while (true)
	{
		string s;
		cin >> s;
		if (s == "exit") {
			break;
		}

		msgServer.SendMsg(s);
	}
	msgServer.ThreadStop();
	system("pause");
}

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true


个人简介:
大学生一枚，想要从事游戏开发,
希望能做出自己的游戏

主要涉及技术：
UE4、Unity2D、C++