How can I schedule to recycle the object after several minutes

Question

I have a defined a class to manage the game room. When a user creates a new room, I generate a new room with unique room number and add it to the hashset.

Now ,I hope to remove that Room object from the hashset and recycle the Room object for perfarmance issue, say 24 hours , or the abandoned Room object will spend most of my mememory

How can I achieve this? Also, any suggestion to improve the performance will be highly appreciated.

My class is as follows:

   public class RoomService {

private RoomService(){
    super();
}

private HashSet<Room> roomSet =new HashSet<Room>();

private static RoomService instance =new RoomService();

public static RoomService getServiceInstance(){
    return instance;
}

private static Integer generateRandom(int length) {
    Random random = new Random();
    char[] digits = new char[length];
    digits[0] = (char) (random.nextInt(9) + '1');
    for (int i = 1; i < length; i++) {
        digits[i] = (char) (random.nextInt(10) + '0');
    }
    return Integer.decode(new String(digits));
}

/**
 * Generate new Room with an unique Room number
 * @return
 */
public Room newRoom(){
    Room newRoom;
    do{
        newRoom =new Room(generateRandom(4));
    }
    while(!roomSet.add(newRoom));

    return newRoom;
}}







public class Room {
private Integer roomNum;
private Date createTime=new Date();
private String creatorId;


/*
 * constructor
 */
public Room(Integer roomNum) {
    super();
    this.roomNum = roomNum;
}




@Override
public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + ((roomNum == null) ? 0 : roomNum.hashCode());
    return result;
}


@Override
public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (getClass() != obj.getClass())
        return false;
    Room other = (Room) obj;
    if (roomNum == null) {
        if (other.roomNum != null)
            return false;
    } else if (!roomNum.equals(other.roomNum))
        return false;
    return true;
}




//getter and setter
//
//
public String getCreatorId() {
    return creatorId;
}

public void setcreatorId(String creatorId) {
    this.creatorId = creatorId;
}

public Integer getRoomNum() {
    return roomNum;
}

public Date getCreateTime() {
    return createTime;
}

}

Answer 1

You can do this yourself by using a Timer. Every time somebody creates a new room you create a new TimerTask instance that will delete the id again and schedule that task to be executed using public void schedule(TimerTask task, Date time). It could look something like this:

private final Timer timer; // Initialised somewhere

public Integer newRoomNum() {
    Integer newRoomNum = ... // Create id
    Date date = ... // Create date when the id should be deleted again
    timer.schedule(new DeleteKeyTask(newRoomNum), date);
    return newRoomNum;
}

Where DeleteKeyTask is a custom subclass of TimerTask that deletes the given id.

private class DeleteKeyTask extends TimerTask {
    private final Integer id;

    public DeleteKeyTask(Integer id) {
        this.id = id;
    }

    @Override
    public void run() {
        // remove id
    }

---

You could use different approaches to save space:

Instead of having a task per key, you can store the date along side the integer key. For example you can use a HashMap<Integer, Date> (or store milliseconds instead of date). The keys of the map form your previous set. The values indicate the time the key was inserted or expires.

You can then schedule the timer to remove the next expiring key, at that time you look for the next expiring key and schedule to remove that etc. This will cost you O(n) time to compute the next expiring key. Your run method for the task would look something like

public void run() {
    map.remove(id);
    Integer next = ... // Find next expiring key
    timer.schedule(new DeleteKeyTask(next), map.get(next));
}

And you would need to adapt the creation method:

public Integer create() { // Previously newRoomNum()
    Integer newRoomNum = ... // Create id
    Date date = ... // Create date when the id should be deleted again
    if(map.isEmpty()) // Only schedule when empty
        timer.schedule(new DeleteKeyTask(newRoomNum), date);
    map.put(newRoomNum, date);
    return newRoomNum;
}

This way you will just need to store a date per integer. If the O(n) overhead is too much for you when calculating the next, you can make it faster by using more space: use a Queue and insert new keys. The queue will allow you to retrieve the next expiring key, making looking up the next expiring key O(1).