[JAVA] waarde van thread in sleep() opvragen

[Verwijderd]

Ik heb een probleem
Ik heb 2 gegevens van 2 threads nodig voor een berekening, echter als thread1 aanbod is gekomen en het gegeven is "opgeslagen" en thread 2 wordt voortgezet wordt het gegeven van thread 1 weggegooid zodat ik het niet kan gebruiken voor de berekening. Heeft iemand hier een oplossing voor

code:

if(thread==1)
{
      gegeven=gegeven+v1;
      this.gegeven1=gegeven;
}
if(thread==2)
{
      gegeven=gegeven+v2;
      this.gegeven2=gegeven;
}

[Jelmer]

synchronized

Misschien wel interresant om je mee bezig te gaan houden:
http://www.icim.fnt.hvu.n...meen/Sheets%20Casus-2.zip
http://www.icim.fnt.hvu.n...sp1/Casussen/Casus.2.html

[ Voor 107% gewijzigd door Jelmer op 16-01-2003 21:51 ]

[Predator]

Yup dat moet je via synchronized doen, er staat een goed stukje daarover in de Java tutorial

http://java.sun.com/docs/...hreads/multithreaded.html

[Soultaker]

Misschien ben ik dom hoor, maar hoe weten jullie nu waar het over gaat, en dat 'synchronized' de oplossing is? Ik snap het probleem in ieder geval nog niet en kan dus niet zonder meer zeggen dat het probleem 'm alleen in de asynchrone executie zit en niet, bijvoorbeeld, in de manier waarop in variabelen wordt geschreven.

Maar goed, als de TS hier tevreden mee is, vind ik het ook goed. Moet 'ie maar duidelijker verwoorden wat de bedoeling is (*HINT*).

[ Voor 20% gewijzigd door Soultaker op 16-01-2003 21:54 ]

[Verwijderd]

ik ben nog maar een beginnende in java please don't blame me als ik het vaag omschrijf, maar ik denk wel dat ik het probleem juist heb omschreven.

[Alarmnummer]

Soultaker schreef op 16 January 2003 @ 21:54:
Misschien ben ik dom hoor,

hmmmzz

maar hoe weten jullie nu waar het over gaat, en dat 'synchronized' de oplossing is?

Volgens mij snap jij nog niet helemaal hoe concurrency control werkt. Als je overal gewoon synchronized voor plakt, dan komt het allemaal wel goed. Deadlocks? waar?

Ik snap het probleem in ieder geval nog niet en kan dus niet zonder meer zeggen dat het probleem 'm alleen in de asynchrone executie zit en niet, bijvoorbeeld, in de manier waarop in variabelen wordt geschreven.

Maar goed, als de TS hier tevreden mee is, vind ik het ook goed. Moet 'ie maar duidelijker verwoorden wat de bedoeling is (*HINT*).

Ik ben het roerend met je eens dat synchronized idd de goeie oplossing is bij de gestelde vraag.

*snapt ook geen h*l van de vraag.

ik ben nog maar een beginnende in java please don't blame me als ik het vaag omschrijf, maar ik denk wel dat ik het probleem juist heb omschreven.

code:

if(javanoob(the-gothic)){
     vingersVanThreadsAf=true;
}

[ Voor 17% gewijzigd door Alarmnummer op 16-01-2003 22:03 ]

[Verwijderd]

Alarmnummer schreef op 16 januari 2003 @ 22:02:

*snapt ook geen h*l van de vraag.


[...]

code:

if(javanoob(the-gothic)){
     vingersVanThreadsAf=true;
}

THNX
wil je dat ff aan mijn leraar vertellen, ben ik mooi van de opdracht af

[Verwijderd]

Ik probeer het probleem van de 2 threads op te lossen door er 1 thread van te maken
maar ieder geval bedankt voor de moeite

[Verwijderd]

Alarmnummer schreef op 16 January 2003 @ 22:02:
Volgens mij snap jij nog niet helemaal hoe concurrency control werkt. Als je overal gewoon synchronized voor plakt, dan komt het allemaal wel goed. Deadlocks? waar?

Ik neem aan dat je het goed bedoeld, maar zo staat het er in iedergeval nu niet. Deadlocks kunnen het gevolg van synchronisatie zijn. Of bedoelde je het ook zo?

[johnny7]

Het was sarcastisch bedoeld, denk ik zo.

[Jelmer]

Soultaker schreef op 16 January 2003 @ 21:54:
Misschien ben ik dom hoor,

Misschien wel ja. Ik citeer:

echter als thread1 aanbod is gekomen en het gegeven is "opgeslagen" en thread 2 wordt voortgezet wordt het gegeven van thread 1 weggegooid

Duidelijk een concurrency probleempje zoals het omschreven staat, als je het mij vraagt.

Alarmnummer schreef op 16 januari 2003 @ 22:02:
Als je overal gewoon synchronized voor plakt, dan komt het allemaal wel goed. Deadlocks? waar?

Valt me erg van je tegen.... synchronized *hoeft* niet altijd om blocken code heen of voor een methode declaratie te staan. Je kan er ook een meganisme mee bouwen waarmee je threads beurtelings dingen laat doen (ok, weg met je concurrency, maar het gaat ff om het idee. Je kan immers ook recourses controllen oid) Lees de documenten in die links maar die ik eerder gegevens heb...


.... tja, k ga maar eens slapen, morgen weer tentamen...

[Alarmnummer]

Jammer dat de sarcasme sommige mensen is ontgaan

