void thread_1(int n)
{
    boost::mutex::scoped_lock  lock_1(mut);
    cout << "start thread 1" << endl;
    sum = sum * n;
    cout << "thread 1, sum: " << sum << endl;
}

void thread_2(int n)
{
    boost::mutex::scoped_lock  lock_2(mut);
    cout << "start thread 2" << endl;
    sum = sum * 7 * n;
    cout << "thread 2, sum: " << sum << endl;
}

// executeLoop函数在不断地轮转状态，以检测新的目标到来
template <class ActionSpec>
void SimpleActionServer<ActionSpec>::executeLoop()
{
    ros::Duration loop_duration = ros::Duration().fromSec(.1);

    while (n_.ok())
    {
      {
        boost::mutex::scoped_lock terminate_lock(terminate_mutex_);
        if (need_to_terminate_)  // 只在 shutdown() 函数中为 true
          break;
      }
      boost::recursive_mutex::scoped_lock lock(lock_);
      if (isActive())
        ROS_ERROR_NAMED("actionlib", "Should never reach this code with an active goal");

      // new_goal_ 标志被置为true后，即 goalcallback 函数被执行完毕后
      else if (isNewGoalAvailable()  )
      {
        GoalConstPtr goal = acceptNewGoal();

        ROS_FATAL_COND(!execute_callback_, "execute_callback_ must exist. This is a bug in SimpleActionServer");

        // Make sure we're not locked when we call execute
        // 重新以新的goal执行executecallback函数
        lock.unlock();
        execute_callback_(goal);
        lock.lock();

        if (isActive())
        {
          ROS_WARN_NAMED("actionlib", "Your executeCallback did not set the goal to a terminal status.\n"
                   "This is a bug in your ActionServer implementation. Fix your code!\n"
                   "For now, the ActionServer will set this goal to aborted");
          setAborted(Result(), "This goal was aborted by the simple action server. The user should have set a terminal status on this goal and did not");
        }
      }
      // 如果没有新目标，通过条件变量将线程阻塞
      else   
        execute_condition_.timed_wait(lock, boost::posix_time::milliseconds(loop_duration.toSec() * 1000.0f));
    }
  }

status_pub_ =
  node_.advertise<actionlib_msgs::GoalStatusArray>("status",
    static_cast<uint32_t>(pub_queue_size), true);

// read the frequency with which to publish status from the parameter server
// if not specified locally explicitly, use search param to find actionlib_status_frequency
double status_frequency, status_list_timeout;
if (!node_.getParam("status_frequency", status_frequency)  )
{
  std::string status_frequency_param_name;
  if (!node_.searchParam("actionlib_status_frequency", status_frequency_param_name) )
  {
    status_frequency = 5.0;
  }
  else
  {
    node_.param(status_frequency_param_name, status_frequency, 5.0);
  }
}
else
{
  ROS_WARN_NAMED("actionlib",
    "You're using the deprecated status_frequency parameter, please switch to actionlib_status_frequency.");
}
node_.param("status_list_timeout", status_list_timeout, 5.0);

this->status_list_timeout_ = ros::Duration(status_list_timeout);

if (status_frequency > 0)
{
  status_timer_ = node_.createTimer(ros::Duration(1.0 / status_frequency),
      boost::bind(&ActionServer::publishStatus, this, boost::placeholders::_1));
}