Question

socket java实现客户端多线程接受消息并发送消息给服务器，并发执行

Answer 1

客服端：
package MyKeFudaun;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.net.UnknownHostException;

public class KeFuDuan {
public static void main(String[] args) {
KeFuDuan kf = new KeFuDuan();
kf.start();
}
public void start(){
Socket sco;
String ss= "";
try {
sco = new Socket("127.0.0.1",8866);
KeFuduanJie kf = new KeFuduanJie(sco);
KeFuWuFasong kfs = new KeFuWuFasong(sco);
kf.start();
kfs.start();

//sco.close();
} catch (UnknownHostException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

class KeFuduanJie extends Thread{

Socket soc;
String ss;
BufferedReader br;
public KeFuduanJie(Socket soc){
try {
this.soc = soc;
br = new BufferedReader(new InputStreamReader(soc.getInputStream()));

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

}

//负责接受服务端来的信息
public void run(){
while(true){
//接受服务器端来的信息
try {
ss = br.readLine();
System.out.println("服务器---->客服端： "+ss);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}
}

//向服务器发送东西
class KeFuWuFasong extends Thread{

Socket soc;
BufferedWriter bw;
BufferedReader brr;
public KeFuWuFasong(Socket soc){

this.soc = soc;

try {
brr =new BufferedReader(new InputStreamReader(System.in));
bw = new BufferedWriter(new OutputStreamWriter(soc.getOutputStream()));
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

public void run(){
while(true){
//向服务器发送请求
try {
bw.write(brr.readLine());
bw.newLine();
bw.flush();// 或者用bw.close()
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}

服务器端：
package MyKeFudaun;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {

public static void main(String[] args) {
Server server = new Server();
server.start();
}

public void start(){

try { //服务器端打开端口
ServerSocket server = new ServerSocket(4499);
Socket socket = null;
ServerToClientThread stct = null;

while(true){
socket = server.accept(); //迎接（接收）客户端的Socket访问
stct = new ServerToClientThread(socket); //分配一个新线程负责和信赖的Socket沟通
stct.start();
}

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

}

}

package MyKeFudaun;

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

public class ServerReceiveFromClient extends Thread{

Socket socket;
BufferedReader br;
String s;

public ServerReceiveFromClient(Socket socket){
this.socket = socket;
try {
br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
} catch (IOException e) {
e.printStackTrace();
}
}

public void run(){

while(true){
try {
s = br.readLine();
System.out.println(socket.getInetAddress().getHostAddress()+"发送了:"+s);

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

}
}
}

package MyKeFudaun;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;

public class ServerToClientThread extends Thread{

Socket socket;
BufferedReader br;
BufferedWriter bw;
String s;

//建立的同时，和客户端的Socket建立输入、输出流
public ServerToClientThread(Socket socket){
this.socket = socket;
try {
bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
} catch (IOException e) {
e.printStackTrace();
}

}

public void run(){
ServerReceiveFromClient srfc = new ServerReceiveFromClient(socket);
srfc.start();

while(true){
try {
bw.write("欢迎光临。");
bw.newLine();
bw.flush();
Thread.sleep(10*1000);
} catch (IOException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}

Answer 2

对于通信来说，不存在绝对的服务器和客户端，谁在等待别人来，谁就是服务器，谁主动去联系人，谁就是客户端。
所以。
你要想客户端接受消息，那在启动客户端的时候，在客户端程序里开始一个提供端口的Socket就可以了。
ServerSocket serverSocket = new ServerSocket(5000);
while (true) {
final Socket socket = serverSocket.accept();
new Thread() {
Socket mySocket = socket;

@Override
public void run() {
try {
System.out.println(mySocket);
InputStream is = mySocket.getInputStream();
byte[] bytes = new byte[1024];
int n = is.read(bytes);
System.out.println(new String(bytes, 0, n));
OutputStream os = mySocket.getOutputStream();
os.write(("server reply at time " + new Date()
.toString()).getBytes());
mySocket.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}.start();
}

追问

客户端要接收服务器发出的消息，并在接收消息的过程中发送给服务器消息，你那个不行吧，

追答

这个不是完整代码，否则你的问题还涉及到一个真实的服务器端，客户端的代码，我写的这个只是在客户端启动的时候开启的一个服务监听程序。当服务器往这个端口发请求时，这个请求就会给出相应的服务。要理解，对于Socket来说客户端是针对提供服务的服务器端说的，可以放在真实的服务器端，也能放在客户端。

追问

不好意思，我还是不怎么明白啊，服务器是每隔15秒发送一次1500条的信息，而客户端在接收消息的同时，每隔20-30秒要向服务器发送一次验证信息，证明这个链接还正常通信，这个要具体怎么实现嘛，服务监听程序可以解决嘛

追答

给你个思路，Server里面有所有登陆进来的客户端列表，List list;
服务器启动后，开个线程.
new Thread(){
@Override
public void run(){
while(true){
// 遍历list，给每一个Client发送1500条信息
// 伪代码
for(Client client:list){
new Socket(client.ip,客户端提供的接收消息端口号).getOutputStream().write("消息");
}
}
}
}.start();

客户端启动后：执行以下代码
Socket socket=new Socket(提供接受消息服务的端口);//监听服务器发过来的消息
while(true){
final Socket mySocket = socket.accept();
//如果是要在接收的同时去验证链接是否正常，（即没接收消息则不验证？），那用一个对象，里面有个值可代表是否接受完 如A有个boolean 字段receiving，
//对这次通讯生成一个判断结束的对象
final A a=new A();
a.receiving=true;
new Thread() {
@Override
public void run() {
mySocket.getInputStream().read(byte[]); //取消息
//当取完信息后，改变receiving的值为false
a.receiving=false;
}
}.start();
// 再开一线程，做为验证链接正常的功能
new Thread(){
public void run(){
while(a.receiving){ //当本次信息未接收完时执行
// 跟服务器通讯，确定链接正常
new Socket(Server.ip,对应端口号);
Thread.sleep(25000);//休眠25秒
}
}
}.start();
}

Answer 3

自己写的socket通信在遇到大的并发量时经常会出现各种各样的问题，对于你的这种需求，建议你使用apache下面的mina框架来写，很简单的，就是专门的网络通讯框架，里面的socket
封装的比较完善，没啥大问题！