Re: Data sharing between threads in robocode
"thYms" <dkalfa@gmail.com> wrote in message
news:1149432719.335821.197210@c74g2000cwc.googlegroups.com...
This is my first post to this grup and I have a little problem with
sharing a static object between threads. There is two thread class and
each of them refer to a static object of a third class through static
methods of the same class.
Problem is, when they refer to that static member, I realised that they
don't refer to same object although I declared it static.
As long as you have don't re-assign the static variable the threads
definately will be sharing the same instances. There are other reasons why
the data may not appear to change-- see below...
// This is the third class that I mentioned above
public class Repository {
public static ArrayList<String> enemyNames = new
ArrayList<String>();
public static HashMap<String, EnemyBot> enemies = new
HashMap<String, EnemyBot>();
public static HashMap<String, TeamBot> teammates = new
HashMap<String, TeamBot>();
public Repository() {
}
public static synchronized void
updateEnemyRepository(ScannedRobotEvent event, TeamRobot myRobot)
{
....
}
public class WarTorch extends TeamRobot
{
public void run()
{
while(true)
{
setTurnRadarRight(Integer.MAX_VALUE);
execute();
}
}
public void onScannedRobot(ScannedRobotEvent e)
{
// Here this class refer to the third class.
Repository.updateEnemyRepository(e, this);
for (Iterator it = Repository.enemyNames.iterator();
it.hasNext();) {
Object key = (String) it.next();
System.out.println(key + " - "
+Repository.enemies.get((String)key).getRobotName() + ", " +
Repository.enemies.get((String)key).getCoordinates());
System.out.println(e.getName());
}
}
Unfortunately, creating shared access to a resource is more complex than
this. You have correctly established that only one thread may update the
Enemy Repository at any time. What it seems you haven't protected against
is that one robot may be reading the repository while another is updating
it. One thread is busy within updateEnemyRepository changing whatever data
structures it needs to change. The other is at a different point within
OnScannedRobot and is reading out the enemy names and their data. All kinds
of data mis-interpreation can go on here and I'm surprised that the only
error you're seeing is that data don't appear to update.
Although both threads are sharing the same static variables, the reading
threads may not see the changes to the writing threads immediately. This is
because changes are only made available to other threads at the end of
synchronization blocks or via volatile variables. The mechanics of this can
be complicated and you can read about it texts such as Doug Lea's book, but
essentially if you want other threads to see the values in a reasonable time
both the reader and writer must be synchronized.
There are quite a number of way to solve this problem but they all have
trade-offs. What is the most important to you? Simplicity of the
synchronization method? Timeliness of data propagation? Correctness of
results? You are currently using an efficient method that sometimes
generates incorrect results. By fully synchronizing read-state access you
can have a very correct method that is very inefficient. Or you can make
your synchronization more complex so that it says correct and reasonably
efficient.
Cheers,
Matt Humphrey matth@ivizNOSPAM.com http://www.iviz.com/