Eric, thanks again for the comment.

but now you're happy with completely externalizing the results for offline inspection.

If you run the last code example I uploaded, you may be able to monitor the Graphics3D output in real time at every intermediate step (i=1,2,3,...,20) as they are evaluated. Yes they are saved to the SSD as png files also but the important point is that it enables real-time screen monitoring without skipping any of the results and I am happy with that. If I save all the steps' outputs (hundreds or thousands of them) to an array and use ListAnimate, it may take up too much memory for my computer to handle so I rather decided to use For loop to keep updating the vector array variable as the calculation goes on, rather than keep appending it to another giant array of arrays. I am not as fluent as most of the experts here including you in Mathematica and I learned a lot from your comments. I guess that the problem might be ultimately solved if Dynamic can have an option to increase its graphical rendering priority as you implied, or there is a Pause-like function that waits until Dynamic finishes updating all of its graphical output.

Eric, thanks for the suggestion again. I inserted a png file Export command in place of the Pause as shown below and it just works fine and shows each and every step now. Probably the png Export requires the output of the updated Graphics3D object a enforcing it to wait until the graphics update is finished internally, or it simply took just enough time :).

a = Graphics3D[{}];
Dynamic[a]
For[i = 1, i <= 20, i++, b = RandomReal[{-1, 1}, {10000, 3}];
 TextStr = {Text["i=" <> ToString[i], {0, 0, 5}]};
 b3g = Map[Sphere[#, 1] &, b];
 a = Graphics3D[{TextStr, b3g}, 
   PlotRange -> {{-5, 5}, {-5, 5}, {-5, 5}}];
 Export["D:\\Downloads\\a" <> ToString[i] <> ".png", a]
 ]

Eric, thanks for your suggestions.

I have some explanation about the code examples and my goal. The large evaluation of RandomReal simulates a chunk of somewhat complicated calculations involving a large array of vectors on a triangular lattice without showing too much details but ends up using a similar total time O(1 sec) per cycle when combined with the Map step. The 10,000 instances of Spheres in the first example also simulates the large Graphics3D object made up of many 3d Arrows used to display the intermediate status of the vector arrays. I wanted to check each and every single cycle result real time on screen as the calculation goes on, but as shown in the first example, many cycles (i=1,2,...,19) are skipped totally, unlike the much lighter second example which shows the whole progression without skipping.

If I insert Pause at the end of the For execution part as shown in the code example below, it shows only i=20 when Pause[0] is used (on my computer), shows i=5,7,9,11,13,15,17,19,20 when Pause[1] is used, shows i=2,3,4,5,6,7,8,...,19,20 when Pause[2] is used.

Dynamic[a]
For[i = 1, i <= 20, i++, b = RandomReal[{-1, 1}, {50000, 3}];
TextStr = {Text["i=" <> ToString[i], {0, 0, 5}]};
b3g = Map[Sphere[#, 1] &, b];
a = Graphics3D[{TextStr, b3g}, 
PlotRange -> {{-5, 5}, {-5, 5}, {-5, 5}}];
Pause[0.2];
]

My guess is that the Graphics3D object of each cycle is thrown at the graphics handler of Mathematica responsible for Dynamic at a pace too fast for it to process and spit out to the screen in time before it receives the next Graphics3D object due to the sheer number of 3D Arrows contained in it. All I need is that, without using Pause and tuning its time atgument to match the speed of the graphics handler, simply do the calculation and the visualization one after the other as if they are performed by a single computing thread.

Why are you generating 10 million random triples when you only need 20?