दिलचस्प पोस्ट
अतुल्यकालिक जावास्क्रिप्ट निष्पादन कैसे होता है? और जब रिटर्न स्टेटमेंट का उपयोग नहीं करते हैं? हाइबरनेट में बायपास जनरेटेड वैल्यू (डेटा को डीबी में नहीं मिलाएं?) रूबी में "मुख्य" क्या है? नरम कीबोर्ड से रोकें बटन मैं एंड्रॉइड डिवाइस से एपीके फाइल कैसे प्राप्त करूं? स्थिर स्मृति आवंटन और गतिशील स्मृति आवंटन के बीच का अंतर कैसे एक सरणी में स्ट्रिंग के लिए खोज करने के लिए मानक आरंभक पर्वतमाला की बजाय क्यों हैं? जे 2 एमई / एंड्रॉइड / ब्लैकबेरी – ड्राइविंग दिशानिर्देश, दो स्थानों के बीच मार्ग एंड्रॉइड में एक फाइल कैसे बनाएं? प्रारंभिक सूची के लाभ एक्सएमएल – रूट पर डेटा अमान्य है पैगमेम में एक प्लेटफॉर्म पर स्क्रॉल करना जोड़ें मैं Google ऐप इंजन के साथ तीसरे पक्ष के पायथन पुस्तकालयों का प्रबंधन कैसे करूं? (वर्चुअलव्यू? पीप?) shouldAutorotateToInterfaceOrientation आईओएस 6 में काम नहीं कर रहा है

जावा थ्रेड में मैं एक पैरामीटर कैसे पास कर सकता हूं?

क्या कोई मुझे सुझाव दे सकता है कि मैं एक पैरामीटर को किसी धागे में कैसे पास कर सकता हूं?

इसके अलावा, अनाम वर्गों के लिए यह कैसे काम करता है?

वेब के समाधान से एकत्रित समाधान "जावा थ्रेड में मैं एक पैरामीटर कैसे पास कर सकता हूं?"

आपको थ्रेड ऑब्जेक्ट के लिए कंस्ट्रक्टर में पैरामीटर पास करना होगा:

public class MyThread implements Runnable { public MyThread(Object parameter) { // store parameter for later user } public void run() { } } 

और इसे इस प्रकार लागू करें:

 Runnable r = new MyThread(param_value); new Thread(r).start(); 

अनाम वर्गों के लिए:

प्रश्नों के जवाब के जवाब में यहां बताया गया है कि यह बेनामी कक्षाओं के लिए कैसे काम करता है

  final X parameter = ...; // the final is important Thread t = new Thread(new Runnable() { p = parameter; public void run() { ... }; t.start(); 

नामांकित कक्षाएं:

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

 Thread t = new MyThread(args...); t.start(); 

रनयबल थ्रेड BTW की तुलना में एक बेहतर समाधान है तो मैं चाहता हूं:

  public class MyRunnable implements Runnable { private X parameter; public MyRunnable(X parameter) { this.parameter = parameter; } public void run() { } } Thread t = new Thread(new MyRunnable(parameter)); t.start(); 

यह उत्तर मूल रूप से इस समान प्रश्न के समान है: थ्रेड ऑब्जेक्ट के लिए पैरामीटर कैसे निकालता है

एक रननबल या थ्रेड क्लास के निर्माता के माध्यम से

 class MyThread extends Thread { private String to; public MyThread(String to) { this.to = to; } @Override public void run() { System.out.println("hello " + to); } } public static void main(String[] args) { new MyThread("world!").start(); } 

जब आप कोई थ्रेड बनाते हैं, तो आपको Runnable का एक उदाहरण चाहिए। एक पैरामीटर में पारित करने का सबसे आसान तरीका इसे कन्स्ट्रक्टर को एक तर्क के रूप में देना होगा:

 public class MyRunnable implements Runnable { private volatile String myParam; public MyRunnable(String myParam){ this.myParam = myParam; ... } public void run(){ // do something with myParam here ... } } MyRunnable myRunnable = new myRunnable("Hello World"); new Thread(myRunnable).start(); 

यदि आप थ्रेड चलते समय पैरामीटर बदलना चाहते हैं, तो आप बस अपने रननेबल क्लास में एक सेटर विधि जोड़ सकते हैं:

 public void setMyParam(String value){ this.myParam = value; } 

आपके पास यह एक बार, आप इस तरह से कॉल करके पैरामीटर का मान बदल सकते हैं:

