Сокеты Java и выделенные соединения

Что состоит в том, чтобы обнаружить самый соответствующий путь, если сокет был отброшен или нет? Или ли пакет действительно на самом деле становился отправленным?

У меня есть библиотека для отправки Уведомлений о Нажатии Apple iPhone через Apple gatways (доступный на GitHub). Клиенты должны открыть сокет и отправить двоичное представление каждого сообщения; но к сожалению Apple не возвращает подтверждения вообще. Соединение может быть снова использовано для отправки нескольких сообщений также. Я использую простые Сокетные соединения Java. Соответствующие нормы:

Socket socket = socket();   // returns an reused open socket, or a new one
socket.getOutputStream().write(m.marshall());
socket.getOutputStream().flush();
logger.debug("Message \"{}\" sent", m);

В некоторых случаях, если соединение отбрасывается, в то время как сообщение отправляется или прямо прежде; Socket.getOutputStream().write() концы успешно все же. Я ожидаю, что это происходит из-за окна TCP еще, не исчерпывается.

Существует ли способ, которым я могу сказать наверняка, вошел ли пакет на самом деле в сеть или нет? Я экспериментировал со следующими двумя решениями:

1. Вставьте дополнительное socket.getInputStream().read() операция с тайм-аутом на 250 мс. Это вызывает операцию чтения, которая перестала работать, когда соединение было отброшено, но зависает иначе для 250 мс.

2. установите размер буфера отправки TCP (например. Socket.setSendBufferSize()) к двоичному размеру сообщения.

Обе из работы методов, но они значительно ухудшают качество обслуживания; пропускная способность идет от 100 сообщения/секунда приблизительно к 10 сообщениям/секунда самое большее.

Какие-либо предложения?

ОБНОВЛЕНИЕ:

Оспариваемый несколькими ответами, подвергающими сомнению возможность описанного. Я создал тесты "единицы" из поведения, которое я описываю. Проверьте случаи единицы в Gist 273786.

Оба модульных теста имеют два потока, сервер и клиент. Сервер закрывается, в то время как клиент отправляет данные без IOException, брошенного так или иначе. Вот основной метод:

public static void main(String[] args) throws Throwable {
    final int PORT = 8005;
    final int FIRST_BUF_SIZE = 5;

    final Throwable[] errors = new Throwable[1];
    final Semaphore serverClosing = new Semaphore(0);
    final Semaphore messageFlushed = new Semaphore(0);

    class ServerThread extends Thread {
        public void run() {
            try {
                ServerSocket ssocket = new ServerSocket(PORT);
                Socket socket = ssocket.accept();
                InputStream s = socket.getInputStream();
                s.read(new byte[FIRST_BUF_SIZE]);

                messageFlushed.acquire();

                socket.close();
                ssocket.close();
                System.out.println("Closed socket");

                serverClosing.release();
            } catch (Throwable e) {
                errors[0] = e;
            }
        }
    }

    class ClientThread extends Thread {
        public void run() {
            try {
                Socket socket = new Socket("localhost", PORT);
                OutputStream st = socket.getOutputStream();
                st.write(new byte[FIRST_BUF_SIZE]);
                st.flush();

                messageFlushed.release();
                serverClosing.acquire(1);

                System.out.println("writing new packets");

                // sending more packets while server already
                // closed connection
                st.write(32);
                st.flush();
                st.close();

                System.out.println("Sent");
            } catch (Throwable e) {
                errors[0] = e;
            }
        }
    }

    Thread thread1 = new ServerThread();
    Thread thread2 = new ClientThread();

    thread1.start();
    thread2.start();

    thread1.join();
    thread2.join();

    if (errors[0] != null)
        throw errors[0];
    System.out.println("Run without any errors");
}

[Кстати, у меня также есть библиотека тестирования параллелизма, которая делает установку немного лучше и более ясный. Контроль образец в сути также].

Когда выполнено я получаю следующий вывод:

Closed socket
writing new packets
Finished writing
Run without any errors