In another short way:

I want to "fool" the user that no code is running in the background.

I feel Thread.MIN_PRIORITY makes the thread low priority when it tries
to "compete" for the CPU and resource, it does not "give up
voluntarily".

Is that the case?

   The short answer is that you probably want to lower the priority of your
process, rather than the priority of your thread; unfortunately, I don't
think you can do this in Java without resorting to JNI or native calls, and
thus making your program OS dependent.

   Read http://www.javaworld.com/jw-09-1998/jw-09-threads-p2.html 
especially the section titled "Get your priorities straight"

   - Oliver

First problem is that to OS controls CPU scheduling, not the jvm. So you
can not do anything with the CPU scheduling without affecting the whole
program. The only thing you can affect through the jvm is the thread
priority. So unless you want to reduce the priority of the entire
program you have to figure out something with the code.

One obvious solution is to split the program in to two parts. Where the
main part is in one process and the heavy backend/batch part is another.
This allows you to reduce the priority of the backend part at a
process/OS level.

Another solution, which is halfway what you have already done, is to
give the backend thread a low priority while giving the other threads
the highest priority.

Still another solution is to program some sort of control logic for this
your self. You could for example, use yield(), or sleep(), in the
backend part after f.ex. each iteration or some small and divisible part
of the task. You could also implement a jvm scheduler your self.

Only the first solution give exactly what you are asking, but it might
not be feasible. So in short there are no easy answers on this one, you
need to decide on the best solution of the ones available to you.

/tom