Exemple de code de pool de threads commun en Java

importer java.util.Collection ;
importer java.util.Vector ;

/**
* 任务分发器
*/
la classe publique TaskManage étend le fil
{
tâches Vector<Runnable> protégées = new Vector<Runnable>();
booléen protégé en cours d'exécution = faux ;
booléen protégé arrêté = faux ;
booléen protégé en pause = faux ;
booléen protégé tué = faux ;
pool ThreadPool privé ;

TaskManage public (pool ThreadPool)
{
this.pool = pool;
}

public void putTask (tâche exécutable)
{
tâches.ajouter(tâche);
}

public void putTasks (tâches Runnable[])
{
pour (int i = 0; i < tâches.longueur; i++)
this.tasks.add(tâches[i]);
}

public void putTasks (tâches Collection<Runnable>)
{
this.tasks.addAll(tâches);
}

popTask exécutable protégé()
{
if (tasks.size() > 0) return (Runnable) tâches.remove(0);
sinon, renvoie null ;
}

public booléen isRunning()
{
revenir en courant;
}

public void stopTasks()
{
arrêté = vrai ;
}

public void stopTasksSync()
{
stopTasks();
pendant que (est en cours d'exécution ())
{
essayer
{
dormir(5);
}
attraper (InterruptedException e)
{
TaskException.getResultMessage(e);
}
}
}

public void pauseTasks()
{
en pause = vrai ;
}

public void pauseTasksSync()
{
pauseTasks();
pendant que (est en cours d'exécution ())
{
essayer
{
dormir(5);
}
attraper (InterruptedException e)
{
TaskException.getResultMessage(e);
}
}
}

public void kill()
{
si (!running) interruption();
sinon tué = vrai ;
}

public vide killSync()
{
tuer();
pendant que (isAlive())
{
essayer
{
dormir(5);
}
attraper (InterruptedException e)
{
TaskException.getResultMessage(e);
}
}
}

startTasks vides synchronisés publics ()
{
en cours d'exécution = vrai ;
this.notify();
}

exécution vide synchronisée publique ()
{
essayer
{
tandis que (vrai)
{
si (!running || tâches.size() == 0)
{
pool.notifyForIdleThread();
ceci.attendre();
}
autre
{
Tâche exécutable ;
while ((tâche = popTask()) != null)
{
tâche.run();
si (arrêté)
{
arrêté = faux ;
si (tâches.size() > 0)
{
tâches.clear();
System.out.println(Thread.currentThread().getId() + " : Les tâches sont arrêtées");
casser;
}
}
si (en pause)
{
en pause = faux ;
si (tâches.size() > 0)
{
System.out.println(Thread.currentThread().getId() + " : Les tâches sont en pause");
casser;
}
}
}
en cours d'exécution = faux ;
}

si (tué)
{
tué = faux ;
casser;
}
}
}
attraper (InterruptedException e)
{
TaskException.getResultMessage(e);
retour;
}
}
}

importer java.util.Collection ;
importer java.util.Iterator ;
importer java.util.Vector ;

/**
* 线程池
*/
Classe publique ThreadPool
{
protected int maxPoolSize = TaskConfig.maxPoolSize;
protected int initPoolSize = TaskConfig.initPoolSize;
protected Vector<TaskManage> threads = new Vector<TaskManage>();
booléen protégé initialisé = faux ;
protégé booléen hasIdleThread = false;

Pool de Threads public()
{
super();
}

pool de threads public (int maxPoolSize, int initPoolSize)
{
this.maxPoolSize = maxPoolSize;
this.initPoolSize = initPoolSize;
}

initialisation vide publique()
{
initialisé = vrai ;
pour (int i = 0; i < initPoolSize; i++)
{
Fil de discussion TaskManage = new TaskManage(this);
thread.start();
threads.add(thread);
}
}

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

/**
*
* 务处理完成 但此方法会立刻从线程池中移除该线程，不会等待事务处理结束
*/
public void setPoolSize (taille int)
{
si (!initialisé)
{
initPoolSize = taille ;
retour;
}
sinon si (taille > getPoolSize())
{
pour (int i = getPoolSize(); i < taille && i < maxPoolSize; i++)
{
Fil de discussion TaskManage = new TaskManage(this);
thread.start();
threads.add(thread);
}
}
sinon si (taille < getPoolSize())
{
tandis que (getPoolSize() > taille)
{
TaskManage th = (TaskManage) threads.remove(0);
th.kill();
}
}
}

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

protégé void notifyForIdleThread()
{
hasIdleThread = vrai ;
}

booléen protégé waitForIdleThread()
{
hasIdleThread = faux ;
tandis que (!hasIdleThread && getPoolSize() >= maxPoolSize)
{
essayer
{
Thread.sleep(5);
}
attraper (InterruptedException e)
{
TaskException.getResultMessage(e);
renvoie faux ;
}
}

renvoie vrai ;
}

TaskManage synchronisé public getIdleThread()
{
tandis que (vrai)
{
pour (Iterator<TaskManage> itr = threads.iterator(); itr.hasNext();)
{
TaskManage th = (TaskManage) itr.next();
if (!th.isRunning()) renvoie th ;
}

si (getPoolSize() < maxPoolSize)
{
Fil de discussion TaskManage = new TaskManage(this);
thread.start();
threads.add(thread);
fil de retour ;
}

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

public void processTask (tâche exécutable)
{
TaskManage th = getIdleThread();
si (th != nul)
{
th.putTask(tâche);
th.startTasks();
}
}

public void processTasksInSingleThread (tâches Runnable[])
{
TaskManage th = getIdleThread();
si (th != nul)
{
th.putTasks(tâches);
th.startTasks();
}
}

public void processTasksInSingleThread (Collection<Runnable> tâches)
{
TaskManage th = getIdleThread();
si (th != nul)
{
th.putTasks(tâches);
th.startTasks();
}
}

}

classe publique TopTask implémente Runnable
{

pool ThreadPool privé ;

TopTask publique()
{
super();
}

TopTask publique (pool ThreadPool)
{
super();
this.pool = pool;
}

@Outrepasser
exécution publique vide()
{
init();
commencer();
}

/**
* 初始化验证权限、参数之类
*/
initialisation vide publique()
{

}

/**
* 开始自动任务
*/
début public vide()
{
pour (int i = 0; i < 10; i++)
{
pool.processTask(nouveau BeginAuto());
}
}
}
/**
* 实现类
*/
la classe BeginAuto implémente Runnable
{
@Outrepasser
exécution publique vide()
{
System.out.println(Thread.currentThread().getId() + "...................");
}

}