Efficient and scalable use of shared resources

A computing device comprising:

• storage hardware storing instructions;
• processing hardware that, when executing the instructions, performs a process comprising:
• executing a process comprising threads, each thread comprising a shared object that stores a resource and an expiration time of the resource, each thread having a lock associated with the shared object, each thread configured to perform respective work using the resource;
• when any of the threads require the resource to perform the work, the thread blocks on the lock if the lock is locked;
• when any of the threads determine that the resource is available, the thread uses the resource to perform the work;
• when any of the threads determine that the resource is not available, the thread locks the lock, acquires the resource from a source external to the process, sets the expiration time accordingly, and then unlocks the lock;
• and
• when any of the threads determine that the expiration time is below threshold, the thread communicates with the external resource to renew the resource, then locks the lock to reset the expiration time, and then unlocks the lock.

Computer storage hardware storing information configured to cause one or more computers to perform a process, the process comprising:

• executing a process managed by an operating system, the process comprising worker threads and a shared resource;
• providing the shared resource, which is shared among the threads, wherein the threads use the shared resource to perform respective tasks;
• initially acquiring the shared resource from a source outside the process when any one of the threads requires the shared resource by any one of the threads:
• acquiring the resource from the source outside the process, setting an expiration time for the shared resource, copying the shared resource, and then signaling the other threads that the shared resource is available, wherein any other thread that requires the shared resource during the initial acquiring will:
• block until signaled that the shared resource is available, and then access the shared resource;
• refreshing the shared resource when any of the threads require the shared resource and the current time is within a threshold amount of time from the expiration time by any one of the threads:
• refreshing the shared resource with the source outside the process, and excluding the other threads from using the expiration time while resetting the expiration time, wherein any other thread can access the shared resource while the shared resource is being refreshed;
• and
• when any of the threads require the shared resource and the shared resource is available and current time is not within the threshold of the expiration time, the thread accesses the shared resource.