Maybe there will be more than one loop -- but you cannot guarantee that there will be more than one loop. I'd advise reading over the proof of the pumping lemma (for regular languages).
I'll sketch the proof in pseudo-english. This is written in the context of this previous post
of mine, for those joining us at home.
Suppose a language L is regular, recognized by some FSM M. Then for some N, M has N states (we don't know what N is!).
Now, suppose L contains a string S such that |S| > N.
Claim 1: when recognizing S, M uses (at least one) state twice. Let a state that is used twice when recognizing S be called Bob.
If M uses the same state twice, we break the string S into three parts. a b and c. a is the part of S that occurs before we reach Bob for the first time while recognizing S. b is the part of the string that starts when we first reach Bob while recognizing S, and ends at the next time we reach Bob. c is the rest of S after the 2nd time we reach Bob.
So S = a b c
Claim 2: a b^n c is in L, for all n >= 0.
And that is the pumping lemma for regular languages.
The two claims can be proven pretty easily.
The first Claim is proven by the pigeonhole principle. When recognizing a string, M transitions from one state to another. If it stays in the same state as it reads a character, that is a really short loop. So to recognize a string of length S without visiting a state twice, it needs |S| states, but it only has N states, and N < |S| by a previous assumption. So it must visit a state twice!
The second Claim would be formally proven by induction, but the main idea is pretty simple. After reading a, we are in state Bob. And, if we are in state Bob and get the string c, we end up accepting. So a c is accepted. So is a b c. Now, b starts in state Bob and ends in state Bob -- but the same is true of b b and b b b and b b b b and b b b b b. So a b b b b b b b c is also accepted: in fact, a X c, where X is any string such that if the machine M started in state Bob, would be back in state Bob after reading X, is accepted. We happen to know that b^n has this property -- so we know that a b^n c has this property.
The real trick here is that the only assumptions we made was that L is a regular language. We then talked about properties it must have (even if we cannot explicitly find them) for it to be regular. And from that, we constructed the conclusion of the pumping lemma.
There could in fact be multiple loops in how M recognizes (at least one string) in L -- but we cannot prove this. And, there is no reason for two loops to be "in sync" like with the CFG one -- in fact, if the language requires that they be in sync, then you cannot recognize it with a FSM!
(The CFG one has two loops in sync because of the limited memory that CFGs recognizers have). You can view this as a property of CNF grammars, or you can make an argument about pushdown automata. The CFG pumping lemma is a bit nastier to prove -- but the main idea (that a you can find a structure in a string in which the CFG parser can be forced to "loop" over) is the same, but because of the increased complexity of said parser the structure is more complex.