public class Client {

public static void main(String[]args) throws UnkNownHostException,IOException
{
    System.out.println("客户端启动中...");
    BufferedReader br =new BufferedReader(new InputStreamReader(system.in));
    System.out.println("请输入用户名:");
    String name=br.readLine();
    Socket client =new Socket("localhost",9999);

    new Thread(new Send(client,name)).start();//在线程还没启动之前，通过构造方法发送名称,先于信息的发送，
    //因为接收信息时，名称已经发送并被读取到变量中

    new Thread(new Receive(client)).start();

}
}

作为释放资源工具类

public class utils {

public static void close(Closeable... target )
{
    for(Closeable it:target)
    {
            try {
                if(null!=it)
                {
                it.close();
                }
            } catch (IOException e) {

                e.printstacktrace();
            }

    }       
}
}

客户端的发送端封装了：
发送消息
从键盘读取消息
run()
释放资源

public class Send implements Runnable{

private BufferedReader br;
private DataOutputStream dos;
private Socket client;
private boolean flag=true;
private String name;

public Send(Socket client,String name)
{
    this.client=client;
    this.name=name;
    br=new BufferedReader(new InputStreamReader(system.in));
    try {
        dos=new DataOutputStream(client.getoutputStream());
        //发送名称
        send(name);
    } catch (IOException e) {

        this.release();
    }
}
public void run()
{
    while(flag)
    {
        String msg=getstr();
        send(msg);

    }
}
private void release()
{
    this.flag=false;
    utils.close(dos,client);
}
//从控制台获取消息
private String getstr()
{
    try {
        String msg=br.readLine();
        return msg;
    } catch (IOException e) {

        e.printstacktrace();
    }
    return null;
}
private void send(String msg)
{
    try {
        dos.writeUTF(msg);
        dos.flush();

    } catch (IOException e) {
    release();
    }
}
}

客户端的接收端封装了:
接收消息
run()
释放资源

public class Receive implements Runnable {
private DataInputStream dis;
private Socket client;
private boolean flag=true;

public Receive(Socket client)
{
    this.client=client;
    try {
        dis=new DataInputStream(client.getInputStream());
    } catch (IOException e) {
        release();
    }
}

private String receive()
{
    String msg;
    try {
        msg = dis.readUTF();
        return msg;
    } catch (IOException e) {
        release();
    }
    return null;
}
public void run()
{
    while(flag)
    {
        String msg=receive();
        System.out.println(msg);
    }

}
private void release()
{
    this.flag=false;
    utils.close(dis,client);
}
}

在线聊天室
服务器：

public class Chat {
private static copyOnWriteArrayList<channel> list=new copyOnWriteArrayList<>();//使用并发容器，适合多线程
public static void main(String[]args) throws IOException
{
    System.out.println("服务器启动中...");

    ServerSocket server=new ServerSocket(9999);

    while(true)
    {
        Socket client =server.accept();
        System.out.println("一个客户端建立了连接");
        channel c=new channel(client);
        list.add(c);  //容器管理所有成员
        new Thread(c).start();

    }

}

static class channel implements Runnable{
    private DataInputStream dis;
    private DataOutputStream dos;
    private BufferedReader br;
    private Socket client;
    private boolean flag;
    private String name;

