培训老师给我们做的一个聊天小程序，大家看看好不？

Question

学校老师组织培训，我们的培训老师当时给我们做了一个小的聊天室的程序是用的命令行，10几分钟就做出来了，而且还一边打一边给我们讲解，感觉老师好厉害，大家给点建议，赫赫……import java.util.*;
import java.net.*;
import java.io.*;public class Server{
public static final int port=10000;
public static final Vector users=new Vector();
public static void main(String args[]){
ServerSocket server=null;
try{
server=new ServerSocket(port);
System.out.println("Server start up on port :"+port);
while(true){
Socket s=server.accept();
User user=new User(s);
user.start();
}
}catch(Exception e){
e.printStackTrace();
}finally{ if(server!=null&&!server.isClosed()){
try{server.close();}catch(Exception e){}
}
}
}}class User extends Thread{
private Socket s;
private String userName;
private InetAddress ip;
public User(Socket s){
this.s=s;
}
public void run(){
try{
InputStream input=s.getInputStream();
OutputStream output=s.getOutputStream();
BufferedReader buf=new 
BufferedReader(new 
InputStreamReader(input));
PrintWriter pw=new 
PrintWriter(new OutputStreamWriter(output),true);

pw.println("welcome u ,enter your name :");
userName=buf.readLine();
Server.users.add(this);
sendAll(userName+" has join us ");;
long t=0;
while(true){
String line=buf.readLine();
long s=System.currentTimeMillis();
if((s-t)/1000<3){
pw.println("flush denied ");
continue;
}
t=s;
if(line==null||line.trim().length()==0){
pw.println("flush denied ");
continue;
}
if(line.equals("bye")){
sendAll(userName+" leave us ");
Server.users.remove(this);
break;

} sendAll(userName+" said :"+line);
}
}catch(Exception e){
//e.printStackTrace();
}finally{
if(s!=null)try{s.close();}catch(Exception e){}
}
}
public  synchronized void sendMessage(String message){
try{
PrintWriter pw=new 
PrintWriter(new OutputStreamWriter(
s.getOutputStream()));
pw.println(message);
pw.flush();
}catch(Exception e){}
}
public void sendAll(String message){
Iterator it=Server.users.iterator();
while(it.hasNext()){
User user=(User)it.next();
user.sendMessage(message);
}
}
}

Answer 1

老师就要达到这水平。
我当初的老师教我们写http server. 

Answer 2

答：说句楼主可能不高兴的话：你的培训老师的水平比较差。连这种基本的但同时又是严重的错误都不知道，怎不知道培训出你们这样的学生，水平就更差了。
楼主知道程序中有什么严重错误吗？
我提醒一下楼主看知道不知道：程序会发生java.util.ConcurrentModificationException这个严重的错误。
去问一下你们的老师吧。问一问为什么。

Answer 3

10楼的,我记得int变量完全可以保存10000.不要误导别人.
short取值范围是-32768~32767
int取值范围是-2147483648~2147483647
long取值范围是-9223372036854775808~9223372036854775807
即使是C语言int变量取值范围-32768~32767也完全可以存储10000.
而且端口本来是以c语言的无符号int定义的,范围是0-65535.

Answer 4

java.util.ConcurrentModificationException这个错误理论上会出现，位置在User user=(User)it.next();情况是Vector迭代的时候有其他线程修改了这个Vector。应该同步访问。

Answer 5

答：你看，又是一个培训出的比较差的学生，你都没有看懂我所说的错误是什么？这与什么int是一点关系都没有的。

Answer 6

解释一下，当时老师用的是linux系统的字符界面没有设置中文环境，所以并没有添加注释，并且在一边讲课一边打代码的情况下并不需要添加注释。

Answer 7

呵呵，不高兴倒是没有，向10楼请教！小弟刚开始学习Java所以内功相当的差劲。我会向老师请教的……

Answer 8

小弟才疏学浅，
貌似，Vector是纯粹的线程安全的类，
就连其迭代器Iterator对象，其方法也是线程安全滴，所以，这个类的使用对系统的开销相对较大。
正因为是线程安全滴，所以，就不会抛出java.util.ConcurrentModificationException这个异常。
java.util.ConcurrentModificationException这个异常，只有在多线程访问同一个非线程安全的集合类对象时，才有可能抛出。比如，List list = Collections.synchronizedList(new ArrayList());这个list对象，
其相关操作并不会抛那个异常，而如果多线程对其用迭代器访问，就会抛出那个异常。
因为，list对象本身是线程安全滴，但是，其迭代器对象并非线程安全滴。

