| |
ad_qqread_mid_big">
服务器端的完整实现
服务器端的完整实现代码如下：
package com.andrew;
import java.io.dataoutputstream;
import java.io.ioexception;
import java.io.serializable;
import java.net.serversocket;
import java.net.socket;
import java.util.concurrent.arrayblockingqueue;
import java.util.concurrent.blockingqueue;
import java.util.concurrent.callable;
import java.util.concurrent.executionexception;
import java.util.concurrent.executorservice;
import java.util.concurrent.executors;
import java.util.concurrent.future;
import java.util.concurrent.rejectedexecutionhandler;
import java.util.concurrent.threadpoolexecutor;
import java.util.concurrent.timeunit;
import java.util.concurrent.locks.reentrantlock;
public class server {
private static int producetasksleeptime = 100;
private static int consumetasksleeptime = 1200;
private static int producetaskmaxnumber = 100;
private static final int core_pool_size = 2;
private static final int max_pool_size = 100;
private static final int keepalive_time = 3;
private static final int queue_capacity = (core_pool_size + max_pool_size) / 2;
private static final timeunit time_unit = timeunit.seconds;
private static final string host = "127.0.0.1";
private static final int port = 19527;
private blockingqueue<runnable> workqueue = new arrayblockingqueue<runnable>(queue_capacity);
//private threadpoolexecutor serverthreadpool = null;
private executorservice pool = null;
private rejectedexecutionhandler rejectedexecutionhandler = new threadpoolexecutor.discardoldestpolicy();
private serversocket serverlistensocket = null;
private int times = 5;
public void start() {
// you can also init thread pool in this way.
/*serverthreadpool = new threadpoolexecutor(core_pool_size,
max_pool_size, keepalive_time, time_unit, workqueue,
rejectedexecutionhandler);*/
pool = executors.newfixedthreadpool(10);
try {
serverlistensocket = new serversocket(port);
serverlistensocket.setreuseaddress(true);
system.out.println("i'm listening");
while (times-- > 0) {
socket socket = serverlistensocket.accept();
string welcomestring = "hello";
//serverthreadpool.execute(new servicethread(socket, welcomestring));
pool.execute(new servicethread(socket));
}
} catch (ioexception e) {
// todo auto-generated catch block
e.printstacktrace();
}
cleanup();
}
public void cleanup() {
if (null != serverlistensocket) {
try {
serverlistensocket.close();
} catch (ioexception e) {
// todo auto-generated catch block
e.printstacktrace();
}
}
//serverthreadpool.shutdown();
pool.shutdown();
}
public static void main(string args[]) {
server server = new server();
server.start();
}
}
class servicethread implements runnable, serializable {
private static final long serialversionuid = 0;
private socket connectedsocket = null;
private string hellostring = null;
private static int count = 0;
private static reentrantlock lock = new reentrantlock();
servicethread(socket socket) {
connectedsocket = socket;
}
public void run() {
increasecount();
int curcount = getcount();
hellostring = "hello, id = " + curcount + "/r/n";
executorservice executor = executors.newsinglethreadexecutor();
future<string> future = executor.submit(new timeconsumingtask());
dataoutputstream dos = null;
try {
dos = new dataoutputstream(connectedsocket.getoutputstream());
dos.write(hellostring.getbytes());
try {
dos.write("let's do soemthing other./r/n".getbytes());
string result = future.get();
dos.write(result.getbytes());
} catch (interruptedexception e) {
e.printstacktrace();
} catch (executionexception e) {
e.printstacktrace();
}
} catch (ioexception e) {
// todo auto-generated catch block
e.printstacktrace();
} finally {
if (null != connectedsocket) {
try {
connectedsocket.close();
} catch (ioexception e) {
// todo auto-generated catch block
e.printstacktrace();
}
}
if (null != dos) {
try {
dos.close();
} catch (ioexception e) {
// todo auto-generated catch block
e.printstacktrace();
}
}
executor.shutdown();
}
}
private int getcount() {
int ret = 0;
try {
lock.lock();
ret = count;
} finally {
lock.unlock();
}
return ret;
}
private void increasecount() {
try {
lock.lock();
++count;
} finally {
lock.unlock();
}
}
}
class timeconsumingtask implements callable<string> {
public string call() throws exception {
system.out.println("it's a time-consuming task, you'd better retrieve your result in the furture");
return "ok, here's the result: it takes me lots of time to produce this result";
}
} |
运行程序
运行服务端，客户端只需使用telnet 127.0.0.1 19527 即可看到信息如下：
|