Ik zie helaas te vaak dat mensen denken dat ze met overal het synchronized keyword maar voorplaatsen dat alle problemen dan zijn opgelost. Vandaar dat ik dit als reactie poste. Concurrency control is een erg lastige zaak omdat er op 1 tijdstip zoveel verschillende combinaties van dingen gebeuren en je moet voor iedere combinatie een passende oplossing bedenken of de combinatie uitsluiten. Dit maakt concurrency control al snel tot iets gecompliceerds. En als je deadlocks er bij gaat betrekken dan vind ik threads toch wel iets erg gevaarlijks.

[ Voor 116% gewijzigd door Alarmnummer op 16-01-2003 22:49 ]

[.oisyn]

Jelmer schreef op 16 January 2003 @ 22:26:
Duidelijk een concurrency probleempje zoals het omschreven staat, als je het mij vraagt.

heeft imho weinig met concurrency control te maken, als je het mij vraagt is de grote fout die ie maakt dat beide threads op dezelfde variabele werken, terwijl hij wel duidelijk 2 verschillende waarden wilt opvragen

Maar goed, * .oisyn snapt ook weinig van z'n probleem

[Soultaker]

Jelmer schreef op 16 januari 2003 @ 22:26:.... tja, k ga maar eens slapen, morgen weer tentamen...

Misschien is het inderdaad maar beter als je lekker gaat slapen en niet meer reageert voor je weer helemaal goed wakker bent.

off-topic, erm, on-topic:
is iemand er al uit, wat dit alles met sleep() te maken heeft?

[ Voor 16% gewijzigd door Soultaker op 16-01-2003 23:06 ]

[Verwijderd]

nou de volledige code maar omdat het spulletje toch met twee threads moet

code:

class Auto extends Thread {
  private int[] auto1=new int[2],
                auto2=new int[2];
  private int autonr,gewicht,v,beginpunt;
  private boolean doorgaan;
  private String richting;
  protected Graphics g;
  
  public Auto( Graphics g,int autonr, int gewicht, int beginpunt ,int v) {
    this.g = g;
    this.autonr=autonr;
    this.gewicht=gewicht;
    this.beginpunt=beginpunt;
    this.v=v;
    doorgaan = true;
  }

  public void run() {
    g.translate( 200, 200 );
    while( doorgaan ) {
      verplaats();
      teken( g, Color.red );
      slaap( 100 );
      teken( g, Color.white );
    }
  }
  public void nuStoppen() {
    doorgaan = false;
  }
  private void teken( Graphics g, Color kleur ) {
    g.setColor( kleur );
    g.fillOval( beginpunt, 0, 10,10 );
    g.setColor( Color.black );
  }

  private synchronized void verplaats() {
    if( beginpunt + v > 100 || beginpunt + v < -100 ) {
      nuStoppen();
    }
    if(autonr==1 )
    {
        beginpunt += v;
        testGewicht(autonr,gewicht,beginpunt);
    }
    if(autonr==2)
    {
        beginpunt += v;
        testGewicht(autonr,gewicht,beginpunt);
    }
  }
    public synchronized void testGewicht(int autonr, int gewicht, int beginpunt)
 {
    if(autonr==1)
    {
        this.auto1[0]=gewicht;
        this.auto1[1]=beginpunt;
        g.drawString(""+auto1[0]+auto2[0], -50, -100);
    }
    if(autonr==2)
    {
        this.auto2[0]=gewicht;
        this.auto2[1]=beginpunt;
        g.drawString(""+auto1[1]+auto2[1], 50, 50);
    }
 }
  public void slaap( int millisec ) {
    try { Thread.sleep( millisec ); }
    catch( InterruptedException e ) {}
  }
}

Wat doe ik fout?

[Soultaker]

Verwijderd schreef op 17 January 2003 @ 09:25:
Wat doe ik fout?

Tja, waar te beginnen?

Hoe is een Auto een specialisatie van een Thread? Waarom bevat het concept 'Auto' twee auto-attributen? Is het nu EEN auto of zijn het er TWEE? Had je bij het posten van deze code compleet zinloze methoden (in het algemeen en voor je specifieke probleem) zoals "teken" niet weg kunnen laten?

Verder is het lusje van "transleer, teken, slaap" niet ideaal. Je kunt beter ofwel tussen vaste intervallen transleren en tekenen of transleren afhankelijk van de hoeveelheid tijd die je gebruikt hebt, zodat de tekentijd niet de snelheid beinvloed. Dat is echter niet je grootste probleem.

Ga eerst eens nadenken over wat je wilt en hoe je dat gaat modelleren. Je programmeert in Java, dus die arrays heb je waarschijnlijk niet nodig. Gebruik liever de Java container types (ook al zuigen die) tot je begrijpt waar arrays geschikt voor zijn. Ik snap nog niet waarom je je auto's in een gemeenschappelijke array wilt opslaan; ze doen niets met elkaar. Hoe beinvloeden ze elkaar?

Haal al die synchronized specifiers weg en doe helemaal niets aan concurrency control of multithreading totdat je ontwerp goed in elkaar zit en je begrijpt hoe threads en het synchronized keyword werken. Overweeg ook om op objecten te synchronizen (en zo een soort mutexen te creeren) in plaats van domweg al je methoden synchronized te maken. Ik vind het sowieso niet netjes om van Thread te erven ten behoeve van de functionaliteit van die klasse, als je afgeleide klasse helemaal niet aan Thread gerelateerd is. Implementeer dan liever de Runnable interface.

Trouwens, waar zie jij twee threads? En wat heeft sleep() met je probleem te maken?

[ Voor 4% gewijzigd door Soultaker op 17-01-2003 10:58 ]