    public channel(Socket client)
    {
        this.client=client;
        try {
            dis=new DataInputStream(client.getInputStream());
            dos=new DataOutputStream(client.getoutputStream());
            flag=true;

            //获取名称
            this.name=receive();
            //欢迎到来
            this.send("欢迎来到聊天室");
            this.sendothers(this.name+"来到了聊天室",true);

        } catch (IOException e) {
            release();          }
    }
    //接收消息
    private String receive() 
    {
        try {
            String msg=dis.readUTF();
            return msg;
        } catch (IOException e) {
            release();
        }
        return null;

    }
    //发送给消息
    private void send(String msg)
    {
        try {
            dos.writeUTF(msg);
            dos.flush();
        } catch (IOException e) {
            release();
        }

    }
    //群聊:获取自己的消息，发给其他人和私聊功能
    private void sendothers(String msg,boolean issys)
    {
        boolean issecrete =msg.startsWith("@");
        if(issecrete)
        {
            int index=msg.indexOf(":");
            String target=msg.substring(1,index);
            msg=msg.substring(index+1);

            for(channel it:list)
            {
                if(it.name.equals(target)) //查找目标
                {
                    it.send(this.name+"悄悄地对你说:"+msg); //私聊消息
                    break;
                }
            }
        }else
        {
            for(channel it:list)
            {
                if(it==this)
                {
                    continue;
                }
                if(!issys)
                {
                    it.send(this.name+":"+msg);
                }else
                {
                    it.send(msg);
                }
            }
        }
    }
    private void release()
    {
        this.flag=false;
        utils.close(dis,dos,client); //写一个工具类,使用Closeable...可变参数    
        //退出时，从容器里面移掉自身
        list.remove(this);
        sendothers("离开了聊天室",false);
    }
    public void run()
    {
        while(flag)
        {
            String msg=receive();
            sendothers(msg,false);
        }
        release();

    }

}
}

#include "ace/SOCK_Acceptor.h"
#include "ace/SOCK_Stream.h"
#include "ace/Log_Msg.h"
#define SIZE_DATA 18
#define SIZE_BUF 1024
#define NO_ITERATIONS 5

class Server
{
public:
    ///初始化
    Server(int port): server_addr_(port),peer_acceptor_(server_addr_)
    {
        data_buf_= new char[SIZE_BUF];
    }
    
    ///建立监听
    int accept_connections()
    {
        if (peer_acceptor_.get_local_addr (server_addr_) == -1)
        {
            ACE_ERROR_RETURN ((LM_ERROR,"%p\n","Error in get_local_addr"),1);
            ACE_DEBUG ((LM_DEBUG,"Starting server at port %d\n",
                server_addr_.get_port_number ()));
        }
        while(1)
        {
            ACE_Time_Value timeout (ACE_DEFAULT_TIMEOUT);
            if (peer_acceptor_.accept (new_stream_, &client_addr_, &timeout)== -1)
            {
                ACE_ERROR ((LM_ERROR, "%p\n", "accept"));
                continue;
            }
            else
            {
                ACE_DEBUG((LM_DEBUG,
                    "Connection established with remote %s:%d\n",
                    client_addr_.get_host_name(),client_addr_.get_port_number()));
                handle_read();
            }
        }
    }

    ///读取流内容
    int handle_read()
    {
        for(int i=0;i<NO_ITERATIONS;i++)
        {
            int byte_count=0;
            if( (byte_count=new_stream_.recv_n (data_buf_, SIZE_DATA, 0))==-1)
            {
                ACE_ERROR ((LM_ERROR, "%p\n", "Error in recv"));
            }
            else
            {
                data_buf_[byte_count]=0;
                ACE_DEBUG((LM_DEBUG,"Server received %s \n",data_buf_));
            }
        }
        if (new_stream_.close () == -1)
        {
            ACE_ERROR ((LM_ERROR, "%p\n", "close"));
        }
        return 0;
    }
private:
    char *data_buf_;

    ACE_INET_Addr server_addr_;//地址

    ACE_INET_Addr client_addr_;

    ACE_SOCK_Acceptor peer_acceptor_;

    ACE_SOCK_Stream new_stream_;//流

};

int ACE_TMAIN (int, ACE_TCHAR *[])
{

    Server server(8002);
    server.accept_connections();
    
    return 0;
};

#include "ace/SOCK_Connector.h"
#include "ace/INET_Addr.h"
#include "ace/Log_Msg.h"
#define SIZE_BUF 128
#define NO_ITERATIONS 5

class Client
{
public:
    Client(char *hostname, int port):remote_addr_(port,hostname)
    {
        data_buf_="Hello from Client";
    }

