import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.Socket;
import java.util.Date;
import java.util.Vector;

public class Handler extends Thread {
    private Vector<Socket> taskQueue;
    public Handler(Vector<Socket> taskQueue,String threadName) {
        super(threadName);
        this.taskQueue = taskQueue;
    }
    @Override
    public void run() {
        /*
         * 这里使用一个死循环，保证线程完成它所分配的任务后
         * 继续回到线程池中等待分配新的任务
         * 从而实现线程重利用
         */
        while(true){
            Socket socket = null;
            synchronized(taskQueue){
                /*
                 * 如果没有排列等候的任务，所有线程一直等待
                 */
                while(taskQueue.isEmpty()){
                    try {
                        /*
                         * 一个对象调用它的wait()方法时，它会首先释放它的锁
                         * 然后导致当前线程等待
                         * 这个时候，等待taskQueue对象的锁
                         * 的线程会得到锁，进入同步块，运行到这里时，该线程也释放锁，等待。。
                         * 直到另外一个线程，调用taskQueue.notifyAll()方法，
                         * 所有在这里等待的线程，就会让taskQueue试着去得到它的锁，
                         * 如果得到了锁，才会往下执行。否则一直等待。
                         */
                        taskQueue.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                /*
                 * 任务队列中出现任务，弹出尾部的任务，保证先进先出顺序
                 */
                socket = taskQueue.remove(taskQueue.size()-1);
            }
            
            try {
                InputStream in = socket.getInputStream();
                BufferedReader reader = new BufferedReader(new InputStreamReader(in));
                String strline = null;
                while((strline=reader.readLine())!=null){
                    System.out.println(Thread.currentThread().getName()+" 处理了请求 "+strline);
                }
                reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
}

------解决方案--------------------
探讨


可不可以不要用socket这个东西啊。。我不懂啊。。我才刚开始学习多线程，尽量写简单一点的嘛。。。


------解决方案--------------------
你自己想实现一个线程池？

涉及到“池”的东西，不管是实例池、数据库连接池，还是线程池，他们的实现都是极其复杂的。如果不是精于这些东西的话，要想实现并且能运用在实际中，那就是不可能的任务。

线程池的实现，我粗粗地列举了一下，以如下技术难点：

1：如果不是使用 java.util.concurrent.LinkedBlockingQueue 的话，那就需要自行实现一个阻塞的有界或者无界队列，用于存放等待的任务

2：线程池中的线程在运行时产生异常且处理不当，这时将会产生线程泄漏，也就是说线程池中的线程少了一个。一个可用的线程池在监测到这种情况出现时应该回收该泄漏的线程，并及时补充一个新的线程

3：线程池中的线程都在工作时，若还有任务加入进来，这时需要将其放入到队列之中，若池中的某个线程工作完了，需要及时通知队列中的任务附加到可用线程中去执行

-----------------------------------
线程池基本上是这样实现的：

1：先 new 出固定数量的 Thread，类似于这样：Thread t0 = new Thread(new WorkRunnable());

WorkRunnable 的结构基本上是这样的（实际远远比这复杂）：

Java code
public class WorkRunnable implements Runnable {

    private Runnable command;

    public WorkRunnable(Runnable command) {
        this.command = command;
    }

    public void run() {
        command.run();
    }

    public void setCommand(Runnable command) {
        this.command = command;
    }
}

------解决方案--------------------
线程池的话，还是使用现成的 java.util.concurrent.ThreadPoolExecutor 吧，自己要实现的话，你和我都不可能完成！

------解决方案--------------------
Java code

public static void main(String[] args) {
    int threadMax = 5;
    ThreadPoolExecutor executor =  
            new ThreadPoolExecutor(2,threadMax,3,TimeUnit.SECONDS, new  ArrayBlockingQueue(3),new ThreadPoolExecutor.CallerRunsPolicy());
    Scanner sc = new Scanner(System.in);
    while(true){
        System.out.println("请输入：");
        final String s = sc.nextLine();
        if(threadMax == executor.getActiveCount()){
            System.out.println("线程满请稍后输入数据");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else{
            executor.execute(new Runnable(){
            public void run(){
            try {
                Thread.sleep(5000);
                System.out.println("s:" + s);
                } catch (InterruptedException e) {
                e.printStackTrace();
            }
            }
            });
        }
    }
}