जावा में निष्पादक सेवा -> निष्पादक का उपयोग करने के लिए सिंगल थ्रेड कोड को कैसे परिवर्तित करें

Question

अगर मुझे मूर्खतापूर्ण लगता है तो मुझे क्षमा करें - मैं अभी निष्पादक का उपयोग करना शुरू कर रहा हूं।

मैं समारोह के लिए एक नया धागा देता है, इस में धागे का उपयोग करता है एक मौजूदा जावा एप्लिकेशन manner-- मूल रूप से स्टैंडअलोन धागे

private Thread spawnThread() 
    { 

     Thread t = new Thread() 
     { 
      String taskSnap = task.toString(); 
      public void run() 
      { 
       try 
       { 
        println(task.run(null)); 
       }catch(InterruptedException e) 
       { 
        println("ITC - " + taskSnap + " interrupted "); 
       } 
      } 
     }; 
     return t; 
    } 

used-- कर रहे हैं आप ऊपर से देख सकते हैं की है।

अब कार्यक्रम का मुख्य() फ़ंक्शन में, एक नया धागा इस manner--

taskThread = spawnThread(); 

    taskThread.start(); 

क्या मुझे क्या करना है, एक प्रबंधक सेवा बनाने चाहते हैं (धागे की निश्चित संख्या के साथ) बनाई गई है -> और उसके बाद उस नए निष्पादक को नए धागे द्वारा कार्य के नए धागे/निष्पादन के निर्माण को बंद कर दें।

जैसा कि मैं निष्पादक के लिए बहुत नया हूं, मैं क्या जानना चाहता हूं, मैं उपरोक्त कोड कैसे बदलूं ताकि एक नए अलग थ्रेड के गठन के बजाय, थ्रेड पूल के भीतर एक नया धागा बनाया जाए। मैं थ्रेड (थ्रेड पूल के भीतर) बनाने के लिए कोई कमांड नहीं देख सकता -> उपर्युक्त कार्य को उस थ्रेड पर हाथ से हटाएं (और उपरोक्त स्टैंड-अलोन थ्रेड पर नहीं)।

कृपया मुझे बताएं कि इस समस्या को कैसे हल किया जाए।

ExecutorService executor = Executors.newFixedThreadPool(nThreads); 
executor.submit(new Runnable() { 
    String taskSnap = task.toString(); 
    public void run() { 
      try { 
       println(task.run(null)); 
      } catch(InterruptedException e) { 
       println("ITC - " + taskSnap + " interrupted "); 
      } 
    } 
}); 

प्रस्तुत विधि प्रबंधक सेवा के भीतर धागे में से एक पर Runnable निष्पादित करेंगे:

Answer 1

अपने मुख्य में, आप कुछ इस तरह लिख सकते हैं।

नोट: जब आपको इसकी आवश्यकता नहीं होती है तो निष्पादक सेवा को बंद करना न भूलें या यह आपके प्रोग्राम को बाहर निकलने से रोक देगा।

Answer 2

पूछने से पहले अपने शोध करें। विचार एक वर्ग बनाना है जो रननेबल लागू करता है और निष्पादक सेवा का उपयोग करके इसे निष्पादित करता है।

उदाहरण से: Java Concurrency (Multithreading) - Tutorial

कार्यकर्ता का कार्यान्वयन (जो Runnable लागू करता है):

package de.vogella.concurrency.threadpools; 

/** * MyRunnable will count the sum of the number from 1 to the parameter * countUntil and then write the result to the console. * <p> * MyRunnable is the task which will be performed * * @author Lars Vogel * */ 

public class MyRunnable implements Runnable { 
    private final long countUntil; 

    MyRunnable(long countUntil) { 
    this.countUntil = countUntil; 
    } 

    @Override 
    public void run() { 
    long sum = 0; 
    for (long i = 1; i < countUntil; i++) { 
     sum += i; 
    } 
    System.out.println(sum); 
    } 
} 

कार्यकर्ता धागा को गति प्रदान चलाने के लिए निष्पादक सेवा का उपयोग कैसे करें।

package de.vogella.concurrency.threadpools; 

import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 

public class Main { 
    private static final int NTHREDS = 10; 

    public static void main(String[] args) { 
    //You can also use Executors.newSingleThreadExecutor() if you just need 1 thread 
    ExecutorService executor = Executors.newFixedThreadPool(NTHREDS); 
    for (int i = 0; i < 500; i++) { 
     Runnable worker = new MyRunnable(10000000L + i); 
     executor.execute(worker); 
    } 
    // This will make the executor accept no new threads 
    // and finish all existing threads in the queue. 
    executor.shutdown(); 
    // Wait until all threads are finish 
    //while (!executor.isTerminated()) { 
    //} 
    //System.out.println("Finished all threads"); 
    //All the threads might not be finished at this point of time. Thread endtime purely depends on the time taken by the processing logic inside your thread. 
    } 
} 

Answer 3

आपका मतलब कुछ ऐसा है?

class Parallel { 
    private ExecutorService pool = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors()); 

    public void shutdown() { 
     pool.shutdown(); 
    } 

    public void foo() { 
     pool.submit(new Runnable() { 
      @Override 
      public void run() { 
       // put your code here 
      } 
     }); 
    } 
}