    int connect_to_server()
    {
        ACE_DEBUG ((LM_DEBUG, "(%P|%t) Starting connect to %s:%d\n",
            remote_addr_.get_host_name(),remote_addr_.get_port_number()));

        if (connector_.connect (client_stream_, remote_addr_) == -1)
        {
            ACE_ERROR_RETURN ((LM_ERROR,"(%P|%t) %p\n","connection failed"),-1);
        }
        else
        {
            ACE_DEBUG ((LM_DEBUG,"(%P|%t) connected to %s\n",
                remote_addr_.get_host_name ()));
        }

        return 0;

    }

    int send_to_server()
    {
        for(int i=0;i<NO_ITERATIONS; i++)
        {
            if (client_stream_.send_n (data_buf_,
                ACE_OS::strlen(data_buf_)+1, 0) == -1)
            {
                ACE_ERROR_RETURN ((LM_ERROR,"(%P|%t) %p\n","send_n"),0);
                break;
            }
        }
        close();
    }

    int close()
    {
        if (client_stream_.close () == -1)
        {
            ACE_ERROR_RETURN ((LM_ERROR,"(%P|%t) %p\n","close"),-1);
        }
        else
        {
            return 0;
        }
    }
private:
    ACE_SOCK_Stream client_stream_;

    ACE_INET_Addr remote_addr_;

    ACE_SOCK_Connector connector_;

    char *data_buf_;

};

int ACE_TMAIN (int, ACE_TCHAR *[])
{

    Client client("127.0.0.1", 8002);    
    client.connect_to_server();
    client.send_to_server();
    
    return 0;
};

解决方法

package com.hejun.socket.TCP;

import com.hejun.socket.UDP.MsgPool;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class TCPService {

    public void start(){
        try {
            //创建ServerSocket服务器套接字,并设置端口号
            //注意 端口号应该大于等于1024，因为0~1023内都被系统内部占用了
            ServerSocket serverSocket = new ServerSocket(10010);
            // 设置连接超时时间，不设置，则是一直阻塞等待
//            serverSocket.setSoTimeout(8000);
            MsgPool.getsInstance().start();
            while (true){
                //等待客户度连接,超时则抛出异常
                Socket accept = serverSocket.accept();
                System.out.println("IP:" + accept.getInetAddress().getHostAddress() + "PORT:" + accept.getPort() + "IS ONLINE" );
                CLientTask cLientTask = new CLientTask(accept);
                MsgPool.getsInstance().addMsgComingListener(cLientTask);
                cLientTask.start();
            }


        } catch (IOException e) {
            e.printStackTrace();
        }

    }
    public static void main(String arg[]){
        new TCPService().start();
    }
}

package com.hejun.socket.UDP;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.LinkedBlockingQueue;

public class MsgPool {


    private static MsgPool sInstance = new MsgPool();
    //使用队列存放信息
    private LinkedBlockingQueue<String> mQueue = new LinkedBlockingQueue<>();

    public static MsgPool getsInstance(){
        return sInstance;
    }

