多线程+批处理的问题

Question

其他地方有多线程调用putBeat方法，当list里面有8000条数据的时候就做一次批处理，现在想如果5秒内没有数据进来，则不满8000条也做同样的批处理操作， 这个时间改怎么加呢
public class T { private int batchSize = 8000;
private Object object;
private ArrayList<String> list = new ArrayList<String>();

public void putBeat(String rtua, String heartBeatTime) {

synchronized (object) {
if (list.size()>batchSize) {
//存满batchSize后做批处理
}
list.add(rtua+heartBeatTime);
/**
 * 如果5秒内没有数据进来，则也做批处理
 */
}// end
}
}

Answer 1

线程是一直运行的 有数据进来的时候就插入list 里面

Answer 2

如果是这样，可以在程序外边写个小程序，算时间用的，可以int n，每过一秒自动+1，然后在程序public void putBeat(String rtua, String heartBeatTime)里面判断是否n==5,等于5了就操作

Answer 3

在外部做控制,做一个每个5秒执行的定时器,当执行了putBeat方法时,将记时器重置.若5秒后没有执行方法,则自动执行一次,传入一个null.在你的putBeat方法中判断一下,如果传入的是null的话就不要add到list中

Answer 4

在后台用一个定时器处理：crontab

Answer 5

楼上的方法是可行的，也可以把原来的类也改成一个单独的线程，其他线程add的时候先添加到另外一个列表，然后notify这个线程，由这个单独线程完成add和提交操作，如果是add操作，然后这个单独的线程开始wait，设定为5秒就可以了。

Answer 6

顶!
不太清楚你的业务,简单做一个例子吧,跟上面说的是一个意思. 这里直接把Timer写成了T的一个属性了,根据业务,这个Timer应该是系统唯一的(单例的),你再根据业务调整吧, 不知道是不是你想要的功能. 这里是BlockedTimer的说明:class T {    private int batchSize = 8000;    
    private static int maxIdle=5000;
    private Object object;
    private List<String> list = new ArrayList<String>();
    // 定时器
    private BlockedTimer timer=new BlockedTimer(maxIdle){
        public void onTimer() {
            doBatch();  // 批处理
        }
    };
    public T(){
        timer.start();
    }
    public void putBeat(String rtua, String heartBeatTime) {
        synchronized (object) {
            if (list.size()>batchSize) {
                doBatch();  // 批处理
            }
            list.add(rtua+heartBeatTime);
            /**
             * 如果5秒内没有数据进来，则也做批处理
             */
        }// end
    }
    public void doBatch() {
        timer.reset();  // 重新计时
        synchronized (object){
            //存满batchSize后做批处理
        }
    }
}

Answer 7

昨天后来想想 写了一个public class T {    private int batchSize = 8000;    
    private Object object;
    private ArrayList<String> list = new ArrayList<String>();
    long lastTime = System.currentTimeMillis();
    public void putBeat(String rtua, String heartBeatTime) {
        
        synchronized (object) {
            if (list.size()>batchSize) {
                //存满batchSize后做批处理
            }
            list.add(rtua+heartBeatTime);
            lastTime = System.currentTimeMillis();
            /**
             * 如果5秒内没有数据进来，则也做批处理
             */
        }// end
    }
    public boolean disTime(){
long delta = System.currentTimeMillis() - lastTime;
return Math.abs(delta) >= 5*1000 && heartBeatArray.getSize()>0;
    }
    public void add(){
HeartBeatArray batchSaveArray = heartBeatArray;
if (batchSaveArray != null)
     addBatchSaveArray(batchSaveArray);
    }}启动线程的时候调用T() public void T(){
try {
Thread.sleep(10*1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
add();
T();
}
public void add() {
// TODO Auto-generated method stub
System.out.println("add:"+System.currentTimeMillis());
if(batchSaver.disTime()){
batchSaver.add();
}
}

Answer 8

class T {    private int batchSize = 8000;    
    private Object object;
    private ArrayList<String> list = new ArrayList<String>();
    private boolean bBatch;
    
    T()
    {
     startTimer();
    }
    
    public void putBeat(String rtua, String heartBeatTime) {
        
        synchronized (object) {
            if (list.size()>batchSize) {
             batch();
            }
            list.add(rtua+heartBeatTime);
            bBatch = false;
        }
    }
    
    private void batch()
    {
    
    }
    
    public void startTimer()
    {
TimerTask task = new TimerTask()
{
public void run()
{
if(bBatch)
{
batch();
}
else
{
bBatch = true;
}
}
};
new Timer().scheduleAtFixedRate(task, 0,5000);
}
}

Answer 9

我感觉timer.start();
放在putBeat方法里面好一点。

Answer 10

synchronized (object) 上面

Answer 11

多线程调用putBeat 你这样会启动多个timer