আমি জাভাতে একাধিক থ্রেড সহ গাণিতিক সমস্যাটি সমাধান করতে চাই। আমার গণিত সমস্যাটি ওয়ার্ক ইউনিটে বিভক্ত হতে পারে, যা আমি বেশ কয়েকটি থ্রেডে সমাধান করতে চাই।
আমি এটিতে একটি নির্দিষ্ট পরিমাণ থ্রেডে কাজ করতে চাই না, তবে তার পরিবর্তে সিপিইউ কোরগুলির পরিমাণের সাথে মিলিত পরিমাণ থ্রেড। আমার সমস্যাটি হ'ল এটির জন্য আমি কোনও সহজ টিউটোরিয়াল খুঁজে পাইনি। আমি খুঁজে পাওয়া সমস্ত হ'ল স্থির থ্রেড সহ উদাহরণ।
কিভাবে এই কাজ করা যেতে পারে? আপনি উদাহরণ প্রদান করতে পারেন?
উত্তর:
আপনি স্ট্যাটিক রানটাইম পদ্ধতি ব্যবহার করে, দ্বারা জাভা ভার্চুয়াল মেশিন উপলব্ধ প্রসেস সংখ্যা নির্ধারণ করতে পারেন availableProcessors । একবার আপনি উপলব্ধ প্রসেসরের সংখ্যা নির্ধারণ করে নিলে, সেই সংখ্যার থ্রেড তৈরি করুন এবং সেই অনুযায়ী আপনার কাজটি বিভক্ত করুন।
আপডেট : আরও স্পষ্ট করার জন্য, একটি থ্রেড জাভাতে কেবল একটি অবজেক্ট, যাতে আপনি অন্য কোনও অবজেক্ট তৈরি করার মতো করে এটিকে তৈরি করতে পারেন। সুতরাং, আসুন আমরা বলি যে আপনি উপরের পদ্ধতিটি কল করেছেন এবং এটি দেখতে পান যে এটি 2 টি প্রসেসর ফেরায়। অসাধারণ. এখন, আপনি একটি লুপ তৈরি করতে পারেন যা একটি নতুন থ্রেড তৈরি করে এবং সেই থ্রেডটির জন্য কাজটি বিভক্ত করে এবং থ্রেডটি ছড়িয়ে দেয়। আমি যা বলতে চাইছি তা প্রদর্শনের জন্য এখানে কিছু স্যুইডোকোড দেওয়া হয়েছে:
int processors = Runtime.getRuntime().availableProcessors();
for(int i=0; i < processors; i++) {
Thread yourThread = new AThreadYouCreated();
// You may need to pass in parameters depending on what work you are doing and how you setup your thread.
yourThread.start();
}
আপনার নিজের থ্রেড তৈরির বিষয়ে আরও তথ্যের জন্য এই টিউটোরিয়ালটিতে যান । এছাড়াও, আপনি থ্রেড তৈরির জন্য থ্রেড পুলিংটি দেখতে চাইতে পারেন ।
আপনি সম্ভবত এই স্টাফটির জন্য java.util.concurrent ফ্রেমওয়ার্কটি দেখতে চান। কিছুটা এইরকম:
ExecutorService e = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
// Do work using something like either
e.execute(new Runnable() {
public void run() {
// do one task
}
});অথবা
Future<String> future = pool.submit(new Callable<String>() {
public String call() throws Exception {
return null;
}
});
future.get(); // Will block till result availableএটি আপনার নিজের থ্রেড পুলের সাথে লড়াই করার চেয়ে অনেক ভাল etc.
বিকল্প 1:
নিউ ওয়ার্ক স্টিলিংপুল থেকেExecutors
public static ExecutorService newWorkStealingPool()সমস্ত উপলভ্য প্রসেসরকে তার লক্ষ্য সমান্তরালতা স্তর হিসাবে ব্যবহার করে একটি ওয়ার্ক-স্টিলিং থ্রেড পুল তৈরি করে।
এই এপিআই দিয়ে আপনার কোনও সংখ্যক কোর পাস করার দরকার নেই ExecutorService।
গ্রেপকোড থেকে এই API এর বাস্তবায়ন
/**
* Creates a work-stealing thread pool using all
* {@link Runtime#availableProcessors available processors}
* as its target parallelism level.
* @return the newly created thread pool
* @see #newWorkStealingPool(int)
* @since 1.8
*/
public static ExecutorService newWorkStealingPool() {
return new ForkJoinPool
(Runtime.getRuntime().availableProcessors(),
ForkJoinPool.defaultForkJoinWorkerThreadFactory,
null, true);
}বিকল্প 2:
newFixedThreadPool API থেকে Executorsবা other newXXX constructors, যা প্রত্যাবর্তন করেExecutorService
public static ExecutorService newFixedThreadPool(int nThreads)এর সাথে এনট্রেডগুলি প্রতিস্থাপন করুন Runtime.getRuntime().availableProcessors()
বিকল্প 3:
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue)Runtime.getRuntime().availableProcessors()পরামিতি হিসাবে পাস maximumPoolSize।
ডগ লিএ (সমবর্তী প্যাকেজের লেখক) এর সাথে এই কাগজটি প্রাসঙ্গিক হতে পারে: http://gee.cs.oswego.edu/dl/papers/fj.pdf
জাভা এসই 7 তে কাঁটাচামচ যোগদানের কাঠামোটি যুক্ত করা হয়েছে নীচে আরও কয়েকটি উল্লেখ রয়েছে:
http://www.ibm.com/developerworks/java/library/j-jtp11137/index.html ব্রায়ান গয়েটসের নিবন্ধ
http://www.oracle.com/technetwork/articles/java/fork-join-422606.html
স্ট্যান্ডার্ড উপায় হ'ল রানটাইম.জেটআরটাইম ()। উপলভ্য প্রসেসর () পদ্ধতি। বেশিরভাগ স্ট্যান্ডার্ড সিপিইউতে আপনি এখানে সর্বোত্তম থ্রেড গণনা (যা আসল সিপিইউ কোর গণনা নয়) ফিরিয়ে দেবেন। অতএব এটি আপনি যা খুঁজছেন তা।
উদাহরণ:
ExecutorService service = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());এই জাতীয় নির্বাহক পরিষেবাটি বন্ধ করতে ভুলবেন না (বা আপনার প্রোগ্রামটি প্রস্থান করবে না):
service.shutdown();ভবিষ্যতের ভিত্তিক এমটি কোড কীভাবে সেটআপ করবেন তা এখানে একটি দ্রুত রূপরেখা (অফটপিক, উদাহরণের জন্য):
CompletionService<YourCallableImplementor> completionService =
new ExecutorCompletionService<YourCallableImplementor>(service);
ArrayList<Future<YourCallableImplementor>> futures = new ArrayList<Future<YourCallableImplementor>>();
for (String computeMe : elementsToCompute) {
futures.add(completionService.submit(new YourCallableImplementor(computeMe)));
}তারপরে আপনার কতগুলি ফলাফল প্রত্যাশা করা উচিত এবং এগুলি তাদের এভাবে পুনরুদ্ধার করতে হবে:
try {
int received = 0;
while (received < elementsToCompute.size()) {
Future<YourCallableImplementor> resultFuture = completionService.take();
YourCallableImplementor result = resultFuture.get();
received++;
}
} finally {
service.shutdown();
}রানটাইম ক্লাসে উপলভ্য প্রসেসরস () নামে একটি পদ্ধতি রয়েছে। আপনার কতটি সিপিইউ রয়েছে তা নির্ধারণ করতে আপনি এটি ব্যবহার করতে পারেন। যেহেতু আপনার প্রোগ্রামটি সিপিইউ বাউন্ডড, আপনি সম্ভবত উপলব্ধ সিপিইউতে (সর্বাধিক) একটি থ্রেড রাখতে চান।