مثال على رمز تجمع الخيوط المشتركة في Java

import java.util.Collection;
import java.util.Vector;

/**
*المنتجات المتاحة
*/
يقوم TaskManage من الفئة العامة بتوسيع الموضوع
{
مهام Vector<Runnable> محمية = ناقل جديد<Runnable>();
تشغيل منطقي محمي = خطأ؛
توقف منطقي محمي = خطأ؛
منطقي محمي متوقف مؤقتًا = خطأ؛
قتل منطقي محمي = خطأ؛
تجمع ThreadPool الخاص؛

إدارة المهام العامة (تجمع ThreadPool)
{
this.pool = Pool;
}

public void putTask (مهمة قابلة للتشغيل)
{
المهام. إضافة(مهمة);
}

putTasks الفراغ العام (المهام القابلة للتشغيل [])
{
لـ (int i = 0; i < Tasks.length; i++)
this.tasks.add(tasks[i]);
}

putTasks باطلة عامة (مجموعة <Runnable> المهام)
{
this.tasks.addAll(tasks);
}

PopTask المحمي القابل للتشغيل ()
{
إذا (tasks.size() > 0) قم بإرجاع المهام (القابلة للتشغيل).remove(0);
وإلا يعود فارغًا؛
}

المنطقية العامة قيد التشغيل ()
{
عودة التشغيل؛
}

stopTasks الفراغ العام ()
{
توقف = صحيح؛
}

stopTasksSync () الفراغ العام
{
stopTasks();
بينما (isRunning ())
{
يحاول
{
النوم(5);
}
قبض على (InterruptedException ه)
{
TaskException.getResultMessage(e);
}
}
}

المهام المؤقتة الفارغة العامة ()
{
متوقف مؤقتا = صحيح؛
}

الفراغ العام الإيقاف المؤقتTasksSync ()
{
PauseTasks();
بينما (isRunning ())
{
يحاول
{
النوم(5);
}
قبض على (InterruptedException ه)
{
TaskException.getResultMessage(e);
}
}
}

قتل الفراغ العام ()
{
إذا (! قيد التشغيل) يقاطع () ؛
قتل آخر = صحيح؛
}

killSync الفراغ العام ()
{
قتل()؛
بينما (على قيد الحياة ())
{
يحاول
{
النوم(5);
}
قبض على (InterruptedException ه)
{
TaskException.getResultMessage(e);
}
}
}

startTasks الفارغة المتزامنة العامة ()
{
تشغيل = صحيح؛
this.notify();
}

تشغيل الفراغ المتزامن العام ()
{
يحاول
{
بينما (صحيح)
{
إذا (! تشغيل || المهام. الحجم () == 0)
{
pool.notifyForIdleThread();
this.wait();
}
آخر
{
مهمة قابلة للتشغيل؛
بينما ((مهمة = popTask()) != فارغة)
{
Task.run();
إذا (توقف)
{
توقف = خطأ؛
إذا (tasks.size() > 0)
{
Tasks.clear();
System.out.println(Thread.currentThread().getId() + ": تم إيقاف المهام");
استراحة؛
}
}
إذا (متوقف مؤقتا)
{
متوقف مؤقتًا = خطأ؛
إذا (tasks.size() > 0)
{
System.out.println(Thread.currentThread().getId() + ": تم إيقاف المهام مؤقتًا");
استراحة؛
}
}
}
تشغيل = خطأ؛
}

إذا (قتل)
{
قتل = خطأ؛
استراحة؛
}
}
}
قبض على (InterruptedException ه)
{
TaskException.getResultMessage(e);
يعود؛
}
}
}

import java.util.Collection;
import java.util.Iterator;
import java.util.Vector;

