स्टैटिक हेल्पर विधि

Question

पर ऑब्जेक्ट संदर्भ पास करने वाले एकाधिक थ्रेड्स मैं जावा में बस शुरुआत कर रहा हूं और बहु-थ्रेडेड अनुप्रयोगों पर ठोकर खा रहा हूं। मुझे पता है कि यह प्रश्न यहां कुछ पोस्ट के समान है लेकिन मुझे अपनी क्वेरी के लिए बेहतर उत्तर नहीं मिला। असल में, मैं किसी ऑब्जेक्ट को एक स्थिर विधि में पास करना चाहता हूं और विधि ऑब्जेक्ट के मानों/गुणों के आधार पर केवल आउटपुट लौटाएगी। प्रत्येक कॉल के लिए, मैं ऑब्जेक्ट का एक नया उदाहरण बना रहा हूं और इस तरीके के अंदर ऑब्जेक्ट को संशोधित करने का कोई मौका नहीं है। अब, मेरा सवाल यह है कि, क्या JVM कई थ्रेड द्वारा प्रत्येक कॉल के लिए स्टैक में स्थिर विधि और उसके स्थानीय चर का एक नया उदाहरण बना देगा (ऑब्जेक्ट को छोड़कर यह ढेर पर होगा)? मैं क्या हासिल करना चाहते का एक स्पष्ट विचार के लिए, यहाँ मेरी कोड है:

TestConcurrent.java

import classes.Player; 

public class TestConcurrent 
{ 
    private static int method(Player player) 
    { 
     int y = (player.getPoints() * 10) + 1; 

      try { 
        Thread.sleep(1000); 
      } catch (InterruptedException e) {} 

      return ++y; 
    } 

    public static void main(String[] args) throws Exception 
    { 
     // Create 100 threads 
     for(int i=1;i<=100;i++) 
     { 
      final int j = i; 
      // Create a new Thread 
      new Thread() 
      { 
       public void run() 
       { 
        // Create a new instance of the Player class 
        Player player = new Player(j,j,"FirstName" + j, "LastName" + j); 
        // Call static method() and pass a new instance of Player class 
        System.out.println("Thread " + j + ": " + TestConcurrent.method(player)); 
        // Check the values of the Player class after the call to the static method() 
        System.out.println("Player" + player.getAcctId() + " : Points=" + player.getPoints() + " Name=" + player.getFirstName() + " " + player.getLastName()); 
       } 
      }.start(); 
     } 
    } 

} 

Player.java

package classes; 

public class Player 
{ 
    private int acctId, points; 
    String firstName, lastName; 

    public Player(int acctId, int points, String firstName, String lastName) 
    { 
     this.acctId = acctId; 
     this.points = points; 
     this.firstName = firstName; 
     this.lastName = lastName; 
    } 

    public int getAcctId() { 
     return acctId; 
    } 
    public void setAcctId(int acctId) { 
     this.acctId = acctId; 
    } 
    public int getPoints() { 
     return points; 
    } 
    public void setPoints(int points) { 
     this.points = points; 
    } 
    public String getFirstName() { 
     return firstName; 
    } 
    public void setFirstName(String firstName) { 
     this.firstName = firstName; 
    } 
    public String getLastName() { 
     return lastName; 
    } 
    public void setLastName(String lastName) { 
     this.lastName = lastName; 
    } 
} 

उत्पादन:

चूंकि मैंने सिंक्रनाइज़ किए गए कीवर्ड को नहीं रखा है, वें ई आउटपुट हर बार अलग होगा और यह निम्न के जैसा दिखता है: (आउटपुट सही है और यह वही है जो मैं उम्मीद कर रहा हूं, मैं सिर्फ यह स्पष्ट करना चाहता हूं कि मैं सही रास्ते पर हूं क्योंकि मैं सिंक्रनाइज़ेशन का उपयोग नहीं करना चाहता इसे नीचे प्रक्रिया धीमी हो जाएगी क्योंकि प्रत्येक धागा खत्म करने के लिए अन्य थ्रेड के लिए प्रतीक्षा करने के लिए इससे पहले कि यह स्थिर विधि कॉल कर सकते हैं होगा)

Thread 2: 22 
Player8 : Points=8 Name=FirstName8 LastName8 
Thread 22: 222 
Thread 26: 262 
Thread 23: 232 
Player23 : Points=23 Name=FirstName23 LastName23 
Thread 21: 212 
Player21 : Points=21 Name=FirstName21 LastName21 
Thread 25: 252 
Player25 : Points=25 Name=FirstName25 LastName25 
Thread 20: 202 
Thread 19: 192 
Thread 24: 242 
Player24 : Points=24 Name=FirstName24 LastName24 
Player9 : Points=9 Name=FirstName9 LastName9 
Thread 28: 282 

Answer 1

स्थिर विधि और उसके स्थानीय का एक नया उदाहरण बनाने JVM होगा कई थ्रेड द्वारा प्रत्येक कॉल के लिए स्टैक में चर (ऑब्जेक्ट को छोड़कर यह ढेर पर होगा)?

हाँ, यह बिल्कुल सही है।

यदि एक स्थिर विधि केवल स्थानीय चर को संदर्भित करती है, तो यह स्वचालित रूप से थ्रेड सुरक्षित है। (वास्तव में, यह गैर स्थैतिक तरीकों के लिए भी है।)

आम तौर पर हालांकि, मैं कहूंगा कि यदि संभव हो तो आपको static से बचना चाहिए। आम तौर पर यह इस तथ्य के कारण कोड को कठिन और कारण बनाने के लिए कठिन बनाता है कि स्थिर सदस्य वैश्विक रूप से एक अर्थ में हैं।

Answer 2

static विधियां कोई समस्या नहीं है, केवल static चर धागे भर में साझा किए जाएंगे।

तो दो धागे

public static int sum(int a, int b) { 
    int tmp = a + b; 
    return tmp; 
} 

लागू समस्याओं में नहीं चलेंगे।

static int tmp; 

public static int sum(int a, int b) { 
    tmp = a + b; 
    return tmp; 
} 

, मल्टी-थ्रेडेड असफल क्योंकि एक धागा दूसरे के ऊपर लिख सकता है tmp मूल्य होगा।

स्थानीय चर, यहां तक ​​कि static विधियों में भी स्थानीय और इस प्रकार सुरक्षित हैं।

static विधियों का उपयोग करना अच्छा है। यह हाइलाइट करता है कि विधि को ऑब्जेक्ट चरों तक पहुंच की आवश्यकता नहीं है।static गैर-निरंतर चर का उपयोग त्रुटियों से ग्रस्त है, इसे हर कीमत से बचें (और चर को एक्सेस करने की आवश्यकता होने पर निरंतर सिंक्रनाइज़ेशन का उपयोग करें)।