Национална академия по разработка на софтуер

Как да установяваме прекъсната TCP връзка

Едната препоръка е никога да не четем от сокет без ограничение откъм време. В класа java.net.Socket има метод setSoTimeout(int), с който може да се задава максималното време в милисекунди, за което една операция read() от InputStream-а, свързан с даден сокет трябва да приключи. Ако за зададеното време по сокета не пристигне нищо, се поражда изключението java.net.SocketTimeoutException и операцията четене се прекратява. По подразбиране стойността, зададена в setSoTimeout(int) е 0, което означава, че ограничение във времето няма.

Подходът със задаване на timeout при четене от сокет решава проблема с безкрайното чакане на данни от невалиден сокет, но не винаги е подходящ.

Понякога е възможно един сокет да е валиден, но по него да не преминават никакви данни в продължение на часове. Например, ако имаме сървър, който приема някаква информация от клиентите си от време на време, когато някой клиент реши да му изпрати нещо, е възможно с часове нищо да не бъде изпратено нито от клиента към сървъра, нито в обратната посока. Въпреки продължителната липса на активност, връзката не трябва да се прекъсва след изминаване на някакъв timeout (примерно 1, 5 или 10 минути). Сървърът, обаче иска ако се случи нещо с клиента и връзката с него се разпадне внезапно, да разбере за това и да освободи ресурсите, отделени за обслужването на този клиент.

Основният проблем е, че при липса на трафик по даден сокет няма начин да се провери дали връзката е активна или е разрушена.

Най-добрият начин да се справим с този проблем е да реализираме разширение на протокола, което осигурява възможност за изпращане на проверяващи пакети от сървъра към клиента от време на време, примерно на 2-3 минути. Така по сокета през определено време ще преминават някакви данни и ако връзката е прекъсната, ще настъпва изключение и сървърът ще разбира, че клиентът е недостъпен.

Този подход е най-надеждният и най-сигурният, но може да причини значителни усложнения при разработката на клиента и сървъра заради синхронизационни проблеми, защото проверяващите пакети трябва да се изпращат и обработват отделно и независимо от другите пакети.

Има и друг вариант да се справим с проблема. Той не изисква промяна на протокола, но и не е толкова надежден. TCP сокетите имат стандартна възможност да бъдат автоматично проверявани през определено време дали са свързани чрез специални keep-alive пакети, на които отсрещната страна е длъжна да отговаря. Тази възможност се поддържа вътрешно от TCP протокола и операционната система и ако бъде включена, при липса на отговори на тези keep-alive пакети за определено време (някакъв системен timeout, който обикновено е 2 часа), се счита, че сокетът е невалиден. Класът Socket в Java има метод setKeepAlive(boolean), с който се задава дали да бъде включена keep-alive опцията за даден сокет. По подразбиране тази опция е изключена. Проблемът на този подход е, че не знаем със сигурност колко е keep-alive timeout стойността и за различните платформи тя е различна. Обикновено стойността е няколко часа, което означава, че при сриване на връзката сървърът ще разбере за това не веднага, а едва след няколко часа.

Обслужване на много потребители едновременно

Даденият по-горе пример за сървър обслужва клиентите си последователно един след друг. Ако двама клиенти едновременно дадат заявка, първият ще бъде обслужен веднага, а вторият едва след приключване на обслужването на първия. Тази стратегия работи, но само за прости сървъри, в които обслужването на клиент отнема много малко време. В повечето случаи обслужването на един клиент отнема известно време и останалите клиенти не могат да бъдат карани да го изчакват. Затова се налага сървърът да обслужва клиентите си едновременно и независимо един от друг. За реализация на такава стратегия в средата на Java най-често се използва многонишковият подход, при който за всеки клиент се създава отделна нишка. Това е препоръчвания начин за разработка на сървъри, предназначени да работят с повече от един клиент. Ако трябва да сме точни, от JDK 1.4 в Java се поддържат и асинхронни сокети, с които могат да се обработват едновременно много клиенти само с една нишка, но засега няма да разглеждаме този програмен модел.

Многопотребителски сървър-речник

Да си поставим за задача реализацията на прост сървър, който по зададена дума на английски език връща преводът й на български език, а за при непозната думи връща грешка. Сървърът трябва да може да обслужва много потребители едновременно и независимо един от друг, без да е необходимо някой от тях да чака докато сървърът обслужва останалите. За простота ще считаме, че думите и техните преводи са дадени като константа с ясната идея, че в една реална ситуация те трябва да се извличат от база данни или от някаква друга система. Ето как можем да реализираме нашият сървър-речник:

DictionaryServer.java

