Java多线程时间切换
我对Java中多线程如何在较低层次上工作的了解很少。我知道当您有两个线程运行时，Java会将“时间块”分配给每个线程执行。Java多线程时间切换,java,multithreading,Java,Multithreading,我对Java中多线程如何在较低层次上工作的了解很少。我知道当您有两个线程运行时，Java会将“时间块”分配给每个线程执行。 例如： public void test() { Thread testThread = new Thread(new TestThread()); testThread.start(); for (int i = 0; i < Integer.MAX_VALUE; ++i) System.out.print("a"); }
例如：
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");
}
}
公共无效测试（）
{
线程testThread=新线程（newtestthread（））；
testThread.start（）；
对于（int i=0；iAAAAAAAAAAAABBBBBBBBAAAAAAAAAAAAAAABBBBBBBBBBAAAAA…
而不是：
阿巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴巴
我的问题是：有没有可能减少“时间块”，让我们更接近：
aabbaabbaabbaabbaabbaabbaabbaabbaabbaabbaabbaabbaabbaabbaabbaabbaabbaabbaabbaabbaabbaabbaabbaabbaabbaabbaabbaabbaabbaabbaabbaabbaabbaabbaabbaabbaabb
为什么？我正在尝试编写一个苹果推送通知服务器（只是为了好玩）。当您向apple推送通知服务写入请求时，可能会发生一两件事：
1.如果请求有效，则不会返回任何内容。
2.如果请求无效，它将返回错误代码并关闭连接，在无效请求之后和连接关闭之前发送的任何请求都将被丢弃。
因为读取套接字会一直阻塞，直到数据可以读取为止（如果我不写入任何无效请求，这可能永远不会发生），所以我不能在每次写入之后简单地读取，以查看是否存在错误，而不设置200-500毫秒的超时。如果有一百万个请求需要写入（很可能），那么这个超时将增加55-138小时，并且我们可能会由于超时时间短而错过返回的错误，这将导致请求永远无法发送。
因此，我有两个类似于上面示例的线程，一个正在向服务器写入，另一个正在读取，等待查看是否返回错误。问题是：如果请求#4不好，但我们在读取错误并关闭连接之前写入了#5-#10，那么苹果服务将丢弃请求#5-10。因此，一旦我们知道#4不好，并且我们知道我们编写的最后一个请求是#10，我们需要重新排队#5-10以便再次发送。
我现在遇到的问题是，由于“时间卡盘”很大，我能够在读取线程读取之前写入请求#1-#400，因为#5出错，所以#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();
}
}
}
}
private Object readWriteLock=new Object（）；
私有volatile int lastWrittenIndex；
私人写作；
私有列表pushNotificationRequestsResnedList=new ArrayList（）；
公共布尔写（）
{
//获取请求读取列表
列表请求=getPushNotificationRequests（false）；
//只要有更多的通知要写。。。
while（requests.size（）>0）
{
lastWrittenIndex=-1；
doneWriting=false；
//创建并启动读取线程
Thread readThread=新线程（new readThread（），“APNS读取器”）；
readThread.start（）；
对于（int i=0；i0）
{
requests.addAll（pushNotificationRequestsResnedList）；
//清除重新发送列表
pushNotificationRequestsResnedList.clear（）；
}
}
}
私有类ReadThread扩展线程
{
公开募捐
{
字节[]读缓冲区=新字节[1024]；
int numBytesRead；
整数总字节数；
当（！不要写）
{
尝试
{
//获取套接字连接
SSLSocket套接字=getAppleServiceSSLSocke
// using Thread.yield() MIGHT give you the results you want
for (int i = 0; i < Integer.MAX_VALUE; ++i)
{
System.out.print("a");
Thread.yield();
}