For the benefit of anyone else finding this question, there is a great overview here:
http://www.fasterj.com/articles/oraclecollectors1.shtml
To quote the relevant parts for this question:
Young generation collectors
Copy (enabled with -XX:+UseSerialGC)
the serial copy collector, uses one thread to copy surviving objects from Eden to Survivor spaces
and between Survivor spaces until it decides they've been there long
enough, at which point it copies them into the old generation.
PS Scavenge (enabled with -XX:+UseParallelGC)
the parallel scavenge collector, like the Copy collector, but uses multiple threads
in parallel and has some knowledge of how the old generation is
collected (essentially written to work with the serial and PS old gen
collectors).
ParNew (enabled with -XX:+UseParNewGC)
the parallel copy collector, like the Copy collector, but uses multiple threads in
parallel and has an internal 'callback' that allows an old generation
collector to operate on the objects it collects (really written to
work with the concurrent collector).
G1 Young Generation (enabled with -XX:+UseG1GC)
the garbage first collector, uses the 'Garbage First' algorithm which splits up
the heap into lots of smaller spaces, but these are still separated
into Eden and Survivor spaces in the young generation for G1.
Old generation collectors
MarkSweepCompact (enabled with -XX:+UseSerialGC)
the serial mark-sweep collector, the daddy of them all, uses a serial (one
thread) full mark-sweep garbage collection algorithm, with optional
compaction.
PS MarkSweep (enabled with -XX:+UseParallelOldGC)
the parallel scavenge mark-sweep collector, parallelised version (i.e. uses
multiple threads) of the MarkSweepCompact.
ConcurrentMarkSweep (enabled with -XX:+UseConcMarkSweepGC)
the concurrent collector, a garbage collection algorithm that attempts to
do most of the garbage collection work in the background without
stopping application threads while it works (there are still phases
where it has to stop application threads, but these phases are
attempted to be kept to a minimum). Note if the concurrent collector
fails to keep up with the garbage, it fails over to the serial
MarkSweepCompact collector for (just) the next GC.
G1 Mixed Generation (enabled with -XX:+UseG1GC)
the garbage first collector, uses the 'Garbage First' algorithm which splits up
the heap into lots of smaller spaces.