長連接服務
㈠ 如何利用長連接實現外網訪問內網服務器
需要在復內網的伺服器上運行一制個類似HTTP代理服務的程序，這個程序與外網HTTP伺服器進行長連接，等待代理請求，外網的HTTP伺服器收到HTTP請求時，把對應的請求轉換成內網HTTP代理軟體能識別的命令返回給HTTP代理軟體，此時內網的HTTP代理軟體收到命令並解析，向內網伺服器發送請求並接收響應內容，最後以POST方式向外網服務提交響應內容，外網伺服器再向請求者返回內網WEB服務的響應，整個過程完成。我之前做的WEB遠程式控制制的課程設計用的就是這個方法，效率還可以吧
㈡ 有個Java 項目，通過Socket Tcp長連接通信方式向伺服器發送消息。
你這消息頭、抄消息體的結構格式都定下來了，總長度就是固定的啊？消息體的長度不是一共2+2+4+1=9個位元組么？消息格式肯定要按照服務端的要求進行發送，明顯服務端不是java的程序。。但是java里是沒有Unsigned Integer這種數據類型的（java的stream操作里提供了一些unsigned的方法，或者自己寫方法來生成對應的位元組格式），你可以按照他的要求，使用位元組數組封裝好，然後發送。
針對這個示例消息，你可以：
創建一個長度為9的位元組數組。把「9」變成byte放入前兩個位元組（前兩個位元組數據應該為：0x00, 0x09。這是第一個欄位，長度），後面的欄位數據以此類推。一個欄位一個欄位處理成伺服器要求的格式。
然後把位元組流發送給服務端。
㈢ 伺服器端 長連接 客戶端要使用什麼連接
我們有時候有這種需求，即我們的android客戶端要始終保持與服務端的連接，當服務端有任務或內消息發送到android客戶端的時候就容發送，沒有任務或消息的時候不發送但要保持這個連接，一旦有任務則開發發送，而我們的android客戶端則要保持一個時刻接收任務或消息的狀態。。。這個時候我們通過socket來實現這種需求【當然你也可以採用http輪詢的方式來不斷的從客戶端個請求服務端，這樣做有一定的弊端】
實現原理：
1：android客戶端通過service在後台通過servreScoket不斷的accept，一旦有相應的socket到達，則啟動一個線程去處理
2:：在線程中處理完返回給我們android客戶端的消息或任務之後，要將這種結果表現在ui上，這個步驟方法就比較多了，例如你可以發一個廣播來通知ui,或者你可以通過一個static的handler來處理
㈣ java如何實現http長連接
通過輪詢來實現長連接
輪詢：隔一段時間訪問伺服器，伺服器不管有沒有新消息都立刻返回。
http長連接實現代碼：
客戶端：
package houlei.csdn.keepalive;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.concurrent.ConcurrentHashMap;
/**
* C/S架構的客戶端對象，持有該對象，可以隨時向服務端發送消息。
* <p>
* 創建時間：2010-7-18 上午12:17:25
* @author HouLei
* @since 1.0
*/
public class Client {
/**
* 處理服務端發回的對象，可實現該介面。
*/
public static interface ObjectAction{
void doAction(Object obj,Client client);
}
public static final class DefaultObjectAction implements ObjectAction{
public void doAction(Object obj,Client client) {
System.out.println("處理：\t"+obj.toString());//診斷程序是否正常
}
}
public static void main(String[] args) throws UnknownHostException, IOException {
String serverIp = "127.0.0.1";
int port = 65432;
Client client = new Client(serverIp,port);
client.start();
}
private String serverIp;
private int port;
private Socket socket;
private boolean running=false;
private long lastSendTime;
private ConcurrentHashMap<Class, ObjectAction> actionMapping = new ConcurrentHashMap<Class,ObjectAction>();
public Client(String serverIp, int port) {
this.serverIp=serverIp;this.port=port;
}
public void start() throws UnknownHostException, IOException {
if(running)return;
socket = new Socket(serverIp,port);
System.out.println("本地埠："+socket.getLocalPort());
lastSendTime=System.currentTimeMillis();
running=true;
new Thread(new KeepAliveWatchDog()).start();
new Thread(new ReceiveWatchDog()).start();
}
public void stop(){
if(running)running=false;
}
/**
* 添加接收對象的處理對象。
* @param cls 待處理的對象，其所屬的類。
* @param action 處理過程對象。
*/
public void addActionMap(Class<Object> cls,ObjectAction action){
actionMapping.put(cls, action);
}
public void sendObject(Object obj) throws IOException {
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
oos.writeObject(obj);
System.out.println("發送：\t"+obj);
oos.flush();
}
class KeepAliveWatchDog implements Runnable{
long checkDelay = 10;
long keepAliveDelay = 2000;
public void run() {
while(running){
if(System.currentTimeMillis()-lastSendTime>keepAliveDelay){
try {
Client.this.sendObject(new KeepAlive());
} catch (IOException e) {
e.printStackTrace();
Client.this.stop();
}
lastSendTime = System.currentTimeMillis();
}else{
try {
Thread.sleep(checkDelay);
} catch (InterruptedException e) {
e.printStackTrace();
Client.this.stop();
}
}
}
}
}
class ReceiveWatchDog implements Runnable{
public void run() {
while(running){
try {
InputStream in = socket.getInputStream();
if(in.available()>0){
ObjectInputStream ois = new ObjectInputStream(in);
Object obj = ois.readObject();
System.out.println("接收：\t"+obj);//接受數據
ObjectAction oa = actionMapping.get(obj.getClass());
oa = oa==null?new DefaultObjectAction():oa;
oa.doAction(obj, Client.this);
}else{
Thread.sleep(10);
}
} catch (Exception e) {
e.printStackTrace();
Client.this.stop();
}
}
}
}
}
服務端：
package houlei.csdn.keepalive;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ConcurrentHashMap;
/**
* C/S架構的服務端對象。
* <p>
* 創建時間：2010-7-18 上午12:17:37
* @author HouLei
* @since 1.0
*/
public class Server {
/**
* 要處理客戶端發來的對象，並返回一個對象，可實現該介面。
*/
public interface ObjectAction{
Object doAction(Object rev);
}
public static final class DefaultObjectAction implements ObjectAction{
public Object doAction(Object rev) {
System.out.println("處理並返回："+rev);//確認長連接狀況
return rev;
}
}
public static void main(String[] args) {
int port = 65432;
Server server = new Server(port);
server.start();
}
private int port;
private volatile boolean running=false;
private long receiveTimeDelay=3000;
private ConcurrentHashMap<Class, ObjectAction> actionMapping = new ConcurrentHashMap<Class,ObjectAction>();
private Thread connWatchDog;
public Server(int port) {
this.port = port;
}
public void start(){
if(running)return;
running=true;
connWatchDog = new Thread(new ConnWatchDog());
connWatchDog.start();
}
@SuppressWarnings("deprecation")
public void stop(){
if(running)running=false;
if(connWatchDog!=null)connWatchDog.stop();
}
public void addActionMap(Class<Object> cls,ObjectAction action){
actionMapping.put(cls, action);
}
class ConnWatchDog implements Runnable{
public void run(){
try {
ServerSocket ss = new ServerSocket(port,5);
while(running){
Socket s = ss.accept();
new Thread(new SocketAction(s)).start();
}
} catch (IOException e) {
e.printStackTrace();
Server.this.stop();
}
}
}
class SocketAction implements Runnable{
Socket s;
boolean run=true;
long lastReceiveTime = System.currentTimeMillis();
public SocketAction(Socket s) {
this.s = s;
}
public void run() {
while(running && run){
if(System.currentTimeMillis()-lastReceiveTime>receiveTimeDelay){
overThis();
}else{
try {
InputStream in = s.getInputStream();
if(in.available()>0){
ObjectInputStream ois = new ObjectInputStream(in);
Object obj = ois.readObject();
lastReceiveTime = System.currentTimeMillis();
System.out.println("接收：\t"+obj);
ObjectAction oa = actionMapping.get(obj.getClass());
oa = oa==null?new DefaultObjectAction():oa;
Object out = oa.doAction(obj);
if(out!=null){
ObjectOutputStream oos = new ObjectOutputStream(s.getOutputStream());
oos.writeObject(out);
oos.flush();
}
}else{
Thread.sleep(10);
}
} catch (Exception e) {
e.printStackTrace();
overThis();
}
}
}
}
private void overThis() {
if(run)run=false;
if(s!=null){
try {
s.close();
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println("關閉："+s.getRemoteSocketAddress());//關閉長連接
}
}
}
長連接的維持，是要客戶端程序，定時向服務端程序，發送一個維持連接包的。
如果，長時間未發送維持連接包，服務端程序將斷開連接。
㈤ 一台伺服器可以連接多少個tcp長連接
TCP是一種通訊協議,用於交換數據,如QQ有時就用TCP連接.SMTP伺服器就是郵件伺服器,smtp協議用來發郵件,pop3用來接受郵件.
㈥ 如何實現單伺服器300萬個長連接的
轉載 這種功能實際上就是數據同步，同時要考慮手機本身、電量、網路流量等等限制因素，所以通常在移動端上有一下兩個解決方案:
1.一種是定時去server查詢數據，通常是使用HTTP協議來訪問web伺服器，稱Polling（輪詢）；
2.還有一種是移動端和伺服器建立長連接，使用XMPP長連接，稱Push（推送）。
從耗費的電量、流量和數據延遲性各方面來說，Push有明顯的優勢。但是使用Push的缺點是：
對於客戶端：實現和維護相對成本高，在移動無線網路下維護長連接，相對有一些技術上的開發難度。
對於伺服器：如何實現多核並發，cpu作業調度，數量龐大的長連接並發維護等技術，仍存在開發難點。
在講述Push方案的原理前，我們先了解一下移動無線網路的特點。
移動無線網路的特點：
因為 IP v4 的 IP 量有限，運營商分配給手機終端的 IP 是運營商內網的 IP，手機要連接 Internet，就需要通過運營商的網關做一個網路地址轉換（Network Address Translation，NAT）。簡單的說運營商的網關需要維護一個外網 IP、埠到內網 IP、埠的對應關系，以確保內網的手機可以跟 Internet 的伺服器通訊
GGSN（Gateway GPRS
Support Node 網關GPRS支持結點）模塊就實現了NAT功能。
因為大部分移動無線網路運營商都是為了減少網關的NAT映射表的負荷，所以如果發現鏈路中有一段時間沒有數據通訊時，會刪除其對應表，造成鏈路中斷。（關於NAT的作用及其原理可以查看我的另一篇博文：關於使用UDP(TCP)跨區域網，NAT穿透的心得）
Push在Android平台上長連接的實現：
既然我們知道我們移動端要和Internet進行通信，必須通過運營商的網關，所以，為了不讓NAT映射表失效，我們需要定時向Internet發送數據，因為只是為了不然NAT映射表失效，所以只需發送長度為0的數據即可。
這時候就要用到定時器，在android系統上，定時器通常有一下兩種：
1.java.util.Timer
2.android.app.AlarmManager
分析：
Timer:可以按照計劃或者時間周期來執行相關的任務。但是Timer需要用WakeLock來讓CPU保持喚醒狀態，才能保證任務的執行，這樣子會消耗大量流量；當CPU處於休眠的時候，就不能喚醒執行任務，所以應用於移動端明顯是不合適。
AlarmManager：AlarmManager類是屬於android系統封裝好來管理RTC模塊的管理類。這里就涉及到RTC模塊，要更好地了解兩者的區別，就要明白兩者真正的區別。
RTC（Real- Time Clock）實時鬧鍾在一個嵌入式系統中，通常採用RTC
來提供可靠的系統時間，包括時分秒和年月日等;而且要求在系統處於關機狀態下它也能夠正常工作（通常採用後備電池供電），它的外圍也不需要太多的輔助電路，典型的就是只需要一個高精度的32.768KHz
晶體和電阻電容等。（如果對這方面感興趣，可以自己查閱相關資料，這里就說個大概）
好了，回來正題。所以，AlarmManager又稱全局定時鬧鍾。這意味著，當我用使用AlarmManager來定時執行任務，CPU可以正常地休眠，只有在執行任務是，才喚醒CPU，這個過程是很短時間的。
下面簡單來說明其使用：
1.類似於Timer功能：
//獲得鬧鍾管理器
AlarmManager
am = (AlarmManager)getSystemService(ALARM_SERVICE);
//設置任務執行計劃
am.setRepeating(AlarmManager.ELAPSED_REALTIME, firstTime, 5*1000,
sender);//從firstTime才開始執行，每隔5秒再執行
2.實現全局定時功能：
//獲得鬧鍾管理器
AlarmManager
am = (AlarmManager)getSystemService(ALARM_SERVICE);
//設置任務執行計劃
am.setRepeating(AlarmManager.ELAPSED_REALTIME_WAKEUP, firstTime,
5*1000, sender);//從firstTime才開始執行，每隔5秒再執行
總結：在android客戶端使用Push推送時，應該使用AlarmManager來實現心跳功能，使其真正實現長連接。
㈦ 一台客戶端可以與多台伺服器保持長連接嗎
正常情況沒有限制，只要客戶端配置夠高。長時間連接，間隔一段時間自動斷開，可能是網路問題導致或者是本地網路設備問題。可以嘗試使用另一台作為終端來連接到伺服器端。
㈧ PHP中如何實現與伺服器的長連接呢 - PHP進階討論
在使用永久連接時還有一些特別的問題需要注意。例如在永久連接中使用數據表回鎖時，如果腳本答不管什麼原因無法釋放該數據表鎖，其隨後使用相同連接的腳本將會被永久的阻塞，使得需要重新啟動 httpd 服務或者資料庫服務。另外，在使用事務處理時，如果腳本在事務阻塞產生前結束，則該阻塞也會影響
㈨ 如何實現單伺服器300萬個長連接的
不是吹牛，理論上完全可以達到。
（以下參考值皆是Linux平台上）
1，Linux單個進程可以維持的連接數(fd)理論值是通過ulimit -a設置，或在server內使用setrlimit()設置，具體最大是多少？我看我的64機上是64bits的一個數值，所以，權且認為理論上是2^64-1。 anyway，幾百萬不是問題。
2，TCP連接數。因為是Server端，不用向系統申請臨時埠，只佔fd資源。所以tcp連接數不受限制。
3，維持連接當然需要內存消耗，假如每個連接（fd），我們為其分配5k位元組（應該足夠了，就存放一些用戶信息之類的）。這樣是5k*3000000=15G。 文中有24G內存，應該也足夠了。
================================
下面我們說下文中提及的 多消息循環、非同步非阻塞。
先說非同步和非阻塞吧。權且認為這倆是一個概念。都是指的IO的非同步和非阻塞。
1，非同步+非阻塞的話，Linux上必然是epoll了。
原理上簡而言之吧，非同步就是基於事件的讀寫，epoll同時監聽所有的tcp連接（fd），當有哪些連接上有了事件（讀、寫、錯誤），就返回有事件的連接集合，然後處理這個集合里的需要處理的連接事件。這兒就是基於事件的非同步IO。
非阻塞。 在得到有事件的tcp連接集合之後，逐一進行讀（寫）。分開來說，需要讀的fd，其實數據已經到OS的tcp buffer里了，讀完直接返回，CPU不等待。（返回EAGAIN，其實就進行了幾次memcpy）； 需要寫的連接，同樣，其實是把數據寫到了OS的tcp buffer里，寫滿為止。。不會等待對方發來ACK再返回。這樣，其實這里CPU基本上只進行了一些memcpy的操作。。即便同時幾十萬連接有事件，也是瞬間處理完的事。。。然後，CPU再進行非同步io等待（epoll_wait()）。
當然這兒要充分利用多核，最好將io線程和work線程分開。
2，多消息循環。。這個應該是他們內部的概念。我個人猜測是非同步的消息協議。
舉例子，傳統的TCP連接是一問一答，如HTTP。