Passing data between hundreds of objects in java [closed]

Currently, I’m working with a group on building a model. This model simulates interactions between many “agents” in a region. Agents can be any entity such as a city, a farmer, a business etc. Each agent is represented by its own object within java. Each agent will need to be able to interact with all of the other agents, and therefore, needs to have access to information about the other agents.

So, for example, lets say we have 1 city object interacting with 99 farmer objects. The city needs to know for instance, the total land that each of the 99 farmers owns in order to perform some sort of calculations.

So, my question is, what is the most performance efficient way of completing something like this? There may even be 500-1000 or more agents in the future, and each agent may need to access many variables from the other agents. Would you potentially set up a table within mysql for each agent and have them access eachother’s information that way?
Or can something be set up directly within java that allows the agents to access each other’s information.

I’m looking to possibly multithread this model in the future too. In any case, I want the most performance efficient way of completing this.

You have two options:

Every agent knows about every other agent, and queries those agents as needed.
Every agent publishes its state changes, and other agents listen to the changes they care about.

The second approach has several benefits over the first, most important being that changes only happen when necessary. For example, if only 2 farmers trade land, the city doesn’t need to query the other 97 farmers.

There are many ways to go about implementing this. I would not put a database in the mix, but would instead use an in-memory event bus with publishes and subscribers. There are ready-made systems to do this, or you could roll your own.

As pointed out in the other answers, it depends on your unique circumstances (needed to run the simulations) whether to use a real database, or a real geographic information system (GIS).

Regardless of you choice of tooling, one thing is certain: your simulations will involve application logic that is superficially similar to what is done by databases and GIS systems. Namely:

Queries over a large number of objects –
some of which may be outside the object hierarchy.
Calculations e.g. sums, averages, minimums and maximums, or other statistical / mathematical / geometrical operations over objects within a certain spatial extent.
- See: Spatial query, and Nearest neighbor search.

Recognize that you will need to learn new concepts no matter what.

Using existing tools (databases and GIS systems) does not save you from having to learn about relational and spatial queries.
Writing your own code does not save you from having to learn about relational and spatial queries (*).

_{(*) repeated for emphasis.}

However, by using existing tools,

You could save time from implementing algorithms for doing that.
In exchange, you will spend more time learning how those tools work, and formulating your simulation requirements into queries with these tools.

On the other hand, the concern expressed in your question is too far from your immediate needs. Namely:

Should I favor a centralized (database) approach, or a decentralized (peer-to-peer, or object-oriented) approach when modeling these operations?
What would be the performance from each approach?
- (See below.)
How do I partition the system for scalability?

You can always revisit architectural decisions next month; however you need to figure out how to meet the needs of your simulation application this week.

What would be the performance from each approach?

Practically speaking, you wouldn’t know until you implement both approaches, optimize them, and then compare their performance.

Theoretically speaking, we need to know exactly what types of algorithms (queries) are performed. Such as:

Queries can be solved by “keeping a tally (sum) up to date”
Queries can be solved by a look-up of a handful of items
Queries that involves 2D spatial search
Queries that involves evaluating a mathematical equation for every pair of objects. (This is going to be slow.)

If you only give “examples”, the usefulness of the advice will depend on how good your examples reflect your application needs.

Get the data design done first. Understanding what data you need for each entity, and how the entities relate should simplify your design.

You may find you have many entities which can be modeled as sub-types. Different sub-types may have different behavior, but should contain the same state (data). Understanding the common and specific behaviors of similar agents will help you design your class hierarchy.

You will likely want a database for persistence, but keep the behavior in the application. I would expect most of the data to be at rest (persisted to the database) most of the time. Databases can be quite efficient at answering questions like how many acres do the farmers in this city have.

If by agent you mean objects, then you are looking at a rather small set of data. You may be able to keep the data in an in-memory database. Even if you don’t the data may well fit in the database and/or operating system memory.

EDIT: The container should be pooling connections to the database so you shouldn’t have any agents connecting to the mysql. They should be asking model object (database proxies) for data, and those may run a database query. Well designed databases are very efficient at gathering data about related entities (agents).

Unless you are running simulations of long term data, it is unlikely the changes will happen often enough to make an observer/mediator type structure work very well. This pattern more appropriate when data is changing several times a minute, not several times a year. Even with hundreds of farmers, I would expect changes to be minutes between during harvest season, and days between the rest of the year.

If you are doing everything in memory you risk loosing all the data whenever the application goes down. Over a period of years, this will be a certainty. Being able to update and restart the application would appear to be essential to your design evolution.

Filed under: softwareengineering - @ 01:21

Thẻ: data, design, design-patterns, java, mysql

Thiết kế website giá rẻ

Danh mục

Passing data between hundreds of objects in java [closed]