多线程socket对象传输

服务器端：

Handler.java

package com.xmgd.socket;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

import com.xmgd.socket.demo.Employee;

/**
* 服务器端的处理方法
*
* @author suj
*/
public class Handler implements Runnable {
private final Socket socket;

public Handler(Socket socket) {
this.socket = socket;
}

private ObjectInputStream getServerInputStream(Socket socket) throws IOException {
ObjectInputStream serverInputStream = new ObjectInputStream(socket.getInputStream());
return serverInputStream;
}

private ObjectOutputStream getServerOutputStream(Socket socket) throws IOException {
ObjectOutputStream serverOutputStream = new ObjectOutputStream(socket.getOutputStream());
return serverOutputStream;
}

@Override
public void run() {
ObjectInputStream serverInputStream;
ObjectOutputStream serverOutputStream;
try {
serverInputStream = getServerInputStream(socket);
serverOutputStream = getServerOutputStream(socket);
Employee employee = (Employee) serverInputStream.readObject();
System.out.println(employee.getEmployeeName());
System.out.println(employee.getEmployeeNumber());
List<String> rlist = employee.getList();
List<String> blist = new ArrayList<String>();
for (int i = 0; i < rlist.size(); i++) {
System.out.println(rlist.get(i));
blist.add(rlist.get(i) + "new");
}

employee.setEmployeeNumber(employee.getEmployeeNumber() + 0);
employee.setEmployeeName(employee.getEmployeeName() + "new");

employee.setList(blist);
serverOutputStream.writeObject(employee);
serverInputStream.close();
serverOutputStream.close();
}
catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
finally {
try {
if (socket != null)
socket.close();
}
catch (IOException e) {
e.printStackTrace();
}

}

}

}





Server.java

package com.xmgd.socket;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
* 多线程socket传输对象的服务器端
*
* @author suj
*/
public class Server {
public static void main(String[] args) throws IOException {
new Server().service();
}

private final int port = 11111;
private final ServerSocket serverSocket;
private final ExecutorService executorService;// 线程池

private final int POOL_SIZE = 10;// 单个CPU线程池大小

public Server() throws IOException {
serverSocket = new ServerSocket(port);
// Runtime的availableProcessor()方法返回当前系统的CPU数目.
executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * POOL_SIZE);
System.out.println("服务器启动");
}

public void service() {
while (true) {
Socket socket = null;
try {
// 接收客户连接,只要客户进行了连接,就会触发accept();从而建立连接
socket = serverSocket.accept();
executorService.execute(new Handler(socket));

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

}




Employee.java

package com.xmgd.socket.demo;

import java.io.Serializable;
import java.util.List;

public class Employee implements Serializable {

/**
*
*/
private static final long serialVersionUID = 1L;
private int employeeNumber;
private String employeeName;
private List<String> list;

public Employee(int num, String name, List<String> list) {
employeeNumber = num;
employeeName = name;
list = list;
}

public String getEmployeeName() {
return employeeName;
}

public int getEmployeeNumber() {
return employeeNumber;
}

public List<String> getList() {
return list;
}

public void setEmployeeName(String name) {
employeeName = name;
}

public void setEmployeeNumber(int num) {
employeeNumber = num;
}

public void setList(List<String> list) {
this.list = list;
}
}


客户端:

Client.java

package com.xmgd.socket;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import com.xmgd.socket.demo.Employee;

/**
* 多线程传输对象的客户端
*
* @author suj
*/
public class Client {

public class ThreadTest extends Thread {
private int tmp;

public ThreadTest() {

}

public ThreadTest(int tmp) {
this.tmp = tmp;
}

public int getTmp() {
return tmp;
}

public synchronized void inputclass(Socket socket) throws IOException {
List<String> list = new ArrayList();
list.add("a" + tmp + "");
list.add("b" + tmp + "");
Employee joe = new Employee(150 + tmp, "Joe" + tmp + "", list);
joe.setList(list);
System.out.println("发送：employeeNumber= " + joe.getEmployeeNumber());
System.out.println("发送：employeeName= " + joe.getEmployeeName());
for (int i = 0; i < joe.getList().size(); i++)
System.out.println("发送：list" + i + "=" + joe.getList().get(i));
ObjectOutputStream clientOutputStream = new ObjectOutputStream(socket.getOutputStream());
clientOutputStream.writeObject(joe);
// clientOutputStream.close();

}

public synchronized void outclass(Socket socket) throws Exception {
ObjectInputStream clientInputStream = new ObjectInputStream(socket.getInputStream());
Employee joe = (Employee) clientInputStream.readObject();
System.out.println("接收：employeeNumber= " + joe.getEmployeeNumber());
System.out.println("接收：employeeName= " + joe.getEmployeeName());
for (int i = 0; i < joe.getList().size(); i++)
System.out.println("接收: list" + i + "= " + joe.getList().get(i));
}

@Override
public void run() {
try {

Socket socket = new Socket("127.0.0.1", 11111);
inputclass(socket);
outclass(socket);

}
catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}

public void setTmp(int tmp) {
this.tmp = tmp;
}
}

public static void main(String[] arg) {
ExecutorService threadPool = Executors.newFixedThreadPool(3);

for (int i = 0; i < 3; i++) {

Client.ThreadTest threadDemo = new Client().new ThreadTest(i);
threadPool.execute(threadDemo);
}
}

}