自己编写的一个数据结构，类似优先级队列

package com.yeepay.sxf.compensation;

import java.sql.Date;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Random;
/**
* 该数据结构类似优先级队列。（生产线程往该数据结构存放任务，消费线程从该数据结构取任务执行）
* （1）生产线程根据等级往不同的容器中存放任务。
* （2）消费线程根据不同等级的权重，每次取用时获取一个根据权重计算出来的等级，从不同等级的容器中获取任务。
* （3）任务是有执行时间的。如果当前时间不到该任务的执行时间，则让获取该任务的当前线程wait相应的时间。
* @author sxf
*
*/
public class CompensationQueue {
/**
* 一级锁
*/
private final Object firstLock=new Object();
/**
* 二级锁
*/
private final Object secondLock=new Object();
/**
* 三级锁
*/
private final Object thirdLock=new Object();
/**
* 一级订单
*/
private final LinkedList<OrderResponse> firstList=new LinkedList<OrderResponse>();
/**
* 二级订单
*/
private final LinkedList<OrderResponse> secondList=new LinkedList<OrderResponse>();
/**
* 三级订单
*/
private final LinkedList<OrderResponse> thirdList=new LinkedList<OrderResponse>();
/**
* 一级读取次数
*/
private Integer readFirstInteger=0;
/**
* 二级读取次数
*/
private Integer readSencodInteger=0;
/**
* 三级读取次数
*/
private Integer readThirdInteger=0;
/**
* 时间间隔
*/
private Integer timeLongInteger=0;
/**
* 尝试读取几次
*/
private Integer reads;
/**
* 一级别权重
*/
private Integer firstWeight;
/**
* 二级权重
*/
private Integer sencodWeight;
/**
* 三级权重
*/
private Integer thirdWeight;
/**
* 一级读取最大数降级
*/
private  final Integer readFirstMax;
/**
* 二级最大数
*/
private final Integer readSecondMax;

public CompensationQueue(Integer timeLongInteger,Integer reads,Integer firstWeight, Integer sencodWeight,Integer thirdWeight,Integer readFirstMax,final Integer readSecondMax) {
super();
this.timeLongInteger = timeLongInteger;
this.reads=reads;
this.firstWeight=firstWeight;
this.sencodWeight=sencodWeight;
this.thirdWeight=thirdWeight;
this.readFirstMax=readFirstMax;
this.readSecondMax=readSecondMax;
}

/**
* 存放一笔订单
* @param orderResponse
* @return
*/
public boolean putOrderResponse(OrderResponse orderResponse){
//获取数据等级
Integer ad=orderResponse.getLeveInteger();
//根据等级放入相应的等级容器中
if(ad==1){
try {
synchronized (firstLock) {
firstList.addFirst(orderResponse);
}
}finally{
firstLock.notifyAll();
}

}else if(ad==2){
try {
synchronized (secondList) {
secondList.addFirst(orderResponse);
}
}finally{
secondLock.notifyAll();
}

}else if(ad==3){
try {
synchronized (thirdLock) {
thirdList.addFirst(orderResponse);
}
}finally{
thirdLock.notifyAll();
}
}
return false;
}
/**
* 获取一笔订单
* @param orderResponse
* @return
*/
public OrderResponse getOrderResponse(){
//获取权重
Integer leve=getWeightLeve();
int count=0;

//一级降二级标识
boolean flagA=false;
//二级降三级标识
boolean flagB=false;
//三级升一级标识
boolean flagC=false;
for(int a=0;a<reads;a++){
if(leve==1||(leve==3&&flagC)){
flagC=false;
synchronized (firstLock) {
if(firstList.size()>0){
if(readFirstInteger<readFirstMax){
//如果还每到执行时间，就让当前线程休眠多长时间
OrderResponse orderResponse=firstList.getLast();
Date nextDate=orderResponse.getNextTime();
Long aLong=0L;
while((aLong=System.currentTimeMillis()-nextDate.getTime())<0){
try {
firstLock.wait(aLong);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
readFirstInteger++;
return firstList.removeLast();
}else{
readFirstInteger=0;
flagA=true;
}
}else{
flagA=true;
}
}
}

if(leve==2||(leve==1&&flagA)||(leve==3&&flagA)){
flagA=false;
synchronized (secondLock) {
if(secondList.size()>0){
if(readSencodInteger<readSecondMax){
OrderResponse orderResponse=secondList.getLast();
Date nextDate=orderResponse.getNextTime();
Long aLong=0L;
while((aLong=System.currentTimeMillis()-nextDate.getTime())<0){
try {
secondLock.wait(aLong);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
readSencodInteger++;
return secondList.removeLast();
}else{
readSencodInteger=0;
flagB=true;
}
}else{
flagB=true;
}
}
}

if(leve==3||(leve==2&&flagB)||(leve==1&&flagB)){
flagB=false;
synchronized (thirdLock) {
if(thirdList.size()>0){
OrderResponse orderResponse=thirdList.getLast();
Date nextDate=orderResponse.getNextTime();
Long aLong=0L;
while((aLong=System.currentTimeMillis()-nextDate.getTime())<0){
try {
thirdLock.wait(aLong);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return thirdList.removeLast();
}else{
flagC=true;
}
}
}
}
return null;
}

private Integer getWeightLeve(){
Map<Integer, Integer> map=new HashMap<Integer, Integer>();
map.put(firstWeight,1);
Integer sencodSum=firstWeight+sencodWeight;
map.put(sencodSum, 2);
Integer sum=sencodSum+thirdWeight;
map.put(thirdWeight, 3);

for(Integer sumd:map.keySet()){
Random r = new Random(System.currentTimeMillis());
int radom = Math.abs(r.nextInt())%sum;
if(sumd>radom){
return map.get(sumd);
}
}

return 1;
}

public Integer getReadFirstInteger() {
return readFirstInteger;
}
public void setReadFirstInteger(Integer readFirstInteger) {
this.readFirstInteger = readFirstInteger;
}
public Integer getReadSencodInteger() {
return readSencodInteger;
}
public void setReadSencodInteger(Integer readSencodInteger) {
this.readSencodInteger = readSencodInteger;
}
public Integer getReadThirdInteger() {
return readThirdInteger;
}
public void setReadThirdInteger(Integer readThirdInteger) {
this.readThirdInteger = readThirdInteger;
}

}