Java多线程时间切换

Question

我对 Java 中多线程如何在底层工作的了解很少。据我所知，当有两个线程运行时，Java 会为每个线程分配“时间 block ”来执行。

例如:

public void test()
{
    Thread testThread = new Thread(new TestThread());
    testThread.start();

    for (int i = 0; i < Integer.MAX_VALUE; ++i)
        System.out.print("a");
}

private class TestThread extends Thread
{
    public void run()
    {
        for (int i = 0; i < Integer.MAX_VALUE; ++i)
            System.out.print("b");
    }
}

会打印出类似的内容:
啊啊啊aaaaaabbbbbbbbbbbbbaaaaaaaaaaabbbbbbbbbbbbbaaaaaa...
而不是:
babababababababababababababababab......


我的问题是:是否可以减少“时间 block ”，以便我们得到更接近的结果:
aabbaabbaabbaaabbaabbbaabbaabbbaabbaaa...


为什么？我正在尝试编写一个苹果推送通知服务器(只是为了好玩)。当您向苹果推送通知服务写入请求时，可能会发生一两件事:
1. 如果请求有效，则不会返回任何内容。
2. 如果请求无效，将返回错误码并关闭连接，无效请求之后、连接关闭之前发送的所有请求都将被丢弃。

因为读取套接字会阻塞，直到有数据可供读取(如果我不写入任何无效请求，这种情况可能永远不会发生)，所以我不能在每次写入后简单地读取以查看是否存在错误，而不设置 200-500 毫秒的超时。如果我们有 100 万个写入请求(很可能)，则超时时间将增加 55 - 138 小时，并且由于超时时间短，我们可能会错过返回的错误，从而导致请求永远不会被发送。

因此，我有两个线程，如上面的示例，一个正在写入服务器，另一个正在读取，等待查看是否返回错误。问题是这样的:如果请求 #4 是错误的，但我们在读取错误和连接关闭之前写入了 #5-#10，则请求 #5-10 会被 Apple 服务丢弃。因此，一旦我们知道#4是坏的并且我们知道我们写的最后一个请求是#10，我们需要重新排队#5-10以再次发送。

我现在遇到的问题是由于“时间卡盘”很大，我能够在读取线程读取 #5 存在错误之前写入请求 #1-#400，因此 #6-#400 被重新排队并发送再次。然后读取线程读取 #21 存在错误，因此 #22-#400 重新排队并再次发送...等等。理想情况下，读取线程能够在每写入 5-10 个请求时从套接字读取数据。

来源:

private Object readWriteLock = new Object();
private volatile int     lastWrittenIndex;
private volatile boolean doneWriting;
private List<PushNotificationRequest> pushNotificationRequestsResnedList = new ArrayList<PushNotificationRequest>();

public boolean write()
{
    // get the requests read list
    List<PushNotificationRequest> requests = getPushNotificationRequests(false);

    // as long as there are more notifications to write...
    while (requests.size() > 0)
    {
        lastWrittenIndex = -1;
        doneWriting = false;

        // create and start the read thread
        Thread readThread = new Thread(new ReadThread(), "APNS Reader");
        readThread.start();

        for (int i = 0; i < requests.size(); ++i)
        {
            PushNotificationRequest request = requests.get(i);

            // write
            boolean success = false;

            // attempt to send the notification a number of times
            for (int j = 0; j < MAX_NUM_PN_WRITE_ATTEMPTS; ++j)
            {
                synchronized (readWriteLock)
                {
                    try
                    {
                        // get the socket connection
                        SSLSocket socket = getAppleServiceSSLSockett();
                        OutputStream socketOutputStream = socket.getOutputStream();

                        socketOutputStream.write(request.binary);
                        socketOutputStream.flush();

                        success = true;
                        lastWrittenIndex = i;

                        break;
                    }
                    catch (IOException e)
                    {
                        e.printStackTrace();
                    }
                    catch (AppleServiceConnectionException e)
                    {
                        e.printStackTrace();
                    }
                }
            }

            if (!success)
                System.err.println("APNS Unable to send push notification:\n" + request);
        }

        // wait for some time so we can make sure the read thread can read everything
        try
        {
            Thread.sleep(Config.APNS_READ_TIME_AFTER_DONE_WRITING_MILLISECONDS);
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }

        // let the read thread know we are done writing and close the connection so it unblocks
        doneWriting = true;
        closeAppleServiceSSLSockett();

        // wait for the read thread to return
        try
        {
            readThread.join();
        }
        catch (InterruptedException e)
        {
            e.printStackTrace();
        }


        // clear the reading list
        requests.clear();

        // add the requests from the re-send to the list
        if (pushNotificationRequestsResnedList.size() > 0)
        {
            requests.addAll(pushNotificationRequestsResnedList);

            // clear the re-send list
            pushNotificationRequestsResnedList.clear();
        }
    }
}

private class ReadThread extends Thread
{
    public void run()
    {
        byte[] readBuffer = new byte[1024];
        int numBytesRead;
        int totalNumBytesRead;

        while (!doneWriting)
        {
            try
            {
                // get the socket connection
                SSLSocket socket = getAppleServiceSSLSockett();
                socket.setSoTimeout(Config.APNS_READ_TIMEOUT_MILLISECONDS);

                InputStream socketInputStream = socket.getInputStream();

                // read (blocking)
                totalNumBytesRead = 0;
                while ((numBytesRead = socketInputStream.read(readBuffer)) != -1)
                    totalNumBytesRead += numBytesRead;

                // check for an error
                if (totalNumBytesRead > 0)
                {
                    synchronized (readWriteLock)
                    {
                        try
                        {
                            PushNotificationResponse response = new PushNotificationResponse(readBuffer, 0);
                            System.err.println("APNS Read got response with id: " + response.identifier);

                            // find the request with the given identifier
                            int i;
                            for (i = lastWrittenIndex; i > -1; --i)
                            {
                                if (pushNotificationRequestsReadingList.get(i).identifier == response.identifier)
                                    break;
                            }


                            if (i == -1)
                            {
                                // something went wrong, we didn't find the identifier
                                System.err.println("APNS Read unable to find request with id: " + response.identifier);
                            }
                            else
                            {
                                System.err.println("APNS Read " + response.getErrorMessage(pushNotificationRequestsReadingList.get(i)));

                                // add the requests between the bad request and the last written (included)
                                for (++i; i <= lastWrittenIndex; ++i)
                                    pushNotificationRequestsResnedList.add(pushNotificationRequestsReadingList.get(i));
                            }
                        }
                        catch (InvalidPushNotificationResponseException g)
                        {
                            g.printStackTrace();
                        }
                    }

                    // the socket will be closed, reopen it
                    try
                    {
                        reopenAppleServiceSSLSockett();
                    }
                    catch (AppleServiceConnectionException e)
                    {
                        e.printStackTrace();
                    }
                }
            }
            catch (SocketException e)
            {
                // ignore a close, it is expected
                if (!e.getMessage().equals("Socket closed"))
                    e.printStackTrace();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            catch (AppleServiceConnectionException e)
            {
                e.printStackTrace();
            }
        }
    }
}

Answer 1

它不是java，而是操作系统实际上为线程调度时间 block 。在生产者/消费者场景中，您希望在生产者方面提供公平性，以便一个生产者在所有其他生产者给出自己的输出后给出一个输出。为此，您可以使用一个线程来轮询几个懒惰的生产者。即:

N 个生产者公开 getNextThing() 和 1 个消费者对生产者进行循环并将结果通过管道传输到您使用的列表