Answer 9

稍微修改了一下代码，又添加了Client.java；聊天程序基本可以运行；package test.net;import java.util.*;
import java.net.*;
import java.io.*;public class Server{
    public static final int port=10000;
    public static final Vector<User> users=new Vector<User>();
    public static void main(String args[]){
        ServerSocket server=null;
        try{
            server=new ServerSocket(port);
            System.out.println("Server start up on port :"+port);
            while(true){
                Socket s=server.accept();
                User user=new User(new BufferedReader(new InputStreamReader(s.getInputStream())), 
                 new PrintWriter(s.getOutputStream(),true)
                );
                user.start();
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            if(server!=null&&!server.isClosed()){
                try{server.close();}catch(Exception e){}
            }
        }
    }
}
class User extends Thread{
private BufferedReader reader;
private PrintWriter writer;
    private String userName;
    public User(BufferedReader reader, PrintWriter writer){
        this.reader = reader;
        this.writer = writer;
    }
    public void run(){
        try{
         writer.println("welcome u ,enter your name :");
            userName=reader.readLine();
            Server.users.add(this);
            sendAll(userName+" has join us ");
            while(true){
                String line=reader.readLine();
                if(line==null||line.trim().length()==0){
                 writer.println("flush denied ");
                continue;
                }
                else if(line.equals("bye")){
                    sendAll(userName+" leave us ");
                    Server.users.remove(this);    
                    break;
                }
                else{
                 sendAll(userName+" said :"+line);
                }
            }        
        }catch(Exception e){
        }finally{
            try {
reader.close();
} catch (IOException e) {
}
            writer.close();
        }
    }
    public  synchronized void sendMessage(String message){
        try{
         writer.println(message);
         writer.flush();
        }catch(Exception e){}
    }
    public void sendAll(String message){
        Iterator it=Server.users.iterator();
        while(it.hasNext()){
            User user=(User)it.next();
            user.sendMessage(message);
        }
    }
}Client.java:package test.net;import java.io.*;
import java.net.*;public class Client {
public static void main(String[] args) throws UnknownHostException, IOException {
Socket socket = new Socket("127.0.0.1", 10000);
//向server写消息
PrintWriter msgWriter = new PrintWriter(socket.getOutputStream());
//从控制台读取输入
BufferedReader msgMaker = new BufferedReader(new InputStreamReader(System.in));
//从server读消息
BufferedReader msgReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
while(true){
String msgRead = msgReader.readLine();
System.out.println("Server: " + msgRead );
String msgSend = msgMaker.readLine();
System.out.println("Me: " + msgSend);
msgWriter.println(msgSend);
msgWriter.flush();
if("bye".equals(msgSend)){
break;
}
}
System.out.println("Server: " + msgReader.readLine() );
msgWriter.close();
msgMaker.close();
msgReader.close();
}
}

Answer 10

答：对23楼和25楼的两位兄弟，我真是无语了。你们真的看不出程序中的问题？而且还不是一处？
最基本与最严重的问题就是：java.util.ConcurrentModificationException这个异常。任何真正有经验写多线程的程序员，程序一写到此处，都会自然而本能的感觉到的[正是基本这一点，我才说那个老师是没有这个感觉的]。23楼的兄弟根本就不清楚：ConcurrentModificationException这个异常的真正本质是什么。23楼的这句话是错误的：
“Vector是纯粹的线程安全的类，就连其迭代器Iterator对象，其方法也是线程安全滴，因为是线程安全滴，所以，就不会抛出java.util.ConcurrentModificationException这个异常。”
上边这句话明显是错误的。17楼讲了部分原因。你们自己想吧，我已无语了。

Answer 11

运行后只显示Server start up on port :10000
其他什么反映也米有

Answer 12

答：多线程程序设计的困难就在于：程序中的错误出现的时机是不定的。那种认为：我运行了程序，没有出现什么java.util.ConcurrentModificationException异常啊，程序是正确的话。
这真的是太幽默搞笑了。

Answer 13

迭代的时候,因为多线程,有可能有其他线程对Vector操作,所以会抛该异常

Answer 14

我的java老师要是有这么厉害就好了
依然清晰的记得第一党课，我问老师怎么把以后的工程文件夹导入MyEclipse，楞是把她问住了
从此以后再也不敢问任何问题

Answer 15

    public void sendAll(String message){
        Iterator it=Server.users.iterator();
        while(it.hasNext()){
            User user=(User)it.next();
            user.sendMessage(message);
        }
        it.removed();  //这样吗？
    }

Answer 16

大师，也没有多线程的经验， 所以也无法领会多线程的玄妙所在。但在这里我也比较迷惑。
Vector的Iterator(AbstractList$Itr)的next方法：
public E next() {
            checkForComodification();
    try {
E next = get(cursor);
lastRet = cursor++;
return next;
    } catch(IndexOutOfBoundsException e) {
checkForComodification();
throw new NoSuchElementException();
    }
}
是没有synchronized,但是它调用的get方法有(Vector的)。
    public synchronized E get(int index) {
if (index >= elementCount)
    throw new ArrayIndexOutOfBoundsException(index);
return (E)elementData[index];
    }
如果你愿意帮忙看,我一会儿开一个帖子来向你学习multithread.

Answer 17

不如像我们北大青鸟直接做MyQQ拉到了,功能扩展性很好

Answer 18

学习人生就为做站 http://www.icjyw.com

Answer 19

你他妈的就是一个SBBBBBBBBBBBBBBBBBBB

Answer 20

java.util.ConcurrentModificationException跟多线程没必然关系吧，单线程在迭代的时候更改了集合也一样会出现
不过多线程必须要考虑同步的问题

Answer 21

public class ConcurrentModificationExceptionextends RuntimeException当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。 例如，某个线程在 Collection 上进行迭代时，通常不允许另一个线性修改该 Collection。通常在这些情况下，迭代的结果是不明确的。如果检测到这种行为，一些迭代器实现（包括 JRE 提供的所有通用 collection 实现）可能选择抛出此异常。执行该操作的迭代器称为快速失败 迭代器，因为迭代器很快就完全失败，而不会冒着在将来某个时间任意发生不确定行为的风险。 注意，此异常不会始终指出对象已经由不同 线程并发修改。如果单线程发出违反对象协定的方法调用序列，则该对象可能抛出此异常。例如，如果线程使用快速失败迭代器在 collection 上迭代时直接修改该 collection，则迭代器将抛出此异常。 注意，迭代器的快速失败行为无法得到保证，因为一般来说，不可能对是否出现不同步并发修改做出任何硬性保证。快速失败操作会尽最大努力抛出 ConcurrentModificationException。

Answer 22

ConcurrentModificationException...
就在这个程序里看来，当第一次创建了vector的迭代时，类似add，remove，next等方法就会造成将来不确定的时间任意发生不确定行为的风险，
而此时就会抛出这个异常，因为这些方法对vector的结构造成了改变，所以不能这么用vector的迭代哦。

Answer 23

ConcurrentModificationException...
就在这个程序里看来，当第一次创建了vector的迭代时，类似add，remove，next等方法就会造成将来不确定的时间任意发生不确定行为的风险，
而此时就会抛出这个异常，因为这些方法对vector的结构造成了改变，所以不能这么用vector的迭代哦。

Answer 24

ConcurrentModificationException...
就在这个程序里看来，当第一次创建了vector的迭代时，类似add，remove，next等方法就会造成将来不确定的时间任意发生不确定行为的风险，
而此时就会抛出这个异常，因为这些方法对vector的结构造成了改变，所以不能这么用vector的迭代哦。

Answer 25

答：sunxing007兄弟，我现在才有时间上网，回复晚些，请见谅。
“大师，不要故意卖关子了，直接说吧，我们才疏学浅，您要是还藏着掖着，估计会有人觉得你太不诚恳了！”我不是故意卖关子，而是现在才有时间上网，我不可能整天挂在网上，我有工作要做。sunxing007兄弟，程序中的错误主要在于：在多线程下使用List时，无论该List是否同步（Vector等），在iterator()遍历时，整个遍历过程必要要同步。否则会发生：ConcurrentModificationException异常。即：设计iterator()时的意图就是：在遍历过程中，List的结构是不能改变的。这是由：checkForComodification()来检查的。该java.util.ConcurrentModificationException异常就是由它来抛出的。其实我感到很吃惊的是：这是个基本常识，又不是什么高深的理论。为何大家对我如此攻击？尤其是40楼的javaboyy,都快要杀人了。回贴晚了些，就要杀人了？？？

Answer 26

while(true)
"哇好厉害啊～"  

Answer 27

关注这个帖子很久了，最近重看O'REILLY版的《HEAD FIRST JAVA》，到第十五章 网络与线程，发现里面也有这段聊天室的程序
import java.io.*;
import java.net.*;
import java.util.*;public class VerySimpleChatServer {    ArrayList<PrintWriter> clientOutputStreams;
    public class ClientHandler implements Runnable {         BufferedReader reader;
       
         Socket sock;
            public ClientHandler(Socket clientSocket) {
           try {
             sock = clientSocket;
             InputStreamReader isReader = new InputStreamReader(sock.getInputStream());
             reader = new BufferedReader(isReader);
              
           } catch(Exception ex) {ex.printStackTrace();}
          } // close constructor        public void run() {
           String message;
             
           try {             while ((message = reader.readLine()) != null) {
                        
                System.out.println("read " + message);
                tellEveryone(message);
    
              } // close while
           } catch(Exception ex) {ex.printStackTrace();}
       } // close run
   } // close inner class
           public static void main (String[] args) {
         new VerySimpleChatServer().go();
    }     public void go() {
      clientOutputStreams = new ArrayList<PrintWriter>();       try {
       ServerSocket serverSock = new ServerSocket(5000);       while(true) {
          Socket clientSocket = serverSock.accept();
          PrintWriter writer = new PrintWriter(clientSocket.getOutputStream());         
          clientOutputStreams.add(writer);       Thread t = new Thread(new ClientHandler(clientSocket));
       t.start();
       System.out.println("got a connection");
     }
       // now if I get here I have a connection
               
      }catch(Exception ex) {
         ex.printStackTrace();
      }
   }   public void tellEveryone(String message) {
      Iterator it = clientOutputStreams.iterator();
      while(it.hasNext()) {
        try {
           PrintWriter writer = (PrintWriter) it.next();
           writer.println(message);
           writer.flush();
         } catch(Exception ex) {
              ex.printStackTrace();
         }
      
       } // end while
       
   } // close tellEveryone
}
       
楼主老师从传达网络这部分知识上来说合格了，但是从线程安全这个角度来看，楼主老师和伟大的HEAD FIRST作者被10楼高手一同看破，高手多次怒我等不争，而对此错误解决方法又不语，实在令我等围观”上等心法“的人纠结啊

Answer 28

while(true)
不是什么大问题，只是一个线程等在哪里不停地等待用户输入，想要结束可以直接用interrupt直接打断线程。

Answer 29

照抄API有什么不好？抄多了API，你自己也就会了。我个人经常就抄API，呵呵

Answer 30

在循环中使用了Server.users.remove(this);对集合的结构造成了改变,就有可能抛出异常

Answer 31

顶一个，虽然是基本的，但有时确实不会关注这些基本的东西，直到有人点拨，我才发现确实没什么高深的，
学会看源码：private void checkForComodification() {
    if (l.modCount != expectedModCount)
        throw new ConcurrentModificationException();
}并且这个方法被多处调用，如：next(),remove(),previous(),set(),add()……等等
就这两句源码，去看下就知道了，引来这么多争论实为不值。
这里我只想感谢点谢这位点拨的人。

Answer 32

从来没有耐心看过别人发上来程序的BK留改用HashMap会不会好些？

Answer 33

你貌似完全没有理解10楼的意思。。他说的是多线程访问同一个vcollection时发生的修改异常。

