After thread and process close, the MainThread still running

TL;DR

First some comments:

1. You have made the read_video thread, the display_video thread and the Model process all daemon yet your main process waits for their completion by calling join. Then nothing is gained by making the threads and process dameon. When a thread or process puts items on a multiprocessing.Queue instance a hidden thread is started that manages the actual putting of the items on the queue, which is built from a multiprocessing.Pipe that has a limited capacity. This prevents the writing process or thread from blocking on a put call (it will be this hidden thread that will block instead).
2. Following the call to c.join() you execute c.terminate(). But the process, by having already called join, has already been terminated. So this seems pointless.
3. Your main process issues calls to close on the multiprocessing.Queue instances. This call is normally made by "writers" to the queue to signify that no more items will be placed on the queue. But your main process is not the one putting items on these queues and so calling close should not be its responsibility. It is also a call that no thread or process really needs to make. It just allows the (hidden) thread that is managing the queue to terminate once the queue becomes empty. This will occur anyway as soon as the queue is garbage collected.
4. In my opinion (others may disagree), it is better in general not to subclass the threading.Thread and multiprocessing.Process classes since the logic you have implemented in those subclasses are now too tightly coupled to threads and processes. I think it is better, for example, to have Model just be a subclass of object (implicitly or explicitly) with the run method removed and to then do m = Model(...); c = Process(target=m.predict).

As for the problem you may be having: When a thread or process has put items on a multiprocessing.Queue instance, it cannot terminate until those items have been retrieved by some reading thread or process. So you must never try to join such a writer thread/process until the queue it has written to is empty or will be empty.

The read_video queue is a "writer" to the predict_frame_queue and the Model process is a writer to the predict_result_queue. The display_video thread is the "reader" of both of these queues. If ‘c’ is typed in the video window then the display_video.show calls self.lock.set() to signal that it is finished and then it returns. But has it possibly left any items on either of the multiprocessing queues? If so, this is a problem because the main process is attempting to join the Model process and read_video thread but these will not terminate as long as there are unread items on them. Likewise, method Model.predict returns when it sees that self.lock has been set and it, too, may have not emptied the predict_frame_queue. It is true that it does not check self.lock until the call self.predict_frame_queue_empty() returns True. But if you read the documentation on the queue_empty method you will see that this call is unreliable. Moreover, even if it were reliable, you would have a race condition arising the the period of time that exists between finding the queue empty and returning for in that small window of time it is possible that another item has been placed on the queue.

Now I cannot be sure that this is what is causing your hang. You may have another issue that I have not spotted. But at the very least, your multiprocessing queue readers must ensure that they do not return until they are certain they have read all the messages if you will be joining these threads and process in the main process.

Try This

Keep your threads and process as daemon, but do not do join calls on these in the main process. Instead, the main process also waits on the termination event:

if __name__ == "__main__":
    lock = multiprocessing.Event()
    sync_lock = multiprocessing.Barrier(3)
    display_queue = queue.Queue()
    predict_frame_queue = multiprocessing.Queue()
    predict_result_queue = multiprocessing.Queue()

    a = read_video("testingv.mp4", lock, sync_lock, display_queue, predict_frame_queue)
    b = display_video(lock, sync_lock, display_queue, predict_result_queue)
    c = Model("best200.pt", lock, sync_lock, predict_frame_queue, predict_result_queue)
    a.start()
    b.start()
    c.start()

    # Wait for this event:
    lock_event.wait()
    # Threads and process will still be running but will terminate
    # when we do.

Alternative

You can remove the daemon attribute from your process and threads and then make sure that no "readers" of a multiprocessing.Queue (the Model process doing get calls on predict_frame_result and the display_video thread doing get calls on predict_result_queue) are terminating before first getting all items from the queue. The safest way to do this is to have the writers of these queues (read_video and Model respectively) put a special sentinel item (None can be used if None cannot be a "normal" data item) indicating that this is the last item that will ever be put on the queue. Then the readers enter a loop getting items from the queue until it sees the sentinel item.

Model.predict should be:

 def predict(self):

        ...
        frame = '' # anything other than a sentinel value
        while not self.lock_is_set():
            frame = self.predict_frame_queue.get()
            # Sentinel?
            if frame is None:
                break
            predict = model(frame).xyxy[0].cpu().numpy()
            self.predict_result_queue.put(predict)

        # Put a sentinel item:
        predict_result_queue.put(None)
        # Empty the queue if we haven't seem the sentinel:
        while frame is not None:
            frame = self.predict_frame_queue.get()
        #self.close() # What is this?

        return

And read_video.read should be:

    def read(self):
        ...

        # Put sentinels:
        self.predict_frame_result.put(None)
        self.result_frame_result.put(None)

        return

And display_video.show should be:

    def show(self):
        ...

            if cv2.waitKey(1) & 0xff == ord('c'):
                self.lock.set()
                cv2.destroyAllWindows()
                # Empty queues:
                while display_frame_queue.get() is not None:
                    pass                    
                while predict_result_queue.get() is not None:
                    pass                    
                break

        return