Concurrency noob needs strategies not just facts.

Question

I'm a concurrency noob. I've read up on it quite a bit I understand most of it but I've written this program and I'm completely clueless as to how to get my time sensitive data threaded correctly. I've included a vastly oversimplified version just for this post. Look at it like a midi sequencer where, at the same time, you have data being edited via GUI and played back by a clock. Of course, this is a simplification, but in the real version, it sometimes happens that the GUI part of the program can be so taxing that it pushes the timed part out of wack. Can someone point me in the right strategic direction?
This is how the unthreaded program is structured. I tried to make it as close to MVC as possible.
import java.util.*;
public class TryThis {
/*main method simulates the program running*/
     public static void main(String args[]) {
          InfoPlayer myInfoPlayer = new InfoPlayer(); // an object to do time sensitive operations on global data
          InfoEditor myInfoEditor = new InfoEditor(); // an object to send events to edit global data
          InfoDisplayer myInfoDisplayer = new InfoDisplayer(); // an object to display any changes made to global data
          // time sensitive information requested
          myInfoPlayer.string();
          myInfoPlayer.integer();
          // user alters data
          myInfoEditor.setString("joooo");
          myInfoEditor.setInt(11111);
          // time sensitive information requested
          myInfoPlayer.string();
          myInfoPlayer.integer();
          // user alters data
          myInfoEditor.setString("korea");
          myInfoEditor.setInt(3333);
          // time sensitive information requested
          myInfoPlayer.string();
          myInfoPlayer.integer();
/* 1: receives instructions on how to edit info
* 2: edits info
* 3: sends same instructions out as an event to update displays*/
class GlobalReference {
     static private InfoHolder myInfo = new InfoHolder();
     static protected javax.swing.event.EventListenerList listenerList = new javax.swing.event.EventListenerList();
     public static InfoHolder getMyInfo() {
          return myInfo;
     static public void doMyEvent(MyEvent me) {
          if (me.getChangeStringOrInt() == MyEvent.STRING) {
               myInfo.setString(me.getString());
          } else {
               myInfo.setInt(me.getInt());
          fireMyEvent(me);
     static public void addMyEventListener(MyEventListener listener) {
          listenerList.add(MyEventListener.class, listener);
     static void fireMyEvent(MyEvent evt) {
          Object[] listeners = listenerList.getListenerList();
          for (int i = 0; i < listeners.length; i += 2) {
               if (listeners[i] == MyEventListener.class) {
                    ((MyEventListener) listeners[i + 1]).myEventOccurred(evt);
//The info
class InfoHolder {
     String string = "default String";
     int integer = 0;
     public String getString()
          {return string;     }
     public void setString(String myString)
          {this.string = myString;}
     public int getInt()
          {return integer;}
     public void setInt(int myInt)
          {this.integer = myInt;}
//Simulates program displaying data,  listens for updates
class InfoDisplayer implements MyEventListener {
     public InfoDisplayer() {
          GlobalReference.addMyEventListener(this);
     public void myEventOccurred(MyEvent evt) {
          if (evt.getChangeStringOrInt() == MyEvent.STRING) {
               System.out.print("InfoDisplayer:\t\t" + evt.getString() + "\n");
          } else {
               System.out.print("InfoDisplayer:\t\t" + evt.getInt() + "\n");
//simulates user using the UI to edit data
class InfoEditor {
     public void setString(String s) {
          /* event says set global string to source s */
          MyEvent temp = new MyEvent(s, MyEvent.STRING);
          GlobalReference.doMyEvent(temp);
     public void setInt(int i) {
          /* event says set global int to source i */
          MyEvent temp = new MyEvent(i, MyEvent.INT);
          GlobalReference.doMyEvent(temp);
//Simulates calls for time sensitive(read clocked) actions on global data.
class InfoPlayer {
     public void string() {
          System.out.print("InfoPlayer:\t\t"
                    + GlobalReference.getMyInfo().getString() + "\n");
     public void integer() {
          System.out.print("InfoPlayer:\t\t"
                    + GlobalReference.getMyInfo().getInt() + "\n");
/* 1 instructs static info repository on how to edit data,
* 2 then gets send by static repository to update any listeners
class MyEvent extends EventObject {
     static boolean STRING = false, INT = true;
     boolean changeStringOrInt = STRING;
     public MyEvent(Object source, boolean changeStringOrInt) {
          super(source);
          this.changeStringOrInt = changeStringOrInt;
     public String getString()
          {return (String) source;}
     public int getInt()
          {return (Integer) source;}
     public boolean getChangeStringOrInt()
          {return changeStringOrInt;}
/*describes any object that might be used to display global data*/
interface MyEventListener extends EventListener {
     public void myEventOccurred(MyEvent evt);
}Edited by: Mat on May 10, 2009 11:34 PM
Edited by: Mat on May 10, 2009 11:47 PM

Answer 1

Can someone point me in the right strategic direction?That's the only question I can see. It's not much of a question, is it? I suggest you state your problem in more detail. And I don't think the code really helps much at this stage.