Make it possible to identify the current worker.

ProtocolLib/src/com/comphenix/protocol/async/AsyncListenerHandler.java

@@ -30,6 +30,9 @@ public class AsyncListenerHandler {
 	 */
 	private static final PacketEvent WAKEUP_PACKET = new PacketEvent(new Object());
 	
+	// Unique worker ID
+	private static final AtomicInteger nextID = new AtomicInteger();
+	
 	// Default queue capacity
 	private static int DEFAULT_CAPACITY = 1024;
 	
@@ -39,9 +42,6 @@ public class AsyncListenerHandler {
 	// Number of worker threads
 	private final AtomicInteger started = new AtomicInteger();
 	
-	// Unique local worker ID
-	private final AtomicInteger nextID = new AtomicInteger();
-	
 	// The packet listener
 	private PacketListener listener;
 
@@ -132,12 +132,17 @@ public class AsyncListenerHandler {
 	 * <p>
 	 * <b>Warning</b>: Never call the run() method in the main thread.
 	 */
-	public Runnable getListenerLoop() {
+	public AsyncRunnable getListenerLoop() {
 		return new AsyncRunnable() {
 
 			private final AtomicBoolean running = new AtomicBoolean();
 			private volatile int id;
 			
+			@Override
+			public int getID() {
+				return id;
+			}
+			
 			@Override
 			public void run() {
 				// Careful now
@@ -271,7 +276,7 @@ public class AsyncListenerHandler {
 	}
 	
 	// DO NOT call this method from the main thread
-	private void listenerLoop(int taskID) {
+	private void listenerLoop(int workerID) {
 		
 		// Danger, danger!
 		if (Thread.currentThread().getId() == mainThread.getId()) 
@@ -302,7 +307,7 @@ public class AsyncListenerHandler {
 					// This is a bit slow, but it should be safe
 					synchronized (stopLock) {
 						// Are we the one who is supposed to stop?
-						if (stoppedTasks.contains(taskID)) 
+						if (stoppedTasks.contains(workerID)) 
 							return;
 						if (waitForStops())
 							return;
@@ -311,6 +316,9 @@ public class AsyncListenerHandler {
 				
 				// Here's the core of the asynchronous processing
 				try {
+					marker.setListenerHandler(this);
+					marker.setWorkerID(workerID);
+					
 					if (packet.isServerPacket())
 						listener.onPacketSending(packet);
 					else

ProtocolLib/src/com/comphenix/protocol/async/AsyncMarker.java

@@ -67,6 +67,10 @@ public class AsyncMarker implements Serializable, Comparable<AsyncMarker> {
 	// Whether or not the asynchronous processing itself should be cancelled
 	private volatile boolean asyncCancelled;
 	
+	// Used to identify the asynchronous worker
+	private AsyncListenerHandler listenerHandler;
+	private int workerID;
+	
 	// Determine if Minecraft processes this packet asynchronously
 	private static Method isMinecraftAsync;
 	private static boolean alwaysSync;
@@ -215,11 +219,47 @@ public class AsyncMarker implements Serializable, Comparable<AsyncMarker> {
 		this.asyncCancelled = asyncCancelled;
 	}
 
+	/**
+	 * Retrieve the current asynchronous listener handler.
+	 * @return Asychronous listener handler, or NULL if this packet is not asynchronous.
+	 */
+	public AsyncListenerHandler getListenerHandler() {
+		return listenerHandler;
+	}
+
+	/**
+	 * Set the current asynchronous listener handler. 
+	 * <p>
+	 * Used by the worker to update the value.
+	 * @param listenerHandler - new listener handler.
+	 */
+	void setListenerHandler(AsyncListenerHandler listenerHandler) {
+		this.listenerHandler = listenerHandler;
+	}
+
+	/**
+	 * Retrieve the current worker ID.
+	 * @return Current worker ID.
+	 */
+	public int getWorkerID() {
+		return workerID;
+	}
+
+	/**
+	 * Set the current worker ID.
+	 * <p>
+	 * Used by the worker.
+	 * @param workerID - new worker ID.
+	 */
+	void setWorkerID(int workerID) {
+		this.workerID = workerID;
+	}
+
 	/**
 	 * Retrieve iterator for the next listener in line.
 	 * @return Next async packet listener iterator.
 	 */
-	public Iterator<PrioritizedListener<AsyncListenerHandler>> getListenerTraversal() {
+	Iterator<PrioritizedListener<AsyncListenerHandler>> getListenerTraversal() {
 		return listenerTraversal;
 	}
 	

ProtocolLib/src/com/comphenix/protocol/async/AsyncRunnable.java

@@ -7,6 +7,12 @@ package com.comphenix.protocol.async;
  */
 public interface AsyncRunnable extends Runnable {
 	
+	/**
+	 * Retrieve a unique worker ID.
+	 * @return Unique worker ID.
+	 */
+	public int getID();
+	
 	/**
 	 * Stop the given runnable.
 	 * <p>