Should I be using a standard or recursive mutex to handle callback interruptions?

edit

I have some code to help describe my problem

void CallbackA(const type& msg)
{
  // do stuff
  WorkerFunction(data);
}

void CallbackB(const type& msg)
{
  // do stuff
  WorkerFunction(data);
}

void WorkerFunction(const type& data)
{
  // do stuff
  ros::spinOnce();
  // do more stuff
}

I am debugging a race condition where a callback function--CallbackA--is running and has not yet completed when a topic gets published causing CallbackB to run because I have a ros::spinOnce() called in a subsequent function. I want to use a mutex to ensure that the current function will finish, before letting the new callback run. This wouldn't be a problem if I did not call spinOnce inside, but I want to let other nodes do work as well.

My question is, should I use a std::mutex or std::recursive_mutex? I understand the difference, but what I don't know is how ROS handles these things. I.e. are callbacks performed with the same thread, or a new thread?

Also, as a secondary question, when are new threads created in ROS? (without specifically creating them myself)

Architectural Details

The callbacks and worker function are inside a node meant for recording information about my robot so it can publish a single, organized report. As such, it gathers information from all parts of the robot including (but not limited to): local planner, global planner, and coverage planner (a node meant for keeping track of where I've been).

Some functions inside this reporter node take a long time to compute and I want to make sure that I am not losing messages so I spawn a thread and while that thread is making calculations (the thread is localized to a single function) I will call ros::spinOnce to ensure that I keep up with the information coming in.

My problem is that I want to block certain callbacks while I'm making these calculations. I thought that I should use a mutex for this, which is why I'm asking how the threads are handled so I could decide whether to use a standard or recursive mutex.

When I say let other nodes do work as well, what I meant was that I did not want to hog cpu from other nodes since other nodes provide mission critical functions like detecting obstacles and since ROS is built off of Linux which isn't a RTOS, I need a way to tell the OS: "the current job can wait for a while, please execute other jobs and come back to this later". I thought ros::spinOnce() was doing that, but, judging by the comments I am mistaken.