You will probably need to provide a little more context. Where is fetch data called? Where is create_cell_contemts called? Who is is adding img2 as a subview, and in what method? What is that thread_check function doing?
If both of these methods are called from within init, your self.custdata= None at the end of init is problematic.... you are removing the reference to the data before you try to access it in the Thread.
This type of problem is typically handled with something like a Semaphore or Lock. If you have two threads, and one depends on the result from the other, you would have the dependent thread block, using a Lock or Semaphore, until the first thread is finished doing what it needs to. The first thread then signals (by releasing the lock) that it is complete. Note that things running within the ui main thread are doing things on their own timeline. Also not that if you use ui.in_background in conjunction with Threads, you will be sorely disappointed -- that does not create a new thread for each call, so things may not get done in the order you expect. See the SPLView i posted recently in a thread recently, or in my uicomponents repo, for an async_exec decorator that does create a new thread.
The other thought i have is that you may need a Semaphore not just for synchronization, but need a Lock for keeping the code nonreentrant. If one or both of these methods is kicked off by a ui event, like scrollview_did_scroll, or touch events, this code could get called multiple times in parallel! if you want to queue up calls, you would use a lock.acquire() at the start of the method, and a lock.release() at the end. If you want to ensure that you only kick off fetch data once (say, if the user scrolls onto then off of the screen, but you still want to keep loading), tou would use the nonblocking version of acquire, check the return type, then return early. The SPLView has an example of this (if i was updating the matplotlib and another touch event came in, i kept track of the cumulative touch, but did not reupdate the matplotlib image.