thread-safe-like dict

import threading
from queue import Queue
import time
from random import randint, seed
seed()
import sys
#print("getcheckinterval= ", sys.getcheckinterval())
#sys.setcheckinterval(1)
print("getcheckinterval= ", sys.getcheckinterval())
print("cavolo")

numeroVolte = 500000
numeroVoci = 10
threadN = 4
startTick = 256

#from contextlib import ContextDecorator

class Clienti():

    def __init__(self, codUs):
        self.lock = threading.Lock()
        self.lock.acquire()
        self.codUs = codUs
        self.oldCarica = list()
        self.incarica()

        self.lock.release()

    def incarica(self):
        self.carica = bytes()
        self.tup = (randint(2024, 53247), )
        iTup = 9348532659245850625 - id(self.tup)
        for j in range(4):
            parzialeMod = iTup.__mod__(53247) + 2048
            iTup = iTup//2048
            self.carica += chr(parzialeMod).encode()
        try:
            dDic[self.carica]
            self.oldCarica.append((dDic[self.carica], self.codUs,None,"AAAAAAAAAAAAAAAAAAAGià presente", sys.getcheckinterval()))
        except:
            dDic[self.carica] = self.codUs

    def wriRanInt(self, item):
        # riscrivo la voce
        if self.lock.acquire():
            if self.carica:
                # già stato caricato
                try:
                    # quindi ci dovrebbe essere:
                    dDic[self.carica]
                    if dDic[self.carica] != item[0]:
                        self.oldCarica.append((self.carica, self.codUs, dDic[self.carica], "div W"))
                    dDic.__delitem__(self.carica)
                except:
                    self.oldCarica.append((self.carica, self.codUs, None,  "Inesistente1"))
            self.incarica()
            self.lock.release()

    def delRanInt(self, item):
        # distruggo la voce
        if self.lock.acquire():
            if self.carica:
                # già stato caricato
                try:
                    # quindi ci dovrebbe essere:
                    dDic[self.carica]
                    if dDic[self.carica] != item[0]:
                        self.oldCarica.append((self.carica, self.codUs, dDic[self.carica], "div D"))
                    dDic.__delitem__(self.carica)
                except:
                    self.oldCarica.append((self.carica, self.codUs, None, "Inesistente2"))
            self.tup = None
            self.carica = None
            self.lock.release()

    def reaRanInt(self, item):
        # qui leggo solo:
        if self.lock.acquire():
            if self.carica:
                # già stato caricato
                try:
                    # quindi ci dovrebbe essere:
                    dDic[self.carica]
                    if dDic[self.carica] != item[0]:
                        self.oldCarica.append((self.carica, self.codUs, dDic[self.carica], "div R"))
                        #print((item[0], self.codUs, dDic[self.carica], "++++++++++++++++div R", sys.getcheckinterval()))
                except:
                    self.oldCarica.append((self.carica, self.codUs, None, "Inesistente3"))
                    self.incarica()
            self.lock.release()

def provaCombinazioni():

    for j in range(numeroVoci):
        # carico qui
        dizio[j] = Clienti(j)

    def do_work(item):
        #chi = randint(0, 9)
        #cheFaccio = randint(0, 9)
        #q.put((chi, cheFaccio))
        chi, chefaccio = item

        if chefaccio < 2:
            # riscrivo
            return dizio[chi].wriRanInt(item)

        if chefaccio < 4:
            # cancello
            return dizio[chi].delRanInt(item)

        # cazzeggio
        return dizio[chi].reaRanInt(item)

    # The worker thread pulls an item from the queue and processes it
    def worker():
        while True:
            item = q.get()
            do_work(item)
            q.task_done()

    # Create the queue and thread pool.
    q = Queue()
    #for i in range(4):
    for i in range(threadN):
         t = threading.Thread(target=worker)
         t.daemon = True  # thread dies when main thread (only non-daemon thread) exits.
         t.start()


    #passo = 0
    #pip = 0
    #ilPasso = un tot minore di numeroVolte

    for volta in range(numeroVolte):
        # se scommenti qui anche le due righe sopra ed
        #passo += 1
        #if passo == ilPasso:
            #pip +=1
            #passo = 0
            #print('++++', pip)

        laVoce = randint(0, numeroVoci -1)
        cheFaccio = randint(0, 9)
        q.put((laVoce, cheFaccio))
        q.join()       # block until all tasks are done


for div in range(8):
    startTick //= 2
    sys.setcheckinterval(startTick)

    dDic = dict()
    dizio = dict()

    provaCombinazioni()

    start = time.perf_counter()
    print("sys.setcheckinterval(startTick):", sys.getcheckinterval(),'time:',time.perf_counter() - start)

    for j in range(numeroVoci):
        for jj in dizio[j].oldCarica:
            if "ente" in jj[3]:
                print(jj)
            if "Try" in jj[3]:
                print(jj)
            if "dev" in jj[3]:
                print(jj)