/**
* 线程池
*/
ThreadPool للفئة العامة
{
protected int maxPoolSize = TaskConfig.maxPoolSize;
protected int initPoolSize = TaskConfig.initPoolSize;
المواضيع المحمية Vector<TaskManage> = new Vector<TaskManage>();
تمت تهيئة منطقية محمية = خطأ؛
hasIdleThread المنطقي المحمي = false;

ThreadPool العام ()
{
ممتاز()؛
}

ThreadPool العام (int maxPoolSize، int initPoolSize)
{
this.maxPoolSize = maxPoolSize;
this.initPoolSize = initPoolSize;
}

الحرف الأول الفراغي العام ()
{
تهيئة = صحيح؛
لـ (int i = 0; i < initPoolSize; i++)
{
موضوع TaskManage = new TaskManage(this);
Thread.start();
Threads.add(thread);
}
}

مجموعة الفراغ العامMaxPoolSize(int maxPoolSize)
{
this.maxPoolSize = maxPoolSize;
if (maxPoolSize < getPoolSize()) setPoolSize(maxPoolSize);
}

/**
* يجب أن تكون قادرًا على التعامل مع هذه المشكلة، ولكن لا داعي للقلق بشأن هذا الأمر.
* قد يكون من الأفضل أن تكون قادرًا على التعامل مع هذه المشكلة من خلال الحصول على أفضل النتائج.
*/
مجموعة الفراغ العامPoolSize (حجم int)
{
إذا (! تمت التهيئة)
{
initPoolSize = size;
يعود؛
}
وإلا إذا (الحجم > getPoolSize())
{
لـ (int i = getPoolSize(); i < size && i < maxPoolSize; i++)
{
موضوع TaskManage = new TaskManage(this);
Thread.start();
Threads.add(thread);
}
}
وإلا إذا (الحجم < getPoolSize ())
{
بينما (getPoolSize() > الحجم)
{
TaskManage th = (TaskManage) threads.remove(0);
th.kill();
}
}
}

كثافة العمليات العامة getPoolSize ()
{
إرجاع Threads.size();
}

notifyForIdleThread() باطلة محمية
{
hasIdleThread = true;
}

waitForIdleThread() المنطقية المحمية
{
hasIdleThread = false;
بينما (! hasIdleThread && getPoolSize() >= maxPoolSize)
{
يحاول
{
Thread.sleep(5);
}
قبض على (InterruptedException ه)
{
TaskException.getResultMessage(e);
عودة كاذبة.
}
}

عودة صحيحة؛
}

إدارة المهام العامة المتزامنة getIdleThread()
{
بينما (صحيح)
{
لـ (Iterator<TaskManage> itr = threads.iterator(); itr.hasNext();)
{
TaskManage th = (TaskManage) itr.next();
إذا قام (!th.isRunning()) بإرجاع th;
}

إذا (getPoolSize () <maxPoolSize)
{
موضوع TaskManage = new TaskManage(this);
Thread.start();
Threads.add(thread);
موضوع العودة.
}

if (waitForIdleThread() == false) return null;
}
}

عملية باطلة عامة (مهمة قابلة للتشغيل)
{
TaskManage th = getIdleThread();
إذا (ال != فارغة)
{
th.putTask(task);
th.startTasks();
}
}

عملية الفراغ العامTasksInSingleThread (المهام القابلة للتشغيل [])
{
TaskManage th = getIdleThread();
إذا (ال != فارغة)
{
th.putTasks(tasks);
th.startTasks();
}
}

عملية الفراغ العامTasksInSingleThread (مجموعة المهام <Runnable>)
{
TaskManage th = getIdleThread();
إذا (ال != فارغة)
{
th.putTasks(tasks);
th.startTasks();
}
}

}

تقوم الطبقة العامة TopTask بتنفيذ Runnable
{

تجمع ThreadPool الخاص؛

TopTask العامة ()
{
ممتاز()؛
}

TopTask العام (تجمع ThreadPool)
{
ممتاز()؛
this.pool = Pool;
}

@تجاوز
تشغيل الفراغ العام ()
{
الحرف الأول () ؛
يبدأ()؛
}

/**
*الحصول على أفضل النتائج
*/
الحرف الأول الفراغي العام ()
{

}

/**
*المنتجات المتاحة
*/
بداية الفراغ العام ()
{
لـ (int i = 0; i < 10; i++)
{
pool.processTask(new BeginAuto());
}
}
}
/**
*المنتجات
*/
تقوم فئة BeginAuto بتنفيذ Runnable
{
@تجاوز
تشغيل الفراغ العام ()
{
System.out.println(Thread.currentThread().getId() + "..................");
}

}