diff --git a/providers/xmlprovider/resolver.go b/providers/xmlprovider/resolver.go
index 276e57a..360c0ef 100644
--- a/providers/xmlprovider/resolver.go
+++ b/providers/xmlprovider/resolver.go
@@ -9,7 +9,7 @@ import (
 
 type Resolver[T XMLItem] struct {
 	index map[string]map[string][]Resolved[T] // Map[typeName][refID] -> []*T
-	mu    sync.Mutex                          // Synchronization for thread safety
+	mu    sync.RWMutex                        // Synchronization for thread safety
 }
 
 func NewResolver[T XMLItem]() *Resolver[T] {
@@ -27,6 +27,9 @@ func (r *Resolver[T]) Add(typeName, refID string, item Resolved[T]) {
 }
 
 func (r *Resolver[T]) Get(typeName, refID string) ([]Resolved[T], error) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+
 	if typeIndex, exists := r.index[typeName]; exists {
 		if items, ok := typeIndex[refID]; ok {
 			return items, nil
diff --git a/providers/xmlprovider/xmlprovider.go b/providers/xmlprovider/xmlprovider.go
index e0d87f8..eb5d637 100644
--- a/providers/xmlprovider/xmlprovider.go
+++ b/providers/xmlprovider/xmlprovider.go
@@ -44,7 +44,7 @@ type XMLProvider[T XMLItem] struct {
 	// INFO: Resolver is used to resolve references (back-links) between XML items.
 	Resolver Resolver[T]
 
-	mu sync.Mutex
+	mu sync.RWMutex
 	// TODO: This array is meant to be for iteration purposes, since iteration over the sync.Map is slow.
 	// It is best for this array to be sorted by key of the corresponding item.
 	Array []T
@@ -149,7 +149,6 @@ func (p *XMLProvider[T]) ReverseLookup(item XMLItem) []Resolved[T] {
 		r, err := p.Resolver.Get(item.Name(), key)
 		if err == nil {
 			ret = append(ret, r...)
-			return ret
 		}
 	}
 
@@ -158,11 +157,6 @@ func (p *XMLProvider[T]) ReverseLookup(item XMLItem) []Resolved[T] {
 
 func (a *XMLProvider[T]) String() string {
 	var s string
-	a.Items.Range(func(key, value interface{}) bool {
-		v := value.(T)
-		s += v.String()
-		return true
-	})
 	for _, item := range a.Array {
 		s += item.String()
 	}
@@ -188,8 +182,8 @@ func (p *XMLProvider[T]) Item(id string) *T {
 }
 
 func (p *XMLProvider[T]) Find(fn func(*T) bool) []T {
-	p.mu.Lock()
-	defer p.mu.Unlock()
+	p.mu.RLock()
+	defer p.mu.RUnlock()
 	var items []T
 	for _, item := range p.Array {
 		if fn(&item) {
@@ -199,10 +193,11 @@ func (p *XMLProvider[T]) Find(fn func(*T) bool) []T {
 	return items
 }
 
+// INFO: These are only reading locks.
 func (p *XMLProvider[T]) Lock() {
-	p.mu.Lock()
+	p.mu.RLock()
 }
 
 func (p *XMLProvider[T]) Unlock() {
-	p.mu.Unlock()
+	p.mu.RUnlock()
 }