इसे वैश्विक बनाने के बिना थ्रेड वैरिएबल साझा करना (पर्ल)

Question

मैं एक साधारण स्क्रिप्ट लिखने की कोशिश कर रहा हूं जो धागे का उपयोग करता है और एक चर साझा करता है, लेकिन मैं इस वैरिएबल ग्लोबल को पूरी स्क्रिप्ट में नहीं बनाना चाहता हूं। नीचे एक सरलीकृत उदाहरण है।

use strict; 
use warnings; 
use threads; 
use threads::shared; 

my $val:shared; 

# Create threads 
for my $i (1 .. 5) { 
    threads->create(\&do_something, $i); 
} 

# Wait for all threads to complete 
map { $_->join(); } threads->list(); 

# $val is global to the script so this line will work! 
print "VAL IS: $val\n"; 

sub do_something { 
    my $i = shift; 
    print "Doing something with thread $i!\n"; 

    { 
     lock $val; 
     $val = "SOMETHING IS $i"; 
     print "$val\n\n"; 
    } 
} 

आउटपुट:

धागा 1 साथ कुछ कर! कुछ है 1

थ्रेड 2 के साथ कुछ करना! कुछ है 2

थ्रेड 3 के साथ कुछ करना! कुछ है 3

धागे 4 के साथ कुछ करना! कुछ है 4

धागे 5 के साथ कुछ करना! कुछ 5

है VAL है: कुछ 5

---

मैं $val पूरी स्क्रिप्ट के लिए सुलभ बनाने के बिना इस आशय कैसे प्राप्त कर सकता है? दूसरे शब्दों में, मैं इसे VAL IS: $val प्रिंट करने का प्रयास कैसे कर सकता हूं, असफल हो जाएगा, लेकिन चर को अभी भी धागे द्वारा सफलतापूर्वक साझा किया जाएगा?

---

मैं इसे इस तरह से परिभाषित नहीं कर सकते हैं:

# Create threads 
for my $i (1 .. 5) { 
    my $val:shared; 
    threads->create(\&do_something, $i); 
} 

या मैं मिल जाएगा:

वैश्विक प्रतीक "$ वैल" की आवश्यकता है स्पष्ट पैकेज

किसी साझा चर को स्पष्ट रूप से गुंजाइश करने का सही तरीका क्या है?

Answer 1

इसे एक तर्क के रूप में संदर्भित करें।

sub do_something { 
    my ($id, $lock_ref) = @_; 
    print("$id: Started\n"); 
    { 
     lock $$lock_ref; 
     print("$id: Exclusive\n"); 
     sleep(1); 
    } 
    print("$id: done.\n"); 
} 

{ 
    my $lock :shared; 
    for my $id (1..5) { 
     async { do_something($id, \$lock); }; 
    } 
} 

या इसे स्कॉप करें ताकि केवल कार्यकर्ता इसे देख सकें।

{ 
    my $lock :shared; 

    sub do_something { 
     my ($id) = @_; 
     print("$id: Started\n"); 
     { 
     lock $lock; 
     print("$id: Exclusive\n"); 
     sleep(1); 
     } 
     print("$id: done.\n"); 
    } 
} 

for my $id (1..5) { 
    async { do_something($id); }; 
} 

Answer 2

आप (सुनिश्चित करें कि पर्ल धागा निर्माण से पहले साझा चर न देखे) साझा चर का दायरा सीमित कर सकते हैं,

# .. 
{ 
    my $val:shared; 
    sub do_something { 
     my $i = shift; 
     print "Doing something with thread $i!\n"; 

     { 
      lock $val; 
      $val = "SOMETHING IS $i"; 
      print "$val\n\n"; 
     } 
    } 
} 

# Create threads 
for my $i (1 .. 5) { 
    threads->create(\&do_something, $i); 
} 

# ...