线程的数量控制

在编程中，往往都需要采用线程来提高速度，但线程并不是越多越好。
1. 线程越多，JVM 所占资源越多
2. 线程越多，越容易造成资源冲突，如果处理不当，造成死锁。
所以，在启动线程的时候要根据应用程序的特点限制线程的数量。
本程序采用了java.util.concurrent的锁进行线程数量控制，测试代码如下：

/**
 * 专注互联网，分享创造价值
 *  [e-mail]
 */
package cn.jteam.app.taobao.spider;
import java.net.InetAddress;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 *
 *  作用:
 */
public class TestThreadLock {
   
    private Lock lock = new ReentrantLock();
    final Condition full = lock.newCondition();
    final CountDownLatch startSignal = new CountDownLatch(1);
    private int threads;
    CountDownLatch signal = new CountDownLatch(5);
    public void addThreads() throws Exception {
        lock.lock();
        try {
            if (threads > 5) {
                full.await();
            }
            threads++;
        } finally {
            lock.unlock();
        }
    }
    public void removeThreads() {
        lock.lock();
        try {
            if (threads <= 5) {
                full.signal();
            }
            threads--;
        } finally {
            lock.unlock();
        }
    }
    /**
     * 测试线程
     * @throws Exception
     */
    public void run() throws Exception {
        for (int i = 0; i < 10; i++) {
            addThreads();
            final int j = i;
            (new Thread() {
                @Override
                public void run() {
                    try {
                        sleep(500);
                        System.out.println("current " + j + "=" + threads);
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        removeThreads();
                        if (threads == 0) {
                            startSignal.countDown();
                        }
                    }
                }
            }).start();
        }
        startSignal.await();
    }
    public static void main0(String[] args) throws Exception {
        System.out.println("begin");
        TestThreadLock test = new TestThreadLock();
        test.run();
        System.out.println("end..........");
    }
     
}

输入结果为：
begin
current 1=6
current 0=6
current 5=5
current 3=4
current 4=4
current 2=4
current 7=4
current 6=3
current 8=3
current 9=3
end..........


这个程序里，限制了线程的数量为5，但线程超过5个时，就排队等待。