生产线程（控制同时运行线程总量）

用处：多线程编程中，限制线程的总数量。

使用方式：

Runnable runnable = 一个实现了Runnable接口的对象 ;

ProductThread pt = ThreadProducer.instance().getThread(runnable) ;
pt.start() ;

ProductThread.java

package net.xy.timer;
/**
* 线程
* @author ooi
*
*/
public class ProductThread extends Thread{

public ProductThread(Runnable runnable){
super(runnable) ;
}

public void run(){
super.run() ;
//收尾
ThreadProducer.instance().remove(this) ;
}

}

ThreadProducer.java

package net.xy.timer;

import java.util.ArrayList;
import java.util.List;

/**
* 线程生成者
* 生产方式：有需求则生产
* 限制：同时处于使用中的线程只能有N个
* 如果当前不可生成，则进入等待状态，直到到达可以生产条件
* @author ooi
*
*/
public class ThreadProducer {
//单例
private static ThreadProducer m = null ;
private ThreadProducer(){
init() ;
}
public static ThreadProducer instance(){
if( m == null ){
m = new ThreadProducer() ;
}
return m ;
}

/**
* 同时处于使用中的线程最多能有几个
*/
public static final int MAX_COUNT = 16 ;

/**
* 所有没有使用结束的线程
*/
private List<ProductThread> productThreadList ;

/**
* 获取线程总数
*/
public int getThreadCount(){
synchronized (productThreadList) {
System.out.println(productThreadList.size());
return productThreadList.size() ;
}
}

/**
* 初始化
*/
private void init(){
productThreadList = new ArrayList<ProductThread>() ;
}

/**
* 生成一个线程<br>
* 如果当前不可生成，则进入等待状态，直到到达可以生产条件
*/
public ProductThread getThread(Runnable runnable){
//判断限制条件
if( getThreadCount() >= MAX_COUNT ){
synchronized (this) {
try {
this.wait() ;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//生成线程
ProductThread productThread = new ProductThread(runnable) ;
synchronized (productThreadList) {
productThreadList.add(productThread) ;
}
return productThread ;
}

/**
* 移除使用结束的线程（一定要移除）
* @param productThread
*/
public void remove(ProductThread productThread){
synchronized (productThreadList) {
productThreadList.remove(productThread) ;
}
if( getThreadCount() < MAX_COUNT ){
synchronized (this) {
this.notify() ;
}
}
}

}