Java ResultSet如何检查是否有任何结果(Java ResultSet how to check if there are any results)

 如果你喜欢，你可以像使用任何其他线程程序一样同步使用threading.Lock访问共享资源，而不是复制它。 
 
 无论如何，我认为在进行优化之前，有必要对代码进行基准测试，然后进行深度复制和其他测量，以确定性能的好坏。 或许它的速度缓慢的原因与深度拷贝无关。 
 
 关于使用锁定编辑：我的意思是，你可以使用更多的细粒度锁定此资源。 我假设你的线程不仅仅是访问共享资源。 您可以尝试从多个正在工作的线程中受益，然后将访问同步到只涉及写入共享资源的“关键部分”。 您也可以调查使您的共享资源线程安全。 例如，如果有一个共享对象， SillyExampleFriendsList ： 
 
class SillyExampleFriendsList(object):
    """Just manipulates a couple lists"""
    def __init__(self):
       self._lock = threading.RLock()
       self._friends = []
       self._enemies = []

    def unfriend(self, x):
       # we lock here to ensure that we're never in a state where
       # someone might think 'x' is both our friend and our enemy.
       self._lock.acquire()
       self._friends.remove(x)
       self._enemies.append(x)
       self._lock.release()
 
 这里的要点只是上面的对象可能在多个线程之间共享，而不需要通过仔细使用锁来进行深度复制。 识别所有这些可能是必要的情况并不是微不足道的，精细的锁定策略可能更难以调试，并且仍然会产生开销。 
 
 也就是说，你可能根本不需要线程，锁或深度拷贝，也不需要对代码进行基准测试，但是如果你有需要解决的性能问题还不清楚。 我很好奇，是什么让你认为你的代码应该更快或者更快？ 

If you like you could just synchronize access to the shared resource with threading.Lock just like you would in any other threaded program rather than copying it. 
 
Regardless, I think it's worth benchmarking your code with and without the deepcopy and otherwise measuring to figure out how good/bad the performance really is before making optimizations. Perhaps the reason it is slow has nothing to do with deepcopy.
 
EDIT regarding using locking: What I mean is that you can use more fine grained locking around this resource. I assume that your threads are doing more than accessing a shared resource. You can try to benefit from multiple threads doing work and then synchronize access to just the one "critical section" that involves writing to the shared resource. You might also investigate making your shared resource threadsafe. For example, if have a shared object, SillyExampleFriendsList:
 
class SillyExampleFriendsList(object):
    """Just manipulates a couple lists"""
    def __init__(self):
       self._lock = threading.RLock()
       self._friends = []
       self._enemies = []

    def unfriend(self, x):
       # we lock here to ensure that we're never in a state where
       # someone might think 'x' is both our friend and our enemy.
       self._lock.acquire()
       self._friends.remove(x)
       self._enemies.append(x)
       self._lock.release()
 
The point here is just that the above object could potentially be shared between multiple threads without deepcopy by careful use of locks. It's not trivial to identify all the cases where this might be necessary and fine grained locking strategies can be more difficult to debug and still introduce overhead.
 
That said, you may not need threads, locks, or deepcopy at all and without benchmarking your code it's not clear if you have a performance problem that needs to be solved. I'm curious what makes you think that your code should be, or needs to be, faster?