text: Title: Can you do a start_background_task on eventlet async mode and never join/kill it?
  Body: Before anything else, I would like to apologize in advance for the grammar and english mistakes I'm probably going to make. It's not my first language.
  
  So i'm working on a project and so far everything is working perfectly. Thank you for this amazing extension. I have a quick question. In my application, a user can place a sort of "bet". When they do, the server has to wait 30 seconds, while checking if there are any new players. If there are, the timer stops and the game begins. If not, the game is cancelled.
  
  My question is, if I use the `socketio.start_background_task()` function, on the eventlet server, can I never actually do a `join()` on the thread? Will there be any memory leaks or will I lose performance because of "sleeping" threads?
  
  I'll include some code to further illustrate my question. (The `self.get_state()` is simply a way to check (using redis) if any other process, such as another server when the app scales, has changed the state). I'm storing pretty much everything to do with the game's state in a redis DB.
  
  ```
  # On a route file.
  game = Game()
  @socket.on("bet-jackpot")
  def bet_jackpot(amount):
      sid = request.sid
      # Omitting some database work and checks.
      try:
          game.handle_bet(user_id, sid, user_name, user_avatar, amount)
      except RuntimeError:
          emit("jck-error", "Can't bet now", room=sid)
          return
  
  # On the models file.
  class Game:
      # Also omitting some logic.
      def handle_bet(self, id, sid, username, avatar, amount):
          if self.get_state() == "R":
              raise RuntimeError("Cant bet now")
  
          if self.get_state() == "W":
              self._add_player_to_game(id, sid, username, avatar, amount)
              socket.start_background_task(target=self.start_game_loop)
  
          elif self.get_state() == "O" or self.get_state() == "L":
              self._add_player_to_game(id, sid, username, avatar, amount)
  
      def start_game_loop(self):
          self.set_state("O")
          socket.emit("jck-state", "O")
  
          socket.emit("jck-timer", 30.00)
          self._start_one_player_timer(30.00)    # Timer function that loops until there are 2 players or the 30 seconds end.
  
          if self.get_player_amount() <= 1:    # Cancelling game
              socket.emit("jck-state", "W")
              self.reset()
              return
  
          self.set_state("L")
          socket.emit("jck-state", "L")
  
          socket.emit("jck-timer", 25.00)
          self._start_main_timer(25.00)    # Same as above, but no checking for players.
  
          # After, we do some simple db work.
  ```
  
  If this function gets called every time a game is played, will the server eventually lag and lose performance because of the threads that are never joined? Or will the eventlet web server know how to "stop" a finished thread?
  
  Thank you and sorry if it seems like a "noob" question, I'm not very experienced in multithreading and these types of apps.
  