java.util.Collectionをインポートします。
java.util.Vectorをインポートします。
/**
* 任务配信者
*/
パブリッククラスTaskManageはThreadを拡張します
{
protected Vector<Runnable> タスク = new Vector<Runnable>();
protected ブール値実行 = false;
protected ブール値停止 = false;
protected ブール値一時停止 = false;
保護されたブール値が殺されました = false;
プライベート ThreadPool プール。
public TaskManage(ThreadPool プール)
{
this.pool = プール;
}
public void putTask(実行可能なタスク)
{
タスク.追加(タスク);
}
public void putTasks(実行可能な[]タスク)
{
for (int i = 0; i < task.length; i++)
this.tasks.add(タスク[i]);
}
public void putTasks(Collection<Runnable> タスク)
{
this.tasks.addAll(タスク);
}
保護された実行可能popTask()
{
if (tasks.size() > 0) return (実行可能) task.remove(0);
それ以外の場合は null を返します。
}
パブリックブール値 isRunning()
{
ランニングに戻る。
}
public void stopTasks()
{
停止 = true;
}
public void stopTasksSync()
{
stopTasks();
while (isRunning())
{
試す
{
スリープ(5);
}
catch (InterruptedException e)
{
TaskException.getResultMessage(e);
}
}
}
public void stopTasks()
{
一時停止 = true;
}
public void stopTasksSync()
{
一時停止タスク();
while (isRunning())
{
試す
{
スリープ(5);
}
catch (InterruptedException e)
{
TaskException.getResultMessage(e);
}
}
}
パブリック void kill()
{
if (!running) 割り込み();
それ以外の場合は殺されました = true;
}
パブリック void killSync()
{
殺す（）;
while (isAlive())
{
試す
{
スリープ(5);
}
catch (InterruptedException e)
{
TaskException.getResultMessage(e);
}
}
}
public synchronized void startTasks()
{
実行中 = true;
this.notify();
}
public synchronized void run()
{
試す
{
その間（本当）
{
if (!実行中 || task.size() == 0)
{
pool.notifyForIdleThread();
this.wait();
}
それ以外
{
実行可能なタスク。
while ((タスク = PopTask()) != null)
{
task.run();
もし（止まった）
{
停止 = false;
if (task.size() > 0)
{
タスク.クリア();
System.out.println(Thread.currentThread().getId() + ": タスクは停止しています");
壊す;
}
}
もし（一時停止）
{
一時停止 = false;
if (task.size() > 0)
{
System.out.println(Thread.currentThread().getId() + ": タスクは一時停止されています");
壊す;
}
}
}
実行中 = false;
}
もし（殺された）
{
殺された = false;
壊す;
}
}
}
catch (InterruptedException e)
{
TaskException.getResultMessage(e);
戻る;
}
}
}
java.util.Collectionをインポートします。
java.util.Iteratorをインポートします。
java.util.Vectorをインポートします。
/**
*線程池
*/
パブリック クラス ThreadPool
{
protected int maxPoolSize = TaskConfig.maxPoolSize;
protected int initPoolSize = TaskConfig.initPoolSize;
protected Vector<TaskManage> スレッド = new Vector<TaskManage>();
保護されたブール値の初期化 = false;
protected boolean hasIdleThread = false;
パブリック ThreadPool()
{
素晴らしい（）;
}
public ThreadPool(int maxPoolSize, int initPoolSize)
{
this.maxPoolSize = maxPoolSize;
this.initPoolSize = initPoolSize;
}
パブリック void init()
{
初期化済み = true;
for (int i = 0; i < initPoolSize; i++)
{
TaskManage スレッド = 新しい TaskManage(this);
thread.start();
スレッド.追加(スレッド);
}
}
public void setMaxPoolSize(int maxPoolSize)
{
this.maxPoolSize = maxPoolSize;
if (maxPoolSize < getPoolSize()) setPoolSize(maxPoolSize);
}
/**
* 重设当前回線程数若必要杀掉或る回線程、回線程不会立瞬間杀掉、而会等到回線程中的事
* 处処理は完了しましたが、この方法会立瞬間从線程池中移除この回線程，不会等待機事务处処理结了
*/
public void setPoolSize(int size)
{
if (!初期化済み)
{
initPoolSize = サイズ;
戻る;
}
else if (サイズ > getPoolSize())
{
for (int i = getPoolSize(); i < サイズ && i < maxPoolSize; i++)
{
TaskManage スレッド = 新しい TaskManage(this);
thread.start();
スレッド.追加(スレッド);
}
}
else if (サイズ < getPoolSize())
{
while (getPoolSize() > サイズ)
{
TaskManage th = (TaskManage) thread.remove(0);
th.kill();
}
}
}
public int getPoolSize()
{
スレッドを返します。size();
}
保護された void NoticeForIdleThread()
{
hasIdleThread = true;
}
protected boolean waitForIdleThread()
{
hasIdleThread = false;
while (!hasIdleThread && getPoolSize() >= maxPoolSize)
{
試す
{
Thread.sleep(5);
}
catch (InterruptedException e)
{
TaskException.getResultMessage(e);
false を返します。
}
}
true を返します。
}
パブリック同期タスクマネージ getIdleThread()
{
その間（本当）
{
for (Iterator<TaskManage> itr = thread.iterator(); itr.hasNext();)
{
タスク管理 th = (タスク管理) itr.next();
if (!th.isRunning()) は th を返します。
}
if (getPoolSize() < maxPoolSize)
{
TaskManage スレッド = 新しい TaskManage(this);
thread.start();
スレッド.追加(スレッド);
スレッドを返します。
}
if (waitForIdleThread() == false) は null を返します。
}
}
public void processTask(実行可能なタスク)
{
タスク管理 th = getIdleThread();
if (th != null)
{
th.putTask(タスク);
th.startTasks();
}
}
public void processTasksInSingleThread(Runnable[] タスク)
{
タスク管理 th = getIdleThread();
if (th != null)
{
th.putTasks(タスク);
th.startTasks();
}
}
public void processTasksInSingleThread(Collection<Runnable> タスク)
{
タスク管理 th = getIdleThread();
if (th != null)
{
th.putTasks(タスク);
th.startTasks();
}
}
}
パブリック クラス TopTask は Runnable を実装します
{
プライベート ThreadPool プール。
パブリック TopTask()
{
素晴らしい（）;
}
パブリック TopTask(ThreadPool プール)
{
素晴らしい（）;
this.pool = プール;
}
@オーバーライド
public void run()
{
init();
始める（）;
}
/**
* 初期化验证权限、パラメータ之类
*/
パブリック void init()
{
}
/**
* 自動任务を開始します
*/
public void start()
{
for (int i = 0; i < 10; i++)
{
pool.processTask(new BeginAuto());
}
}
}
/**
*实现类
*/
BeginAuto クラスは Runnable を実装します
{
@オーバーライド
public void run()
{
System.out.println(Thread.currentThread().getId() + ".....");
}
}