हाय मुझे 2 धागे बनाने की ज़रूरत है जो बार-बार दिन के समय को एचएच: एमएम: एसएस स्ट्रिंग के रूप में प्रति सेकंड 100 बार वैश्विक चर में लिखता है। दूसरा धागा बार-बार उस चर से दिन की स्ट्रिंग के समय को प्रति सेकंड दो बार पढ़ेगा और इसे स्क्रीन पर प्रदर्शित करने का प्रयास करेगा लेकिन उस थ्रेड में कोड को यह सुनिश्चित करना चाहिए कि एक ही स्ट्रिंग एक पंक्ति में दो बार कभी नहीं लिखी जाती है। नतीजा यह है कि दूसरा धागा वास्तव में प्रति सेकंड केवल एक बार स्क्रीन पर प्रदर्शित होता है। मैंने कोड का पालन करने की कोशिश की है लेकिन यह काम नहीं कर रहा है

    import threading
    import time
    c = threading.Condition()
    flag = 0      #shared between Thread_A and Thread_B
    val = ''

class Thread_A(threading.Thread):
    def __init__(self, name):
        threading.Thread.__init__(self)
        self.name = name

    def run(self):
        global flag
        global val     #made global here
        while True:
            c.acquire()
            if flag == 0:
                time.sleep(0)
                flag = 1
                a=range(1,101)
                for i in a:
                    val=time.strftime("%H:%M:%S", time.localtime(time.time()))
                c.notify_all()
            else:
                c.wait()
            c.release()


class Thread_B(threading.Thread):
    def __init__(self, name):
        threading.Thread.__init__(self)
        self.name = name

    def run(self):
        global flag
        global val    #made global here
        while True:
            c.acquire()
            if flag == 1:
                #time.sleep(1)
                flag = 0
                a=range(0,2)
                for i in a:
                    print str(val)
                #val = 20
                c.notify_all()
            else:
                c.wait()
            c.release()


a = Thread_A("myThread_name_A")
b = Thread_B("myThread_name_B")

b.start()
a.start()

a.join()
b.join()
0
Jeff 27 नवम्बर 2017, 17:31

1 उत्तर

सबसे बढ़िया उत्तर

आप इसे जरूरत से ज्यादा जटिल बना रहे हैं। आप यह सुनिश्चित करने के लिए एक साधारण Lock ऑब्जेक्ट का उपयोग कर सकते हैं कि एक समय में केवल एक थ्रेड val तक पहुंच सकता है।

नीचे दिया गया कोड Python 2 या Python 3 पर चलेगा। इसे रोकने के लिए, Enter दबाएं

import time
from threading import Thread, Lock

# Rename Python 2's raw_input to input
try:
    input = raw_input
except NameError:
    pass

val = ''
lock = Lock()

def set_time(delay=0.01):
    ''' Write the current time to val '''
    global val
    while True:
        lock.acquire()
        val = time.strftime("%H:%M:%S")
        lock.release()
        time.sleep(delay)

def get_time(delay=0.5):
    ''' Read the current time from val and print
        it if it hasn't been printed already 
    '''
    oldval = ''
    while True:
        lock.acquire()
        if val != oldval:
            print(val)
            oldval = val
        lock.release()
        time.sleep(delay)

# Start the threads
for func in (set_time, get_time):
    t = Thread(target=func)
    t.setDaemon(True)
    t.start()

#Wait until we get some input
s = input()

कुछ सामान्य आउटपुट

02:22:04
02:22:05
02:22:06
02:22:07
02:22:08
1
PM 2Ring 27 नवम्बर 2017, 18:22