How to prioritize a certain request in java?

This may be a workaround, as it must be executed before the requests are sent. Taking into account your use case (500 requests at sec), my suggestion is to send first the most critical ones, by using a PriorityQueue.

As you already batch the messages in order to send them, this approach would help into ordering the batched messages in base of the set priority.

You could first wrap the requests into another entity that holds a priority field. For example, an skeleton/base PriorityRequest class:

public class PriorityRequest implements Comparable<PriorityRequest> 
{
    public int priority;
    public PriorityRequest(int priority) 
    {
       this.priority=priority;
    }

    @Override
    public int compareTo(PriorityRequest request) 
    {
       return Integer.compare(request.priority,this.priority);
    }
}

And declare both children, HttpPost and HttpGet:

public class PriorityHttpPost extends PriorityRequest 
{
    public HttpPost post;
    public PriorityHttpPost(int priority, HttpPost post) 
    {
       super(priority);
       this.post=post;
    }
}        

public class PriorityHttpGet extends PriorityRequest 
{
    public HttpGet get;
    public PriorityHttpGet(int priority, HttpGet get) 
    {
       super(priority);
       this.get=get;
    }
}

So, while you create the requests, you could insert them into the queue so they get automatically located in base of their priority:

Queue<PriorityRequest> requestQueue = new PriorityQueue<>();

/*into the batch mechanism*/
requestQueue.add(new PriorityHttpPost(6,httpPost));
//...
requestQueue.add(new PriorityHttpGet(99,httpGet));
//...

This way, you guarantee the requests with higher priority to leave the queue before the lesser priority ones, as they will be ordered in descending order.

Queue- | Get  (99) | --> out
       | Get  (9)  |
       | Post (6)  |
       | Get  (3)  |
       | Post (1)  |

Queue- | Get  (9)  | --> out
       | Post (6)  |  
       | Get  (3)  |
       | Post (1)  |

        (...)

Just to finish, a little extra feature of this approach (in certain use cases) would consist of being able to define which elements go first and which go last:

requestQueue.add(new PriorityHttpPost(INTEGER.MAX_VALUE, httpPostMax));
requestQueue.add(new PriorityHttpPost(INTEGER.MAX_VALUE-1, httpPostVery));
requestQueue.add(new PriorityHttpPost(INTEGER.MIN_VALUE+1, httpPostNotVery));
requestQueue.add(new PriorityHttpPost(INTEGER.MIN_VALUE, httpPostNoOneCares));

--

perfect world, yeah, i know..

Queue- | Post (MAX)   | --> out
       | Post (MAX-1) |
       | ............ |
       | ............ |
       | Post (MIN+1) |
       | Post (MIN)   |