如何使每个线程的全局计数器增量？

Question

I am trying to make a python file that will increment a global counter by 5 for every time a thread is started. My goal is to have 4 threads increment the counter by 5 and the end result is 20. Here is the code I have so far:

    import threading
    import time
    global counter
    counter =0
    class MyThread(threading.Thread):
        counter = counter
        def __init__(self, name, delay, counter=0):
            threading.Thread.__init__(self)
            self.name = name
            self.delay = delay
            self.counter = counter

        def run(self):
    
            print('Starting thread %s...'% self.name)
            self.thread_lock.acquire()
            self.thread_lock.release()
            print('Finished thread %s...'% self.name)


        thread_lock = threading.Lock()

    thread1 = MyThread('A', 0.1)
    thread2 = MyThread('B', 0.1)
    thread3 = MyThread('C', 0.1)
    thread4 = MyThread('D', 0.1)

    thread1.start()
    thread2.start()
    thread3.start()
    thread4.start()

    thread1.join()
    thread2.join()
    thread3.join()
    thread4.join()

Answer 1

You could use a counter class and a (locking) function that increases the value:

import threading
import time

lock = threading.Lock()


class Counter:
    def __init__(self, initial_count):
        self.value = initial_count


def add(counter, name, delay, value):
    with lock:
        msg = f"{name} is sleeping for {delay} seconds, before increasing {counter.value} by {value}"
        print(msg)
        time.sleep(x)
        counter.value = counter.value + value


counter = Counter(0)
increasingValue = 5

_threads = []
for x in range(4):
    th = threading.Thread(
        target=add, args=(counter, f"thread_{x}", x, increasingValue)
    )
    _threads.append(th)
    th.start()
    [t.join() for t in _threads]

print('>', counter.value)

Out:

thread_0 is sleeping for 0 seconds, before increasing 0 by 5
thread_1 is sleeping for 1 seconds, before increasing 5 by 5
thread_2 is sleeping for 2 seconds, before increasing 10 by 5
thread_3 is sleeping for 3 seconds, before increasing 15 by 5
> 20

Answer 2

You have many counter variables in your program

counter =0

creates one in the global namespace

class MyThread(threading.Thread):
    counter = counter

creates another in the class namespace

    def __init__(self, name, delay, counter=0):
        ...
        self.counter = counter

creates one in each instance of your thread class. And you don't actually increment any of them.

If you really want a single global counter, use the global keyword in the method that increments it. global tells a function that a variable should be resolved in the global namespace, not the local function namespace. Its completely unneeded at the module level, you can't unilaterally declare a variable global. You can only tell specific functions how to treat the variable.

import threading
import time

counter =0
class MyThread(threading.Thread):

    def __init__(self, name, delay, counter=0):
        threading.Thread.__init__(self)
        self.name = name
        self.delay = delay

    def run(self):
        global counter    
        print('Starting thread %s...'% self.name)
        self.thread_lock.acquire()
        counter += 5
        self.thread_lock.release()
        print('Finished thread %s...'% self.name)


    thread_lock = threading.Lock()

thread1 = MyThread('A', 0.1)
thread2 = MyThread('B', 0.1)
thread3 = MyThread('C', 0.1)
thread4 = MyThread('D', 0.1)

thread1.start()
thread2.start()
thread3.start()
thread4.start()

thread1.join()
thread2.join()
thread3.join()
thread4.join()

print(counter)