import java.io.*; import java.net.ServerSocket; import java.net.Socket; import java.util.Date; public class DictionaryServer { public static int LISTENING_PORT = 3333; public static void main(String[] args) throws IOException { ServerSocket serverSocket = new ServerSocket(LISTENING_PORT); System.out.println("Server started."); while (true) { Socket socket = serverSocket.accept(); DictionaryClientThread dictionaryClientThread = new DictionaryClientThread(socket); dictionaryClientThread.start(); } } } class DictionaryClientThread extends Thread { private int CLIENT_REQUEST_TIMEOUT = 15*60*1000; // 15 min. private Socket mSocket; private BufferedReader mSocketReader; private PrintWriter mSocketWriter; public DictionaryClientThread(Socket aSocket) throws IOException { mSocket = aSocket; mSocket.setSoTimeout(CLIENT_REQUEST_TIMEOUT); mSocketReader = new BufferedReader( new InputStreamReader(mSocket.getInputStream())); mSocketWriter = new PrintWriter( new OutputStreamWriter(mSocket.getOutputStream())); } public void run() { System.out.println(new Date().toString() + " : " + "Accepted client : " + mSocket.getInetAddress() + ":" + mSocket.getPort()); try { mSocketWriter.println("Dictionary server ready."); mSocketWriter.flush(); while (!isInterrupted()) { String word = mSocketReader.readLine(); if (word == null) break; // Client closed the socket String translation = getTranslation(word); mSocketWriter.println(translation); mSocketWriter.flush(); } } catch (Exception ex) { ex.printStackTrace(); } System.out.println(new Date().toString() + " : " + "Connection lost : " + mSocket.getInetAddress() + ":" + mSocket.getPort()); } private String getTranslation(String aWord) { if (aWord.equalsIgnoreCase("network")) { return "мрежа"; } else if (aWord.equalsIgnoreCase("firewall")) { return "защитна стена"; } else { return "! непозната дума !"; } } }

Как работи сървърът-речник

Сървърът-речник е изключително прост. Той отваря за слушане сървърски сокет на порт 3333 и започва да слуша в цикъл за клиентски заявки идващи към този сокет. При приемане на клиент създава нишка, която да го обслужва, подава й създадения клиентски сокет и я стартира.

Нишката, която обслужва клиентите, първо им изпраща поздравително съобщение, след което в цикъл чете дума от клиента, намира преводът й в речника си и изпраща към клиента този превод. Това продължава докато нишката не бъде помолена да завърши работата си. Ако междувременно от клиента се прочете празен низ, това означава, че е достигнат края на входния поток, т.е. клиентът е затворил сокет връзката. В такъв случай се прекратява обслужването на клиента и нишката завършва.

За клиентския сокет се задава timeout при четене 15 минути. Това се прави с цел да се прекъсват автоматично връзките на клиентите, които по някаква причина много дълго бездействат. Такива клиенти могат или да са изгубили по някаква причина връзката със сървъра или просто да са свързани, но да не са активни. И в двата случая е добре сървърът да ги премахва, за да не хаби излишни ресурси.

Забележете, че веднага след като изпратим нещо към сървъра извикваме flush() метода, за да осигурим реалното изпращане на данните по сокета. Ако не извикаме flush(), данните ще останат да чакат в буфера на класа PrintWriter и няма да отпътуват по сокета, все едно не са изпратени към потока. Тази особеност с буферирането е много важна при комуникация с потоци и винаги трябва да се съобразяваме с нея.

Клиент за сървъра-речник

Нека сега напише и клиент за нашия сървър речник. Всичко, което трябва да прави клиента е да се свърже със сървъра, да извлече от него поздравителното съобщение и след това постоянно да чете дума от конзолата, да я изпраща към сървъра за превод и да отпечатва превода получен от клиента. Ето една реализация:

DictionaryClient.java

import java.io.*; import java.net.Socket; public class DictionaryClient { private static int SERVER_RESPONSE_TIMEOUT = 60*1000; public static void main(String[] args) throws IOException { Socket socket = new Socket("localhost", 3333); socket.setSoTimeout(SERVER_RESPONSE_TIMEOUT); BufferedReader socketReader = new BufferedReader( new InputStreamReader(socket.getInputStream()) ); PrintWriter socketWriter = new PrintWriter(socket.getOutputStream()); BufferedReader consoleReader = new BufferedReader( new InputStreamReader(System.in) ); String welcomeMessage = socketReader.readLine(); System.out.println(welcomeMessage); try { while (true) { String word = consoleReader.readLine(); socketWriter.println(word); socketWriter.flush(); String translation = socketReader.readLine(); System.out.println(translation); } } finally { socket.close(); } } }

Как работи клиентът за сървъра-речник

Всичко което прави клиентът е да отвори сокет към сървъра, да прочете от него поздравителното съобщение, след което в безкраен цикъл да чете дума от конзолата, да я изпраща към сървъра за превод, да прочита отговора на сървъра и да го отпечатва в конзолата. Забележете отново, че след изпращане на заявката към сървъра се извиква методът flush() на изходния поток. Ако този метод не се извика, програмата ще блокира, защото заявката няма да достигне сървъра. Ако ги няма ограниченията за максимално допустимо време за четене на сървъра и на клиента, програмата ще се опитва неограничено дълго време да прочете отговора на сървъра, а сървърът ще чака неограничено дълго време да получи заявка от клиента и така никой няма да дочака другия. В случая максималното допустимо време за чакане на отговор от сървъра се ограничава до 1 минута веднага след успешно свързване към сървъра.

Каталог: books -> inetjava
books -> В обятията на шамбала
books -> Книга се посвещава с благодарност на децата ми. Майка ми и жена ми ме научиха да бъда мъж
books -> Николай Слатински “Надеждата като лабиринт” София, Издателство “виденов & син”, 1993 год
books -> София, Издателство “Българска книжница”, 2004 год. Рецензенти доц д. ик н. Димитър Йончев, проф д-р Нина Дюлгерова Научен редактор проф д-р Петър Иванов
books -> Николай Слатински “Измерения на сигурността” София, Издателство “Парадигма”, 2000 год
books -> Книга 2 щастие и успех предисловие
books -> Превръщане на числа от една бройна система в друга
books -> Тантриското преобразяване

Изтегляне 2.68 Mb.

Сподели с приятели: