আমরা যখন কথা বলতে পারি তখন মূল পুলের আকার এবং সর্বাধিক পুলের আকারের মধ্যে পার্থক্যটি কী ThreadPoolExecutor?
এটি একটি উদাহরণ সাহায্যে ব্যাখ্যা করা যেতে পারে?
উত্তর:
থেকে এই ব্লগ পোস্টে :
এই উদাহরণটি ধরুন। প্রারম্ভিক থ্রেড পুলের আকার 1, মূল পুলের আকার 5, সর্বাধিক পুলের আকার 10 এবং সারি 100 হয়।
হিসাবে অনুরোধ আসা, থ্রেড থেকে 5 পর্যন্ত তৈরি করা হবে এবং তারপর কর্ম কিউ যোগ করা হবে না হওয়া পর্যন্ত 100 ছুঁয়েছে কিউ পূর্ণ নতুন থ্রেড পর্যন্ত নির্মিত হবে
maxPoolSize। সমস্ত থ্রেড একবার ব্যবহার করা হয়ে গেলে এবং সারি পুরো কাজগুলি বাতিল হয়ে যাবে। সারি যেমন কমেছে তেমনি সক্রিয় থ্রেডের সংখ্যাও রয়েছে।
allowCoreThreadTimeOut(boolean)যা নিষ্ক্রিয় সময় দেওয়ার পরে মূল থ্রেডগুলিকে হত্যা করতে দেয়। এটি সত্যে সেট করা এবং সেটিং core threads= max threadsথ্রেড পুলকে 0 এবং এর মধ্যে স্কেল করার অনুমতি দেয় max threads।
যদি থ্রেড> কোরপুলসাইজ এবং <ম্যাকপুলসাইজ চলমান থাকে তবে মোট টাস্কের সারি পূর্ণ এবং নতুন উপস্থিত থাকলে নতুন থ্রেড তৈরি করুন।
ফর্ম ডক: (যদি কোরপুলসাইজের চেয়ে বেশি থাকে তবে সর্বাধিক পুলসাইজের থ্রেড চলমান থাকে তবে সারি পূর্ণ হলেই একটি নতুন থ্রেড তৈরি হবে))
এখন, একটি সাধারণ উদাহরণ নিন,
ThreadPoolExecutor executorPool = new ThreadPoolExecutor(5, 10, 3, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(50));
এখানে 5 টি কোরপুলসাইজ - এর অর্থ জেভিএম প্রথম 5 টি কাজের জন্য নতুন টাস্ক তৈরি করবে। এবং অন্যান্য কার্যগুলি কাতারে যোগ করা হবে যতক্ষণ না সারি পূর্ণ না হয় (50 টি কার্য)।
10 হ'ল ম্যাক্সপুলসাইজ - জেভিএম সর্বোচ্চ 10 টি থ্রেড তৈরি করতে পারে। এর অর্থ যদি ইতিমধ্যে 5 টি টাস্ক / থ্রেড চলমান থাকে এবং 50 টি মুলতুবি কার্যক্রমে সারি পূর্ণ হয় এবং যদি আরও একটি নতুন অনুরোধ / টাস্ক কাতারে পৌঁছায় তবে জেভিএম 10 পর্যন্ত নতুন থ্রেড তৈরি করবে (মোট থ্রেড = পূর্ববর্তী 5 + নতুন 5) ;
নতুন অ্যারেব্লকিংকিউ (50) = মোট সারি আকার - এটি এতে 50 টি কার্য সারি করতে পারে।
সমস্ত 10 টি থ্রেড চলমান থাকলে এবং যদি নতুন কার্যটি আগত হয় তবে সেই নতুন কাজটি প্রত্যাখ্যান করা হবে।
সূর্যের দ্বারা অভ্যন্তরীণভাবে থ্রেডগুলি তৈরি করার নিয়ম:
যদি থ্রেডের সংখ্যা কোরপুল সাইজের তুলনায় কম হয় তবে একটি নতুন টাস্ক চালানোর জন্য একটি নতুন থ্রেড তৈরি করুন।
থ্রেডের সংখ্যা কোরপুলসাইজের সমান (বা তার চেয়ে বড়), কাজটিকে কাতারে রাখুন।
যদি সারিটি পূর্ণ থাকে এবং থ্রেডের সংখ্যাটি ম্যাকপুলসাইজের চেয়ে কম হয় তবে কার্যগুলি চালনার জন্য একটি নতুন থ্রেড তৈরি করুন।
যদি সারিটি পূর্ণ থাকে এবং থ্রেডের সংখ্যাটি ম্যাকপুলসাইজের চেয়ে বড় বা সমান হয় তবে কার্যটি প্রত্যাখ্যান করুন।
আশা করি, এটি হেল্পফুল .. এবং আমি ভুল হলে দয়া করে আমাকে সংশোধন করুন ...
ডক থেকে :
যখন পদ্ধতিতে এক্সিকিউট করা (java.lang.Runnable) তে কোনও নতুন কাজ জমা দেওয়া হয় এবং কোরপুল সাইজের থ্রেডগুলি কম চলছে তখন অন্য কর্মী থ্রেডগুলি নিষ্ক্রিয় থাকলেও অনুরোধটি পরিচালনা করতে একটি নতুন থ্রেড তৈরি করা হয়। যদি কোরপুলসাইজের চেয়ে বেশি থাকে তবে সর্বাধিক পুলসাইজের থ্রেড চলমান থাকে তবে সারিটি পূর্ণ হলেই একটি নতুন থ্রেড তৈরি হবে।
আরও:
কোরপুল সাইজ এবং ম্যাক্সিমুলপুল সাইজ একই সেট করে আপনি একটি স্থির আকারের থ্রেড পুল তৈরি করেন। ম্যাক্সিমপুলসাইজকে মূলত আনবাউন্ডেড মান যেমন ইন্টিজার.ম্যাক্স_ভ্যালুতে সেট করে, আপনি পুলটিকে একাধিক সংখ্যক সামনের কাজগুলিতে সামঞ্জস্য করার অনুমতি দেন। সর্বাধিক সাধারণত, কোর এবং সর্বাধিক পুলের আকারগুলি কেবলমাত্র নির্মাণের উপর ভিত্তি করে সেট করা থাকে তবে সেগুলি সেটকোরপুলসাইজ (ইনট) এবং সেটম্যাক্সিমিউমপুলসাইজ (ইন্ট) ব্যবহার করে গতিশীলভাবে পরিবর্তিত হতে পারে।
আপনি যদি কারখানার ক্লাসটি ThreadPoolExecutorব্যবহার না করে ম্যানুয়ালি তৈরি করার সিদ্ধান্ত নিয়ে থাকেন তবে আপনাকে এর নির্মাতাগুলির একটি ব্যবহার করে Executorsএকটি তৈরি এবং কনফিগার করতে হবে। এই শ্রেণীর সর্বাধিক বিস্তৃত নির্মাতা:
public ThreadPoolExecutor(
int corePoolSize,
int maxPoolSize,
long keepAlive,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
RejectedExecutionHandler handler
);
আপনি দেখতে পাচ্ছেন, আপনি কনফিগার করতে পারেন:
আপনার থ্রেড পুলের আকার নির্ধারণ, সামঞ্জস্যপূর্ণ কাজগুলি সংখ্যার সীমাবদ্ধ করা ভবিষ্যদ্বাণী এবং স্থায়িত্বের ক্ষেত্রে আপনার অ্যাপ্লিকেশন এবং এর কার্যকরকরণ পরিবেশের জন্য একটি বিশাল উপকারের প্রতিনিধিত্ব করে: একটি সীমাহীন থ্রেড সৃষ্টি অবশেষে রানটাইম সংস্থানগুলি নিঃশেষ করে দেবে এবং ফলস্বরূপ আপনার অ্যাপ্লিকেশনটির অভিজ্ঞতা হতে পারে , গুরুতর পারফরম্যান্স সমস্যা যা এমনকি অ্যাপ্লিকেশন অস্থিরতা হতে পারে।
এটি সমস্যার মাত্র একটি অংশের সমাধান: আপনি কার্যকর সম্পাদনের সংখ্যা ক্যাপ করছেন তবে পরবর্তী কাজ সম্পাদনের জন্য জমা দেওয়া এবং সজ্জিত কাজগুলির সংখ্যাটি ক্যাপ করছেন না। অ্যাপ্লিকেশনটি পরে সম্পদের ঘাটতি অনুভব করবে, তবে শেষ পর্যন্ত যদি জমা দেওয়ার হারটি কার্যকরভাবে হারকে ছাড়িয়ে যায় তবে তা শেষ পর্যন্ত এটির অভিজ্ঞতা অর্জন করবে।
এই সমস্যার সমাধান হ'ল: অপেক্ষার কাজগুলি ধরে রাখতে নির্বাহককে একটি ব্লক করা সারি সরবরাহ করা। সারি পূরণের ক্ষেত্রে জমা দেওয়া কাজটি "প্রত্যাখ্যান" করা হবে। RejectedExecutionHandlerপ্রার্থনা যখন একটি টাস্ক জমা প্রত্যাখ্যাত হয়, এবং যে কেন ক্রিয়া প্রত্যাখ্যাত পূর্ববর্তী আইটেমে উদ্ধৃত করা হয়েছে। আপনি আপনার নিজস্ব প্রত্যাখ্যান নীতি বাস্তবায়ন করতে পারেন বা ফ্রেমওয়ার্কের সরবরাহিত বিল্ট-ইন নীতিগুলির একটি ব্যবহার করতে পারেন।
ডিফল্ট প্রত্যাখ্যান নীতিগুলিতে এক্সিকিউটারটি একটি থাকে RejectedExecutionException। তবে অন্যান্য অন্তর্নির্মিত নীতিগুলি আপনাকে দেয়:
একটি থ্রেডপুলএক্সেকিউটার পুল আকারের বিধি
ক এর আকারের নিয়ম ThreadPoolExecutor'sপুলের সাধারণত মিস-বোঝা হয়, কারণ এটি আপনার মনে হয় যেভাবে এটি করা উচিত বা যেভাবে আপনি এটি চান সেভাবে কাজ করে না।
এই উদাহরণটি ধরুন। প্রারম্ভিক থ্রেড পুলের আকার 1, মূল পুলের আকার 5, সর্বাধিক পুলের আকার 10 এবং সারি 100 হয়।
সূর্যের উপায়: অনুরোধগুলি থ্রেডে আসার পরে ৫০ টি তৈরি করা হবে, সুতরাং এটি 100 এ পৌঁছা না হওয়া পর্যন্ত কাজগুলিকে কাতারে যুক্ত করা হবে When যখন সারিটি পূর্ণ হবে তখন নতুন থ্রেড তৈরি করা হবে maxPoolSize । সমস্ত থ্রেড একবার ব্যবহার করা হয়ে গেলে এবং সারি পুরো কাজগুলি বাতিল হয়ে যাবে। সারি যেমন কমেছে ততই সক্রিয় থ্রেডের সংখ্যা রয়েছে।
ব্যবহারকারীর প্রত্যাশিত উপায়: থ্রেডগুলিতে অনুরোধগুলি 10 অবধি তৈরি করা হবে, তারপরে 100 টি না হওয়া পর্যন্ত কাজগুলি কাতারে যুক্ত করা হবে যেখানে সেগুলি প্রত্যাখ্যান করা হবে। সারি খালি না হওয়া পর্যন্ত থ্রেডের সংখ্যা সর্বাধিক নামকরণ করবে। যখন সারিটি খালি থাকে তখন থ্রেডগুলি বন্ধ না হয়ে অবধি মারা যাবে corePoolSize।
পার্থক্যটি হ'ল ব্যবহারকারীরা পুলের আকারটি আরও আগে বাড়ানো শুরু করতে চান এবং সারিটি আরও ছোট হতে চান, যেখানে সূর্যের পদ্ধতিটি পুলের আকারটি ছোট রাখতে চায় এবং লোডটি খুব বেশি হয়ে যাওয়ার পরে কেবল এটি বাড়িয়ে তোলে।
সহজ শর্তে থ্রেড তৈরির জন্য এখানে সূর্যের নিয়ম রয়েছে:
corePoolSizeএকটি নতুন টাস্ক চালানোর জন্য একটি নতুন থ্রেড তৈরি করুন।corePoolSize, কাজটিকে কাতারে রাখুন।maxPoolSizeকাজগুলি চালানোর জন্য একটি নতুন থ্রেড তৈরি করুন।maxPoolSize, কাজটি বাতিল করুন। দীর্ঘ এবং সংক্ষেপে এটি হ'ল নতুন থ্রেডগুলি কেবল তখনই তৈরি করা হয় যখন সারিটি পূর্ণ হয়, সুতরাং আপনি যদি আনবাউন্ডেড সারি ব্যবহার করেন তবে থ্রেডের সংখ্যা অতিক্রম করবে না corePoolSize।পূর্ণাঙ্গ ব্যাখ্যার জন্য, এটি ঘোড়ার মুখ থেকে পান: ThreadPoolExecutorএপিআই ডকুমেন্টেশন।
একটি দুর্দান্ত ফোরাম পোস্ট রয়েছে যা ThreadPoolExecutorকোড উদাহরণগুলির সাথে যেভাবে কাজ করে তার মাধ্যমে আপনাকে কথা বলবে : http://forums.sun.com/thread.jspa?threadID=5401400&tstart=0
আরও তথ্য: http://forums.sun.com/thread.jspa?threadID=5224557&tstart=450
জাভাডোকটিতে আপনি কোরপুলসাইজ এবং ম্যাকপুলসাইজ পদগুলির সংজ্ঞাটি পেতে পারেন। http://docs.oracle.com/javase/6/docs/api/java/util/concurrent/ThreadPoolExecutor.html
উপরের লিঙ্কটিতে আপনার প্রশ্নের উত্তর রয়েছে। তবে, কেবল এটি পরিষ্কার করার জন্য। অ্যাপ্লিকেশন কোরপুল সাইজে না পৌঁছা পর্যন্ত থ্রেড তৈরি করতে থাকবে। আমি মনে করি যে এখানে ধারণাটি এই যে অনেকগুলি থ্রেডগুলি কার্যপ্রবাহ পরিচালনা করার জন্য পর্যাপ্ত হওয়া উচিত। কোরপুল সাইজের থ্রেড তৈরির পরে যদি কোনও নতুন টাস্ক আসে তবে কাজগুলি সারিবদ্ধ করা হবে। কিউ পূর্ণ হয়ে গেলে এক্সিকিউটার নতুন থ্রেড তৈরি শুরু করবে। এটি একরকম ভারসাম্যহীন। এটির মূলত অর্থটি হ'ল প্রক্রিয়াজাতকরণের ক্ষমতার চেয়ে কাজের প্রবাহ বেশি। সুতরাং, এক্সিকিউটার সর্বাধিক সংখ্যক থ্রেড না পাওয়া পর্যন্ত নতুন থ্রেড তৈরি করা শুরু করবে। আবার, একটি নতুন থ্রেড তৈরি করা হবে যদি এবং কেবল সারিটি পূর্ণ হয়।
এই ব্লগে ভাল ব্যাখ্যা :
public class ThreadPoolExecutorExample {
public static void main (String[] args) {
createAndRunPoolForQueue(new ArrayBlockingQueue<Runnable>(3), "Bounded");
createAndRunPoolForQueue(new LinkedBlockingDeque<>(), "Unbounded");
createAndRunPoolForQueue(new SynchronousQueue<Runnable>(), "Direct hand-off");
}
private static void createAndRunPoolForQueue (BlockingQueue<Runnable> queue,
String msg) {
System.out.println("---- " + msg + " queue instance = " +
queue.getClass()+ " -------------");
ThreadPoolExecutor e = new ThreadPoolExecutor(2, 5, Long.MAX_VALUE,
TimeUnit.NANOSECONDS, queue);
for (int i = 0; i < 10; i++) {
try {
e.execute(new Task());
} catch (RejectedExecutionException ex) {
System.out.println("Task rejected = " + (i + 1));
}
printStatus(i + 1, e);
}
e.shutdownNow();
System.out.println("--------------------\n");
}
private static void printStatus (int taskSubmitted, ThreadPoolExecutor e) {
StringBuilder s = new StringBuilder();
s.append("poolSize = ")
.append(e.getPoolSize())
.append(", corePoolSize = ")
.append(e.getCorePoolSize())
.append(", queueSize = ")
.append(e.getQueue()
.size())
.append(", queueRemainingCapacity = ")
.append(e.getQueue()
.remainingCapacity())
.append(", maximumPoolSize = ")
.append(e.getMaximumPoolSize())
.append(", totalTasksSubmitted = ")
.append(taskSubmitted);
System.out.println(s.toString());
}
private static class Task implements Runnable {
@Override
public void run () {
while (true) {
try {
Thread.sleep(1000000);
} catch (InterruptedException e) {
break;
}
}
}
}
}
আউটপুট:
---- Bounded queue instance = class java.util.concurrent.ArrayBlockingQueue -------------
poolSize = 1, corePoolSize = 2, queueSize = 0, queueRemainingCapacity = 3, maximumPoolSize = 5, totalTasksSubmitted = 1
poolSize = 2, corePoolSize = 2, queueSize = 0, queueRemainingCapacity = 3, maximumPoolSize = 5, totalTasksSubmitted = 2
poolSize = 2, corePoolSize = 2, queueSize = 1, queueRemainingCapacity = 2, maximumPoolSize = 5, totalTasksSubmitted = 3
poolSize = 2, corePoolSize = 2, queueSize = 2, queueCapacity = 1, maximumPoolSize = 5, totalTasksSubmitted = 4
poolSize = 2, corePoolSize = 2, queueSize = 3, queueRemainingCapacity = 0, maximumPoolSize = 5, totalTasksSubmitted = 5
poolSize = 3, corePoolSize = 2, queueSize = 3, queueRemainingCapacity = 0, maximumPoolSize = 5, totalTasksSubmitted = 6
poolSize = 4, corePoolSize = 2, queueSize = 3, queueRemainingCapacity = 0, maximumPoolSize = 5, totalTasksSubmitted = 7
poolSize = 5, corePoolSize = 2, queueSize = 3, queueRemainingCapacity = 0, maximumPoolSize = 5, totalTasksSubmitted = 8
Task rejected = 9
poolSize = 5, corePoolSize = 2, queueSize = 3, queueRemainingCapacity = 0, maximumPoolSize = 5, totalTasksSubmitted = 9
Task rejected = 10
poolSize = 5, corePoolSize = 2, queueSize = 3, queueRemainingCapacity = 0, maximumPoolSize = 5, totalTasksSubmitted = 10
--------------------
---- Unbounded queue instance = class java.util.concurrent.LinkedBlockingDeque -------------
poolSize = 1, corePoolSize = 2, queueSize = 0, queueRemainingCapacity = 2147483647, maximumPoolSize = 5, totalTasksSubmitted = 1
poolSize = 2, corePoolSize = 2, queueSize = 0, queueRemainingCapacity = 2147483647, maximumPoolSize = 5, totalTasksSubmitted = 2
poolSize = 2, corePoolSize = 2, queueSize = 1, queueRemainingCapacity = 2147483646, maximumPoolSize = 5, totalTasksSubmitted = 3
poolSize = 2, corePoolSize = 2, queueSize = 2, queueRemainingCapacity = 2147483645, maximumPoolSize = 5, totalTasksSubmitted = 4
poolSize = 2, corePoolSize = 2, queueSize = 3, queueRemainingCapacity = 2147483644, maximumPoolSize = 5, totalTasksSubmitted = 5
poolSize = 2, corePoolSize = 2, queueSize = 4, queueRemainingCapacity = 2147483643, maximumPoolSize = 5, totalTasksSubmitted = 6
poolSize = 2, corePoolSize = 2, queueSize = 5, queueRemainingCapacity = 2147483642, maximumPoolSize = 5, totalTasksSubmitted = 7
poolSize = 2, corePoolSize = 2, queueSize = 6, queueRemainingCapacity = 2147483641, maximumPoolSize = 5, totalTasksSubmitted = 8
poolSize = 2, corePoolSize = 2, queueSize = 7, queueRemainingCapacity = 2147483640, maximumPoolSize = 5, totalTasksSubmitted = 9
poolSize = 2, corePoolSize = 2, queueSize = 8, queueRemainingCapacity = 2147483639, maximumPoolSize = 5, totalTasksSubmitted = 10
--------------------
---- Direct hand-off queue instance = class java.util.concurrent.SynchronousQueue -------------
poolSize = 1, corePoolSize = 2, queueSize = 0, queueRemainingCapacity = 0, maximumPoolSize = 5, totalTasksSubmitted = 1
poolSize = 2, corePoolSize = 2, queueSize = 0, queueRemainingCapacity = 0, maximumPoolSize = 5, totalTasksSubmitted = 2
poolSize = 3, corePoolSize = 2, queueSize = 0, queueRemainingCapacity = 0, maximumPoolSize = 5, totalTasksSubmitted = 3
poolSize = 4, corePoolSize = 2, queueSize = 0, queueRemainingCapacity = 0, maximumPoolSize = 5, totalTasksSubmitted = 4
poolSize = 5, corePoolSize = 2, queueSize = 0, queueRemainingCapacity = 0, maximumPoolSize = 5, totalTasksSubmitted = 5
Task rejected = 6
poolSize = 5, corePoolSize = 2, queueSize = 0, queueRemainingCapacity = 0, maximumPoolSize = 5, totalTasksSubmitted = 6
Task rejected = 7
poolSize = 5, corePoolSize = 2, queueSize = 0, queueRemainingCapacity = 0, maximumPoolSize = 5, totalTasksSubmitted = 7
Task rejected = 8
poolSize = 5, corePoolSize = 2, queueSize = 0, queueRemainingCapacity = 0, maximumPoolSize = 5, totalTasksSubmitted = 8
Task rejected = 9
poolSize = 5, corePoolSize = 2, queueSize = 0, queueRemainingCapacity = 0, maximumPoolSize = 5, totalTasksSubmitted = 9
Task rejected = 10
poolSize = 5, corePoolSize = 2, queueSize = 0, queueRemainingCapacity = 0, maximumPoolSize = 5, totalTasksSubmitted = 10
--------------------
Process finished with exit code 0
জাভা কনসুরেন্সির প্রয়োজনীয় বইটি থেকে :
কোরপুলসাইজ : থ্রেডপুলঅ্যাক্সিকিউটারের একটি বৈশিষ্ট্যযুক্ত কোরপুলসাইজ রয়েছে যা নির্ধারণ করে যে কতগুলি থ্রেড শুরু হবে যতক্ষণ না নতুন থ্রেড কেবল সারি পূর্ণ হওয়ার পরে শুরু হয়
MaximumPoolSize এই বৈশিষ্ট্য নির্ধারণ করে কত থ্রেড সর্বাধিক শুরু করছে। আপনি এটি পূর্ণসংখ্যার সেট করতে পারেন। উপরের সীমানা না থাকার জন্য MAX_VALUE
java.util.concurrent.ThreadPoolExecutor
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
/*
* Proceed in 3 steps:
*
* 1. If fewer than corePoolSize threads are running, try to
* start a new thread with the given command as its first
* task. The call to addWorker atomically checks runState and
* workerCount, and so prevents false alarms that would add
* threads when it shouldn't, by returning false.
*
* 2. If a task can be successfully queued, then we still need
* to double-check whether we should have added a thread
* (because existing ones died since last checking) or that
* the pool shut down since entry into this method. So we
* recheck state and if necessary roll back the enqueuing if
* stopped, or start a new thread if there are none.
*
* 3. If we cannot queue task, then we try to add a new
* thread. If it fails, we know we are shut down or saturated
* and so reject the task.
*/
int c = ctl.get();
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command))
reject(command);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
else if (!addWorker(command, false))
reject(command);
}
ThreadPoolExecutorকোনও নতুন কার্য জমা দেওয়ার সময়ে অভ্যন্তরীণ আচরণ বুঝতে আমাকে কীভাবে corePoolSizeএবং maximumPoolSizeপৃথক তা বুঝতে সহায়তা করে ।
দিন:
Nপুলে থ্রেডের সংখ্যা হতে হবে getPoolSize(),। সক্রিয় থ্রেড + নিষ্ক্রিয় থ্রেড।T নির্বাহক / পুলে জমা দেওয়া কাজের পরিমাণ হও।Cকোর পুল আকার হতে হবে getCorePoolSize(),। নতুন কার্যগুলি কাতারে যাওয়ার আগে আগত কর্মগুলির জন্য পুল প্রতি সর্বাধিক কত থ্রেড তৈরি করা যায় ।Mসর্বাধিক পুল আকার হতে হবে getMaximumPoolSize(),। পুল বরাদ্দ করতে পারে সর্বাধিক পরিমাণ থ্রেড।ThreadPoolExecutorজাভাতে আচরণগুলি যখন কোনও নতুন কার্য জমা দেওয়া হয়:
N <= C , নিষ্ক্রিয় থ্রেডগুলি নতুন আগত টাস্ক বরাদ্দ করা হয় না, পরিবর্তে একটি নতুন থ্রেড তৈরি করা হয়।N > Cএবং যদি নিষ্ক্রিয় থ্রেড থাকে তবে সেখানে নতুন কার্য নির্ধারিত হয়।N > Cএবং কোনও নিষ্ক্রিয় থ্রেড না থাকে তবে নতুন কার্যগুলি সারিতে রাখা হবে। এখানে নতুন কোনও নতুন তৈরি করা হয়নি।M। যদি Mপৌঁছে যায়, আমরা কার্যগুলি প্রত্যাখ্যান করি। এখানে না গুরুত্বপূর্ণ বিষয়টি হ'ল সারিটি পূর্ণ না হওয়া পর্যন্ত আমরা নতুন থ্রেড তৈরি করি না!সূত্র:
corePoolSize = 0এবং এর উদাহরণmaximumPoolSize = 1050 ।এটির সারিটিতে 50 টি আইটেম না হওয়া পর্যন্ত পুলটিতে একটি একক সক্রিয় থ্রেডের ফলস্বরূপ।
executor.execute(task #1):
before task #1 submitted to executor: java.util.concurrent.ThreadPoolExecutor@c52dafe[Running, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 0]
after task #1 submitted to executor: java.util.concurrent.ThreadPoolExecutor@c52dafe[Running, pool size = 1, active threads = 1, queued tasks = 1, completed tasks = 0]
[task #1 immediately queued and kicked in b/c the very first thread is created when `workerCountOf(recheck) == 0`]
execute(task #2):
before task #2 submitted to executor: java.util.concurrent.ThreadPoolExecutor@c52dafe[Running, pool size = 1, active threads = 1, queued tasks = 0, completed tasks = 0]
after task #2 submitted to executor: java.util.concurrent.ThreadPoolExecutor@c52dafe[Running, pool size = 1, active threads = 1, queued tasks = 1, completed tasks = 0]
[task #2 not starting before #1 is done]
... executed a few tasks...
execute(task #19)
before task #19 submitted to executor: java.util.concurrent.ThreadPoolExecutor@735afe38[Running, pool size = 1, active threads = 1, queued tasks = 17, completed tasks = 0]
after task #19 submitted to executor: java.util.concurrent.ThreadPoolExecutor@735afe38[Running, pool size = 1, active threads = 1, queued tasks = 18, completed tasks = 0]
...
execute(task #51)
before task submitted to executor: java.util.concurrent.ThreadPoolExecutor@735afe38[Running, pool size = 1, active threads = 1, queued tasks = 50, completed tasks = 0]
after task submitted to executor: java.util.concurrent.ThreadPoolExecutor@735afe38[Running, pool size = 2, active threads = 2, queued tasks = 50, completed tasks = 0]
Queue is full.
A new thread was created as the queue was full.
corePoolSize = 10এবং এর উদাহরণmaximumPoolSize = 1050 ।এর ফলে পুলটিতে 10 টি সক্রিয় থ্রেড হবে। যখন কাতারে 50 টি আইটেম থাকবে, কাজগুলি বাতিল হয়ে যাবে।
execute(task #1)
before task #1 submitted to executor: java.util.concurrent.ThreadPoolExecutor@32d9e072[Running, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 0]
after task #1 submitted to executor: java.util.concurrent.ThreadPoolExecutor@32d9e072[Running, pool size = 1, active threads = 1, queued tasks = 0, completed tasks = 0]
execute(task #2)
before task #2 submitted to executor: java.util.concurrent.ThreadPoolExecutor@32d9e072[Running, pool size = 1, active threads = 1, queued tasks = 0, completed tasks = 0]
after task #2 submitted to executor: java.util.concurrent.ThreadPoolExecutor@32d9e072[Running, pool size = 2, active threads = 2, queued tasks = 0, completed tasks = 0]
execute(task #3)
before task #3 submitted to executor: java.util.concurrent.ThreadPoolExecutor@32d9e072[Running, pool size = 2, active threads = 2, queued tasks = 0, completed tasks = 0]
after task #3 submitted to executor: java.util.concurrent.ThreadPoolExecutor@32d9e072[Running, pool size = 3, active threads = 3, queued tasks = 0, completed tasks = 0]
... executed a few tasks...
execute(task #11)
before task #11 submitted to executor: java.util.concurrent.ThreadPoolExecutor@32d9e072[Running, pool size = 10, active threads = 10, queued tasks = 0, completed tasks = 0]
after task #11 submitted to executor: java.util.concurrent.ThreadPoolExecutor@32d9e072[Running, pool size = 10, active threads = 10, queued tasks = 1, completed tasks = 0]
... executed a few tasks...
execute(task #51)
before task #51 submitted to executor: java.util.concurrent.ThreadPoolExecutor@32d9e072[Running, pool size = 10, active threads = 10, queued tasks = 50, completed tasks = 0]
Task was rejected as we have reached `maximumPoolSize`.