    private MsgPool() {
    }
    //向队列中中放入数据
    public void sendMsg(String msg){
        try {
            mQueue.put(msg);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    //从队列中拿取数据
    public void start(){
        new Thread(){
            @Override
            public void run() {
                try {
                    String msg = mQueue.take();
                    notifyComingMsg(msg);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();
    }

    private void notifyComingMsg(String msg) {
        for (MsgComingListener listener: comingListeners){
            listener.onMsgComing(msg);
        }
    }

    public interface MsgComingListener{
        void onMsgComing(String msg);
    }

    private List<MsgComingListener> comingListeners = new ArrayList<>();

    public void addMsgComingListener(MsgComingListener comingListener){
        comingListeners.add(comingListener);
    }
}

package com.hejun.socket.TCP;

import com.hejun.socket.UDP.MsgPool;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.Socket;

public class CLientTask  extends  Thread implements MsgPool.MsgComingListener{
    private Socket mSocket;
    private  InputStream mIs;
    private  OutputStream mOs;

    public CLientTask(Socket socket){
        this.mSocket = socket;
        try {
            mIs = socket.getInputStream();
            mOs = socket.getOutputStream();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
    //接收信息,读取数据
    @Override
    public void run() {
        BufferedReader br = new BufferedReader(new InputStreamReader(mIs));
        String line = null;
        try{
            while ((line = br.readLine()) != null){

                System.out.println(mSocket.getPort() + ":" + line);
                MsgPool.getsInstance().sendMsg(line);
            }
        }catch (IOException e){
            e.printStackTrace();
        }

    }
    //发送信息,写入数据
    @Override
    public void onMsgComing(String msg) {
        try {
            mOs.write(msg.getBytes());
//            mOs.write("\n" .getBytes());
            mOs.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

package com.hejun.socket.UDP;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Scanner;

public class UDPService {

    private InetAddress mInetAddress;
    private int port = 8888;
    private DatagramSocket mSocket;
    private Scanner scanner;
    public UDPService() {
        try {
            mInetAddress = InetAddress.getLocalHost();
            //创建套接字
            mSocket = new DatagramSocket(port,mInetAddress);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public void start(){
        while(true){

            try {
                //创建数据报
                byte[] bytes = new byte[1024];
                DatagramPacket received = new DatagramPacket(bytes,bytes.length);
                mSocket.receive(received);

                //接收信息
                InetAddress address = received.getAddress();
                int recevidPort = received.getPort();
                String clietContent = new String(received.getData(),0,received.getLength());
                System.out.print("address="+address + " port = " + recevidPort + "data="+ clietContent );

                //发送信息
                scanner = new Scanner(System.in);
//                scanner.useDelimiter("\n");
                String sc = scanner.next();
                byte[] bytes1 = sc.getBytes();
                DatagramPacket datagramPacket = new DatagramPacket(bytes1,bytes1.length,address,recevidPort);
                mSocket.send(datagramPacket);

            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args){
        new UDPService().start();
    }
}

package com.hejun.socket.UDP;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.Scanner;

public class UDPClient {

    private String secviceIP = "192.168.141.2";
    private InetAddress mInetAddress;
    private int port = 8888;
    private DatagramSocket mDatagramSocket;
    private Scanner scanner;
    public UDPClient() {
        try {
            mInetAddress = InetAddress.getByName(secviceIP);
            //创建套接字
            this.mDatagramSocket = new DatagramSocket();
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }
    public void start(){
        while (true){
            try {
                //发送信息
                scanner = new Scanner(System.in);
//                scanner.useDelimiter("\n");
                String sc = scanner.next();
                byte[] bytes = sc.getBytes();
                DatagramPacket datagramPacket = new DatagramPacket(bytes,bytes.length,mInetAddress,port);
                mDatagramSocket.send(datagramPacket);
                //接收信息
                byte[] bytes1 = new byte[1024];
                DatagramPacket received = new DatagramPacket(bytes1,bytes1.length);
                mDatagramSocket.receive(received);
                String clietContent = new String(received.getData(),0,received.getLength());
                System.out.print(clietContent);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
    public static void main(String[] args){
        new UDPClient().start();
    }
    public void start(String text){
            try {
                byte[] bytes = text.getBytes();
                DatagramPacket datagramPacket = new DatagramPacket(bytes,bytes.length,mInetAddress,port);
                mDatagramSocket.send(datagramPacket);
            } catch (IOException e) {
                e.printStackTrace();
            }
    }
    public String get(){
        byte[] bytes1 = new byte[1024];

        try {
            DatagramPacket received = new DatagramPacket(bytes1,bytes1.length);
            mDatagramSocket.receive(received);
            String clietContent = new String(received.getData(),0,received.getLength());
            return clietContent;
        } catch (IOException e) {
            e.printStackTrace();
        }
      return null;
    }
}