How to use Reap and Sow instead of AppendTo

You need only one Reap for all Sows -- that's primarily the advantage of using them.

Moreover, you may use tags to obtain datax[1] and datax[2]:

x = {{0.1}, {0.2}}; ClearAll[datax]; datax = Association@Reap[ Do[ x = x + t; Do[ Sow[ Flatten[{t, x[[tag]]}], tag ], {tag, 1, 2}], {t, 0, 1, 0.1}], _, Rule][[2]] 

<|1 -> {{0., 0.1}, {0.1, 0.2}, {0.2, 0.4}, {0.3, 0.7}, {0.4, 1.1}, {0.5, 1.6}, {0.6, 2.2}, {0.7, 2.9}, {0.8, 3.7}, {0.9, 4.6}, {1., 5.6}}, 2 -> {{0., 0.2}, {0.1, 0.3}, {0.2, 0.5}, {0.3, 0.8}, {0.4, 1.2}, {0.5, 1.7}, {0.6, 2.3}, {0.7, 3.}, {0.8, 3.8}, {0.9, 4.7}, {1., 5.7}}|>

Now you can access datax[1] and datax[2] as before.

Edit:

Because the question changed: This should allow you to assemble more than one list in one go:

data = Merge[ Reap[ Do[ x = x + t; xm = xm + t; Do[ Sow[Flatten[{t, x[[i]]}], "datax" -> i]; Sow[Flatten[{t, xm[[i]]}], "dataxm" -> i] , {i, 1, 2}], {t, 0, 1, 0.1}], _, #1[[1]] -> Association[#1[[2]] -> #2] &][[2]] , Association ]; 

Now data["datax"] and data["dataxm"] should behave like datax and dataxm.

Edit 2

You can obtain essentially the same result much more efficiently with arrays produced by Table:

x = {0.1, 0.2}; xm = {0.4, 0.5}; {datax, dataxm} = Transpose[ Table[{{{t, t}, x += t}, {{t, t}, xm += t}}, {t, 0, 1, 0.1}], {3, 1, 4, 2}]; 

Now you have (notice the double brackets):

datax[[1]] datax[[2]] dataxm[[1]] dataxm[[2]] 

Speed considerations

Even faster for this particular problem is to avoid recursive addition and to use vectorized operations.

The Reap/Sow method from above:

n = 1000000; x = {0.1, 0.2}; xm = {0.4, 0.5}; First@AbsoluteTiming[ data = Merge[ Reap[ Do[ x = x + t; xm = xm + t; Do[ Sow[Flatten[{t, x[[i]]}], "datax" -> i]; Sow[Flatten[{t, xm[[i]]}], "dataxm" -> i] , {i, 1, 2}], {t, 0., 1., 1./n}], _, #1[[1]] -> Association[#1[[2]] -> #2] &][[2]] , Association ]; ] 

11.4845

The Table method from above:

x = {0.1, 0.2}; xm = {0.4, 0.5}; First@AbsoluteTiming[ {datax, dataxm} = Transpose[ Table[{{{t, t}, x += t}, {{t, t}, xm += t}}, {t, 0., 1., 1./n}], {3, 1, 4, 2}]; ] 

2.74062

Vectorized version:

x = {0.1, 0.2}; xm = {0.4, 0.5}; First@AbsoluteTiming[ tlist = Subdivide[0., 1., n]; slist = Accumulate[tlist]; datax2 = { Transpose[{tlist, x[[1]] + slist}], Transpose[{tlist, x[[2]] + slist}] }; dataxm2 = { Transpose[{tlist, xm[[1]] + slist}], Transpose[{tlist, xm[[2]] + slist}] }; ] 

0.061355

So, the latter is 187 or 44 times faster than the methods before. So you should take these considerations into account when using Reap and Sow.

Errors:

Max[Abs[data["datax"][1] - datax[[1]]]] Max[Abs[data["datax"][2] - datax[[2]]]] Max[Abs[data["dataxm"][1] - dataxm[[1]]]] Max[Abs[data["dataxm"][2] - dataxm[[2]]]] Max[Abs[datax - datax2]] Max[Abs[dataxm - dataxm2]] 

5.82077*10^-11

5.82077*10^-11