运行线程时Python数据丢失

Question

I have two versions of the same program with the same task, one that utilizes the threading module while the other doesn't. The task I want to optimize is the following

from random import randint
import time

t = time.time()

rolls = 25000
wins = 0
loss = 0

while rolls > 0:
    dice1 = randint(1, 6)
    dice2 = randint(1, 6)

    if dice1+dice2 == 11 or dice1+dice2 == 7 or dice1 == dice2:
        wins += 1
    else:
        loss += 1

    rolls -= 1

print(wins+loss)
percentage = (wins / wins+loss) * 100

print("Calculated percentage of a roll fulfilling requirements are:", 
round(percentage, 2), "%")
print(round((time.time()-t), 3))

As you can hopefully tell I basically want to roll two dices a certain amount of times, in this example that number is 25 000 and then print out what the chance that these two dice fulfill one of the three criteria, sum is 11, sum is 7 or they both have the same number.

Of course the amount of rolls I decide to go with alters the outcome of this program by giving a more accurate answer the higher you go. All well and good up until this point, program working as expected and the sum of wins and loss is equal to total amount of rolls.

What bothers me is the threaded version of the program. When I enter say, 25 000 rolls there too I end up with the sum of around 22 000 for wins + loss (this sum varies from run to run, why are there rolls disappearing?) Another side effect from running the threaded version is a less accurate calculation of the win percentage.

from random import randint
import threading
import time

t = time.time()

def dice_calc(rolls):
    global wins
    global loss
    while rolls > 0:

        dice1 = randint(1, 6)
        dice2 = randint(1, 6)

        if dice1+dice2 == 11 or dice1+dice2 == 7 or dice1 == dice2:
            wins += 1
        else:
            loss += 1

        rolls -= 1

wins = 0
loss = 0
rolls = 25000

t1 = threading.Thread(target=dice_calc, args=(rolls/4,))
t2 = threading.Thread(target=dice_calc, args=(rolls/4,))
t3 = threading.Thread(target=dice_calc, args=(rolls/4,))
t4 = threading.Thread(target=dice_calc, args=(rolls/4,))

t1.start()
t2.start()
t3.start()
t4.start()

print(wins+loss)

t1.join()
t2.join()
t3.join()
t4.join()

percentage = (wins / (wins+loss)) * 100

print("Calculated percentage of a roll fulfilling requirements are:", 
round(percentage, 2), "%")

print(round((time.time()-t), 3))

My aim with using this threading module was to increase the programs accuracy while taking up less processing time. I have managed to do the exact opposite.

How is this possible and what can I do to fix it?

Answer 1

def dice_calc(rolls):

    mutex.acquire() #Since you are using global variables you need to lock the code before the thread has access to the global

    global wins
    global loss
    while rolls > 0:

        dice1 = randint(1, 6)
        dice2 = randint(1, 6)

        if dice1+dice2 == 11 or dice1+dice2 == 7 or dice1 == dice2:
            wins += 1
        else:
            loss += 1

        rolls -= 1

    mutex.release() #Then you release it when it is finished

You need to lock the code before the thread has access to the global, then you release it after it is done processing.

A good analogy:

You and three friends want a drink out of the water fountain, you each need to wait your turn to use it before you are able to take a drink. If you each go at the same time it will get messy because there is only one water fountain. The water fountain are your global variables and code, you and your friends are the threads