Beispielcode für einen gemeinsamen Thread-Pool in Java

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

/**
* 任务分发器
*/
Die öffentliche Klasse TaskManage erweitert Thread
{
protected Vector<Runnable> task = new Vector<Runnable>();
protected boolean running = false;
protected boolean gestoppt = false;
protected boolean paused = false;
protected boolean killed = false;
privater ThreadPool-Pool;

öffentliches TaskManage (ThreadPool-Pool)
{
this.pool = pool;
}

public void putTask(Ausführbare Aufgabe)
{
Aufgaben.add(Aufgabe);
}

public void putTasks(Ausführbare[] Aufgaben)
{
for (int i = 0; i < task.length; i++)
this.tasks.add(tasks[i]);
}

public void putTasks(Collection<Runnable>-Aufgaben)
{
this.tasks.addAll(tasks);
}

protected Runnable popTask()
{
if (tasks.size() > 0) return (Runnable) task.remove(0);
sonst null zurückgeben;
}

öffentlicher boolescher Wert isRunning()
{
Rücklauf;
}

public void stopTasks()
{
gestoppt = wahr;
}

public void stopTasksSync()
{
stopTasks();
while (isRunning())
{
versuchen
{
Schlaf(5);
}
Catch (InterruptedException e)
{
TaskException.getResultMessage(e);
}
}
}

public void pauseTasks()
{
pausiert = wahr;
}

public void pauseTasksSync()
{
pauseTasks();
while (isRunning())
{
versuchen
{
Schlaf(5);
}
Catch (InterruptedException e)
{
TaskException.getResultMessage(e);
}
}
}

public void kill()
{
if (!running) interrupt();
sonst getötet = wahr;
}

public void killSync()
{
töten();
while (isAlive())
{
versuchen
{
Schlaf(5);
}
Catch (InterruptedException e)
{
TaskException.getResultMessage(e);
}
}
}

öffentlich synchronisiert void startTasks()
{
läuft = wahr;
this.notify();
}

öffentlicher synchronisierter void run()
{
versuchen
{
while (wahr)
{
if (!running || task.size() == 0)
{
pool.notifyForIdleThread();
this.wait();
}
anders
{
Ausführbare Aufgabe;
while ((task = popTask()) != null)
{
task.run();
wenn (gestoppt)
{
gestoppt = falsch;
if (tasks.size() > 0)
{
Aufgaben.clear();
System.out.println(Thread.currentThread().getId() + „: Aufgaben werden gestoppt“);
brechen;
}
}
wenn (pausiert)
{
pausiert = falsch;
if (tasks.size() > 0)
{
System.out.println(Thread.currentThread().getId() + „: Aufgaben werden angehalten“);
brechen;
}
}
}
läuft = false;
}

wenn (getötet)
{
getötet = falsch;
brechen;
}
}
}
Catch (InterruptedException e)
{
TaskException.getResultMessage(e);
zurückkehren;
}
}
}

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

/**
* 线程池
*/
öffentliche Klasse ThreadPool
{
protected int maxPoolSize = TaskConfig.maxPoolSize;
protected int initPoolSize = TaskConfig.initPoolSize;
protected Vector<TaskManage> threads = new Vector<TaskManage>();
protected boolean initialized = false;
protected boolean hasIdleThread = false;

öffentlicher ThreadPool()
{
super();
}

public ThreadPool(int maxPoolSize, int initPoolSize)
{
this.maxPoolSize = maxPoolSize;
this.initPoolSize = initPoolSize;
}

public void init()
{
initialisiert = wahr;
for (int i = 0; i < initPoolSize; i++)
{
TaskManage-Thread = new TaskManage(this);
thread.start();
threads.add(thread);
}
}

public void setMaxPoolSize(int maxPoolSize)
{
this.maxPoolSize = maxPoolSize;
if (maxPoolSize < getPoolSize()) setPoolSize(maxPoolSize);
}

/**
* 重设当前线程数 若需杀掉某线程,线程不会立刻杀掉,而会等到线程中的事
* 务处理完成 但此方法会立刻从线程池中移除该线程,不会等待事务处理结束
*/
public void setPoolSize(int size)
{
if (!initialisiert)
{
initPoolSize = Größe;
zurückkehren;
}
sonst wenn (Größe > getPoolSize())
{
for (int i = getPoolSize(); i < size && i < maxPoolSize; i++)
{
TaskManage-Thread = new TaskManage(this);
thread.start();
threads.add(thread);
}
}
sonst wenn (size < getPoolSize())
{
while (getPoolSize() > Größe)
{
TaskManage th = (TaskManage) threads.remove(0);
th.kill();
}
}
}

public int getPoolSize()
{
return threads.size();
}

protected void notifyForIdleThread()
{
hasIdleThread = true;
}

protected boolean waitForIdleThread()
{
hasIdleThread = false;
while (!hasIdleThread && getPoolSize() >= maxPoolSize)
{
versuchen
{
Thread.sleep(5);
}
Catch (InterruptedException e)
{
TaskException.getResultMessage(e);
return false;
}
}

return true;
}

öffentliches synchronisiertes TaskManage getIdleThread()
{
while (wahr)
{
for (Iterator<TaskManage> itr = threads.iterator(); itr.hasNext();)
{
TaskManage th = (TaskManage) itr.next();
if (!th.isRunning()) return th;
}

if (getPoolSize() < maxPoolSize)
{
TaskManage-Thread = new TaskManage(this);
thread.start();
threads.add(thread);
Rückgabethread;
}

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

public void ProcessTask (Ausführbare Aufgabe)
{
TaskManage th = getIdleThread();
if (th != null)
{
th.putTask(task);
th.startTasks();
}
}

public void ProcessTasksInSingleThread(Runnable[]-Aufgaben)
{
TaskManage th = getIdleThread();
if (th != null)
{
th.putTasks(tasks);
th.startTasks();
}
}

public void ProcessTasksInSingleThread(Collection<Runnable> Aufgaben)
{
TaskManage th = getIdleThread();
if (th != null)
{
th.putTasks(tasks);
th.startTasks();
}
}

}

Die öffentliche Klasse TopTask implementiert Runnable
{

privater ThreadPool-Pool;

öffentliche TopTask()
{
super();
}

öffentliche TopTask (ThreadPool-Pool)
{
super();
this.pool = pool;
}

@Override
public void run()
{
init();
Start();
}

/**
* 初始化验证权限、参数之类
*/
public void init()
{

}

/**
* 开始自动任务
*/
public void start()
{
for (int i = 0; i < 10; i++)
{
pool.processTask(new BeginAuto());
}
}
}
/**
* 实现类
*/
Die Klasse BeginAuto implementiert Runnable
{
@Override
public void run()
{
System.out.println(Thread.currentThread().getId() + „..................“);
}

}