 myRunnable.setMyParam("Goodbye World"); 

बेशक, यदि आप पैरामीटर बदलते हैं, तो आप को एक ट्रिगर करना चाहते हैं, तो आपको ताले का उपयोग करना होगा, जिससे चीजें काफी जटिल हो सकती हैं।

एक धागा बनाने के लिए जो आप सामान्य रूप से रनयबल के अपना स्वयं का कार्यान्वयन करते हैं। इस वर्ग के निर्माता में धागे के पैरामीटर को पास करें।

 class MyThread implements Runnable{ private int a; private String b; private double c; public MyThread(int a, String b, double c){ this.a = a; this.b = b; this.c = c; } public void run(){ doSomething(a, b, c); } } 

आप या तो Thread class या Runnable class विस्तार कर सकते हैं और पैरामीटर प्रदान कर सकते हैं जैसे आप चाहते हैं। डॉक्स में सरल उदाहरण हैं मैं उन्हें यहां बंद कर दूंगा:

  class PrimeThread extends Thread { long minPrime; PrimeThread(long minPrime) { this.minPrime = minPrime; } public void run() { // compute primes larger than minPrime . . . } } PrimeThread p = new PrimeThread(143); p.start(); class PrimeRun implements Runnable { long minPrime; PrimeRun(long minPrime) { this.minPrime = minPrime; } public void run() { // compute primes larger than minPrime . . . } } PrimeRun p = new PrimeRun(143); new Thread(p).start(); 

यह उत्तर बहुत देर से आता है, लेकिन शायद किसी को यह उपयोगी मिलेगा। यह बिना किसी निर्दिष्ट पैरामीटर (इनलाइनर्स के लिए आसान) को घोषित करने के बिना एक पैनरेम को कैसे चलाया जा सकता है:

 String someValue = "Just a demo, really..."; new Thread(new Runnable() { private String myParam; public Runnable init(String myParam) { this.myParam = myParam; return this; } @Override public void run() { System.out.println("This is called from another thread."); System.out.println(this.myParam); } }.init(someValue)).start(); 

बेशक, आप कुछ और सुविधाजनक या उपयुक्त पल की start निष्पादन को स्थगित कर सकते हैं। और यह आपके लिए निर्भर है कि init पद्धति के हस्ताक्षर क्या होंगे (इसलिए इसमें अधिक और / या भिन्न तर्क हो सकते हैं) और निश्चित रूप से इसका नाम भी है, लेकिन मूलतः आपको एक विचार मिलता है।

वास्तव में प्रारंभिक ब्लॉकों के उपयोग के साथ एक गुमनाम वर्ग के पैरामीटर को पारित करने का दूसरा तरीका भी है। इस पर विचार करो:

 String someValue = "Another demo, no serious thing..."; int anotherValue = 42; new Thread(new Runnable() { private String myParam; private int myOtherParam; { this.myParam = someValue; this.myOtherParam = anotherValue; } @Override public void run() { System.out.println("This comes from another thread."); System.out.println(this.myParam + ", " + this.myOtherParam); } }).start(); 

तो सब कुछ प्रारंभिक ब्लॉक के अंदर होता है।

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

आप रननाबल से एक वर्ग प्राप्त कर सकते हैं, और निर्माण के दौरान (कहना) पैरामीटर में पास कर सकते हैं।

तब थ्रेड.चार्ट (रननेबल आर) का उपयोग करके इसे लॉन्च करें;

अगर आपका मतलब है कि धागा चल रहा है, तो बस कॉलिंग धागे में अपने व्युत्पन्न वस्तु का एक संदर्भ पकड़ कर, और उचित सेटर विधियों (जहां उपयुक्त हो वहां सिंक्रनाइज़ करना) कहें।

प्रारंभ () और रन () विधियों के माध्यम से पैरामीटर गुजर रहा है:

 // Tester public static void main(String... args) throws Exception { ThreadType2 t = new ThreadType2(new RunnableType2(){ public void run(Object object) { System.out.println("Parameter="+object); }}); t.start("the parameter"); } // New class 1 of 2 public class ThreadType2 { final private Thread thread; private Object objectIn = null; ThreadType2(final RunnableType2 runnableType2) { thread = new Thread(new Runnable() { public void run() { runnableType2.run(objectIn); }}); } public void start(final Object object) { this.objectIn = object; thread.start(); } // If you want to do things like setDaemon(true); public Thread getThread() { return thread; } } // New class 2 of 2 public interface RunnableType2 { public void run(Object object); } 

रननबल्स में मापदंडों को पारित करने का एक सरल तरीका है कोड:

 public void Function(final type variable) { Runnable runnable = new Runnable() { public void run() { //Code adding here... } }; new Thread(runnable).start(); } 

एक और विकल्प; यह दृष्टिकोण आपको रननेबल आइटम का उपयोग करने देता है जैसे एसिंक्रोनस फ़ंक्शन कॉल। यदि आपके कार्य को नतीजे वापस करने की ज़रूरत नहीं है, उदाहरण के लिए, यह कुछ कार्य करता है, आपको चिंता करने की ज़रूरत नहीं है कि आप "परिणाम" कैसे वापस करते हैं।

यह पैटर्न आपको किसी आइटम का पुन: उपयोग करने देता है, जहां आपको किसी प्रकार की आंतरिक स्थिति की आवश्यकता होती है। पैरामीटर (पैरामीटर) पर पैरामीटर (पैरामीटर) तक पहुंचने के लिए मध्यस्थ होने के लिए कंस्ट्रक्टर की देखभाल में नहीं होने पर यदि आपके उपयोग-मामले में अलग-अलग कॉलर शामिल हैं, तो आपको अधिक जांच की आवश्यकता हो सकती है।

 public class MyRunnable implements Runnable { private final Boolean PARAMETER_LOCK = false; private X parameter; public MyRunnable(X parameter) { this.parameter = parameter; } public void setParameter( final X newParameter ){ boolean done = false; synchronize( PARAMETER_LOCK ) { if( null == parameter ) { parameter = newParameter; done = true; } } if( ! done ) { throw new RuntimeException("MyRunnable - Parameter not cleared." ); } } public void clearParameter(){ synchronize( PARAMETER_LOCK ) { parameter = null; } } public void run() { X localParameter; synchronize( PARAMETER_LOCK ) { localParameter = parameter; } if( null != localParameter ) { clearParameter(); //-- could clear now, or later, or not at all ... doSomeStuff( localParameter ); } } 

}

धागा टी = नया थ्रेड (नया MyRunnable (पैरामीटर)); t.start ();

यदि आपको प्रसंस्करण के परिणाम की आवश्यकता है, उप-कार्य समाप्त होने पर आपको MyRunnable के पूरा समन्वय करने की आवश्यकता होगी। आप कॉल वापस पास कर सकते हैं या बस थ्रेड 'टी' आदि पर प्रतीक्षा कर सकते हैं।

विशेषकर एंड्रॉइड के लिए

कॉलबैक प्रयोजनों के लिए मैं आम तौर पर अपने सामान्य जेनरिक Runnable को इनपुट पैरामीटर (एस) के साथ लागू करता हूं:

 public interface Runnable<TResult> { void run(TResult result); } 

उपयोग सरल है:

 myManager.doCallbackOperation(new Runnable<MyResult>() { @Override public void run(MyResult result) { // do something with the result } }); 

प्रबंधक में:

 public void doCallbackOperation(Runnable<MyResult> runnable) { new AsyncTask<Void, Void, MyResult>() { @Override protected MyResult doInBackground(Void... params) { // do background operation return new MyResult(); // return resulting object } @Override protected void onPostExecute(MyResult result) { // execute runnable passing the result when operation has finished runnable.run(result); } }.execute(); } 

नहीं, आप run() विधि को पैरामीटर नहीं दे सकते। हस्ताक्षर आपको बताता है कि (इसका कोई पैरामीटर नहीं है)। संभवत: ऐसा करने का सबसे आसान तरीका उद्देश्य-निर्मित ऑब्जेक्ट का उपयोग करना होगा जो कंस्ट्रक्टर में एक पैरामीटर लेता है और इसे अंतिम वैरिएबल में संग्रहीत करता है:

 public class WorkingTask implements Runnable { private final Object toWorkWith; public WorkingTask(Object workOnMe) { toWorkWith = workOnMe; } public void run() { //do work } } //... Thread t = new Thread(new WorkingTask(theData)); t.start(); 

एक बार जब आप ऐसा करते हैं – आपको 'वर्किंगटस्क' में आने वाले वस्तु की डेटा अखंडता के बारे में सावधान रहना होगा डेटा अब दो अलग-अलग धागे में मौजूद होगा ताकि आपको यह सुनिश्चित करना पड़े कि यह थ्रेड सुरक्षित है।

जावा 8 के अनुसार, आप प्रभावी ढंग से अंतिम पैरामीटर प्राप्त करने के लिए लैम्ब्डा का उपयोग कर सकते हैं। उदाहरण के लिए:

 final String param1 = "First param"; final int param2 = 2; new Thread(() -> { // Do whatever you want here: param1 and param2 are in-scope! System.out.println(param1); System.out.println(param2); }).start();