Answer 34

这就和围棋中的指导棋一样，下指导棋只是高手指引菜鸟往正确的方向去下，而非处处紧逼，杀得菜鸟片甲不留。所以我们不能通过一盘指导棋来评论双方的实力水平。也许他们老师做实际的项目，又会是完全不同的代码和效果。但有一点可以肯定的是，实战的高手未必能当好老师，未必能把自己的想法通俗易懂的表达出来。另外争对jiangnaisong 说几句，如果你51楼的分析放在10楼，你就不会被别人说是装B，而且被骂。

Answer 35

进来一看发现是Java，而我是现在搞的时.NET，就没有看了。

Answer 36

认为很对的,要是会的高手都只是看着我们新手在那讨论的话那csdn也就没有意思了.....

Answer 37

先MARK看起来一点都不难，就是用java.net包的方法哦，一会拿家里电脑做试验

Answer 38

引用 29 楼 jiangnaisong 的回复: 
引用 28 楼 baetg 的回复: 
运行后只显示Server start up on port :10000 
其他什么反映也米有 
答：多线程程序设计的困难就在于：程序中的错误出现的时机是不定的。那种认为：我运行了程序，没有出现什么java.util.ConcurrentModificationException异常啊，程序是正确的话。 
这真的是太幽默搞笑了。 
你他妈的就是一个SBBBBBBBBBBBBBBBBBBB