Kode contoh kumpulan thread umum di java

import java.util.Koleksi;
impor java.util.Vector;

/**
* 任务分发器
*/
TaskManage kelas publik memperluas Thread
{
tugas Vector<Runnable> yang dilindungi = Vector<Runnable>() baru;
boolean terlindung berjalan = false;
boolean yang dilindungi dihentikan = false;
boolean terlindungi dijeda = false;
boolean yang dilindungi terbunuh = false;
kolam ThreadPool pribadi;

TaskManage publik (kumpulan ThreadPool)
{
this.pool = kolam;
}

public void putTask (Tugas yang dapat dijalankan)
{
tugas.tambahkan(tugas);
}

public void putTasks(Tugas yang dapat dijalankan[])
{
for (int i = 0; i < tugas.panjang; i++)
this.tugas.tambahkan(tugas[i]);
}

public void putTasks (Tugas Koleksi<Runnable>)
{
this.tasks.addAll(tugas);
}

popTask yang dapat dijalankan yang dilindungi()
{
if (tasks.size() > 0) return (Dapat dijalankan) task.remove(0);
jika tidak, kembalikan nol;
}

boolean publik isRunning()
{
kembali berlari;
}

penghentian tugas publik()
{
berhenti = benar;
}

kekosongan publik stopTasksSync()
{
stopTugas();
sementara (sedang berjalan())
{
mencoba
{
tidur(5);
}
menangkap (InterruptedException e)
{
TaskException.getResultMessage(e);
}
}
}

kekosongan publik jedaTugas()
{
dijeda = benar;
}

kekosongan publik jedaTasksSync()
{
jedaTugas();
sementara (sedang berjalan())
{
mencoba
{
tidur(5);
}
menangkap (InterruptedException e)
{
TaskException.getResultMessage(e);
}
}
}

pembunuhan kekosongan publik()
{
if (!berjalan) interupsi();
kalau tidak terbunuh = benar;
}

kekosongan publik killSync()
{
membunuh();
sementara (isAlive())
{
mencoba
{
tidur(5);
}
menangkap (InterruptedException e)
{
TaskException.getResultMessage(e);
}
}
}

void startTasks() yang disinkronkan secara publik
{
berjalan = benar;
ini.beritahu();
}

run void tersinkronisasi publik()
{
mencoba
{
sementara (benar)
{
if (!berjalan || tugas.ukuran() == 0)
{
pool.notifyForIdleThread();
ini.tunggu();
}
kalau tidak
{
Tugas yang dapat dijalankan;
sementara ((tugas = popTask()) != null)
{
tugas.jalankan();
jika (berhenti)
{
berhenti = salah;
if (tugas.ukuran() > 0)
{
tugas.hapus();
System.out.println(Thread.currentThread().getId() + ": Tugas dihentikan");
merusak;
}
}
jika (dijeda)
{
dijeda = salah;
if (tugas.ukuran() > 0)
{
System.out.println(Thread.currentThread().getId() + ": Tugas dijeda");
merusak;
}
}
}
berjalan = salah;
}

jika (terbunuh)
{
terbunuh = salah;
merusak;
}
}
}
menangkap (InterruptedException e)
{
TaskException.getResultMessage(e);
kembali;
}
}
}

import java.util.Koleksi;
impor java.util.Iterator;
impor java.util.Vector;

/**
* 线程池
*/
ThreadPool kelas publik
{
dilindungi int maxPoolSize = TaskConfig.maxPoolSize;
dilindungi int initPoolSize = TaskConfig.initPoolSize;
thread Vector<TaskManage> yang dilindungi = Vector<TaskManage>() baru;
boolean dilindungi diinisialisasi = false;
boolean terlindung hasIdleThread = false;

Kolam Thread publik()
{
super();
}

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

kekosongan publik init()
{
diinisialisasi = benar;
untuk (int i = 0; i < initPoolSize; i++)
{
Utas TaskManage = TaskManage baru (ini);
thread.mulai();
utas.tambahkan(utas);
}
}

kekosongan publik setMaxPoolSize(int maxPoolSize)
{
this.maxPoolSize = maxPoolSize;
jika (maxPoolSize < getPoolSize()) setPoolSize(maxPoolSize);
}

/**
* 重设当前线程数 若需杀掉某线程,线程不会立刻杀掉,而会等到线程中的事
* 务处理完成 但此方法会立刻从线程池中移除该线程,不会等待事务处理结束
*/
kekosongan publik setPoolSize(ukuran int)
{
jika (!diinisialisasi)
{
initPoolSize = ukuran;
kembali;
}
lain jika (ukuran > getPoolSize())
{
untuk (int i = getPoolSize(); i < ukuran && i < maxPoolSize; i++)
{
Utas TaskManage = TaskManage baru (ini);
thread.mulai();
utas.tambahkan(utas);
}
}
lain jika (ukuran < getPoolSize())
{
sementara (getPoolSize() > ukuran)
{
TaskManage th = (TaskManage) thread.remove(0);
th.kill();
}
}
}

int publik getPoolSize()
{
return thread.size();
}

dilindungi kekosongan notifyForIdleThread()
{
hasIdleThread = benar;
}

boolean yang dilindungi waitForIdleThread()
{
hasIdleThread = salah;
sementara (!hasIdleThread && getPoolSize() >= maxPoolSize)
{
mencoba
{
Thread.tidur(5);
}
menangkap (InterruptedException e)
{
TaskException.getResultMessage(e);
kembali salah;
}
}

kembali benar;
}

TaskManage getIdleThread() yang disinkronkan secara publik
{
sementara (benar)
{
untuk (Iterator<TaskManage> itr = thread.iterator(); itr.hasNext();)
{
Pengelolaan Tugas th = (Manajemen Tugas) itr.next();
if (!th.isRunning()) kembalikan th;
}

jika (getPoolSize() < maxPoolSize)
{
Utas TaskManage = TaskManage baru (ini);
thread.mulai();
utas.tambahkan(utas);
kembalikan utas;
}

jika (waitForIdleThread() == false) mengembalikan nol;
}
}

public void processTask (Tugas yang dapat dijalankan)
{
Pengelolaan Tugas th = getIdleThread();
jika (th != nol)
{
th.putTask(tugas);
th.startTasks();
}
}

public void processTasksInSingleThread(Tugas yang dapat dijalankan[])
{
Pengelolaan Tugas th = getIdleThread();
jika (th != nol)
{
th.putTasks(tugas);
th.startTasks();
}
}

public void processTasksInSingleThread(Tugas Koleksi<Runnable>)
{
Pengelolaan Tugas th = getIdleThread();
jika (th != nol)
{
th.putTasks(tugas);
th.startTasks();
}
}

}

kelas publik TopTask mengimplementasikan Runnable
{

kolam ThreadPool pribadi;

Tugas Utama publik()
{
super();
}

TopTask publik (kumpulan ThreadPool)
{
super();
this.pool = kolam;
}

@Mengesampingkan
menjalankan kekosongan publik()
{
init();
awal();
}

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

}

/**
* 开始自动任务
*/
kekosongan publik mulai()
{
untuk (int saya = 0; saya < 10; saya++)
{
pool.processTask(baru BeginAuto());
}
}
}
/**
* 实现类
*/
kelas BeginAuto mengimplementasikan Runnable
{
@Mengesampingkan
menjalankan kekosongan publik()
{
System.out.println(Thread.currentThread().getId() + "..................");
}

}