One thing to note is that the timer is not creating it's own thread. In your example, the reason your timer_callback is not ending is because you're expecting that function to be in it's own thread, which it is not. All the timer does is create callback events that an executor would pick up to run. In your example, you create the executor when you call rclpy.spin() which initializes the default, single-threaded executor, adds the node upload_plan to it, and then calls spin() on that executor. Whenever your subscription object or timer object need to respond to do something, they create an event, or callback, for the executor to actually do the executing.

What you're trying to do is wrong because your events should not be continuous, blocking events, lest they clog up the executor from being able to do other things. I don't quite understand why you think you need a separate thread inside the timer_callback. I'm guessing from your example that you're are simply trying to create a periodic calculation that listens to topics and publishes a calculation as the given timer_period. To do that all you would need to do is modify your blocking function to be one run of that calculation and then publish that result for the other vehicles to use. It would look something like this:

class UploadPlan(Node):

    def __init__(self):
        super().__init__('upload_plan')
        self.publisher_ = self.create_publisher(String, '/topic', 10)
        self.subscription = self.create_subscription(
            String,
            '/topic',
            self.sub_callback,
            10)
        self.state = "foo"
        timer_period = 1  # seconds
        self.timer = self.create_timer(timer_period, self.timer_callback)

    def timer_callback(self):
        if self.state == 'bar':
            self.publisher_.publish(String("foobar"))
        else:
            self.publisher_.publish(String("barfoo"))

    def sub_callback(self, msg):
         self.state = msg.data

def main(args=None):
    rclpy.init(args=args)

    upload_plan = UploadPlan()

    rclpy.spin(upload_plan)
    upload_plan.destroy_node()
    rclpy.shutdown()


if __name__ == '__main__':
     main()