Memory Thread.sleep()

Status
Nicht offen für weitere Antworten.
O

Olbi

Gast
Heidiho ihrz.
Also vorweg. Ich habe die Suche benutzt und ich denke ich hab das Prinzip halbwegs verstanden wie diese Methode funktioniert. Leider sind die anderen Memory-Versionen anders als meine aufgebaut und ich bekomm es nicht hin die Werte in die Run-Methode von Thread zu übertragen.

Hier mal der Quelltext:
Die GUI
Code:
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.*;
    

public class MemoryGUI extends JFrame{
    
    private JButton[] press;
    
    private JLabel[]karten;
    private JLabel[]deckkarten;
    
    private JLabel level;
    
    private JLabel zeit;
    private JLabel timer;
    
    private JLabel smilie;
    private Label[] speicher;
    
    private JLabel auf;
    private JLabel anzKart;
    private JLabel aufNum;
    
    private JButton pause;
    
    private JLabel test;
    
    private JLabel hinter;
    
    private JButton los;
    
    private MenuBar menubar;
    private Menu Spiel;
    private MenuItem optionen;
    private MenuItem Neu;
    private MenuItem Ende;
    
    
  
    MemoryGUI()
    {
        setTitle("Memory von Christian Zörner");
        setBackground(Color.lightGray);
        setLayout (null);
        
        
       
              
        

        karten = new JLabel[18];
        press = new JButton[18];
        speicher = new Label[9];
        deckkarten = new JLabel[18];
       
        for(int i=0;i<18;++i)
        {
         karten[i]=new JLabel("0");
         press[i]=new JButton(""+i);
         deckkarten[i]=new JLabel("");
        
         ImageIcon icon = new ImageIcon("deck.jpg");
         if(i<6)
         {
            
             speicher[i]= new Label("0");
             speicher[i].setBounds(900,100+i*30,100,25);
        karten[i].setBounds(180+i*110,200,100,100);
        karten[i].setVisible(false);
        deckkarten[i].setBounds(180+i*110,200,100,100);
        deckkarten[i].setVisible(false);
         deckkarten[i].setIcon(icon);
          press[i].setBounds(180+i*110,200,100,100);
        press[i].setContentAreaFilled(false);
        
        
         add(karten[i]);
         add(speicher[i]);
         add(deckkarten[i]);
         add(press[i]);
         }
         else if (i>=6  && i<12)
         {
             if (i<8)
             { speicher[i]= new Label("0");
             speicher[i].setBounds(600,100+i*30,100,25); 
             }
             karten[i].setBounds(180+(i-6)*110,320,100,100);
             karten[i].setVisible(false);
             add(karten[i]);
              deckkarten[i].setBounds(180+(i-6)*110,320,100,100);
                deckkarten[i].setIcon(icon);
                 deckkarten[i].setVisible(false);
             add(deckkarten[i]);
              press[i].setBounds(180+(i-6)*110,320,100,100);
              press[i].setContentAreaFilled(false);
             add(press[i]);
         }
         else if (i>=12 )
         {
             karten[i].setBounds(180+(i-12)*110,440,100,100);
             karten[i].setVisible(false);
             add(karten[i]);
              deckkarten[i].setBounds(180+(i-12)*110,440,100,100);
                deckkarten[i].setIcon(icon);
                 deckkarten[i].setVisible(false);
             add(deckkarten[i]);
              press[i].setBounds(180+(i-12)*110,440,100,100);
              press[i].setContentAreaFilled(false);
             add(press[i]);
         }
        
        }
        
       auf= new JLabel("0");
       auf.setBounds(600,400,100,25);
       add(auf);
       
       aufNum= new JLabel("0");
       aufNum.setBounds (700,400,100,25);
       add(aufNum);
       
       anzKart= new JLabel("0");
       anzKart.setBounds(600,425,100,25);
       add(anzKart);
       
       test = new JLabel ("0");
       test.setBounds(400,500,300,25);
       add(test);
       
        los = new JButton ("Los");
        los.setBounds(50,500,100,25);
        add(los);
        
      
       
        
        
        level = new JLabel("Level 1");
        level.setBounds(25,0,100,25);
        add(level);
        
        pause= new JButton ("Pause");
        pause.setBounds(150,0,80,25);
        add(pause);
        
        zeit = new JLabel ("Zeit:");
        zeit.setBounds(250,0,30,25);
        add(zeit);
        
        timer= new JLabel("30");
        timer.setBounds(280,0,30,25);
        add(timer);
        
        ImageIcon smilieIcon = new ImageIcon("smilie_gut.jpg");
        smilie= new JLabel(smilieIcon);
        smilie.setBounds(600,400,200,190);
        add(smilie);
        
        menubar = new MenuBar();
        setMenuBar(menubar);
        
        Spiel = new Menu ("Spiel");
        menubar.add(Spiel);
        
        optionen = new MenuItem ("Optionen");
        Spiel.add(optionen);
        
        Neu = new MenuItem ("Neu");
        Spiel.add(Neu);
        
        Ende = new MenuItem ("Ende");
        Spiel.add(Ende);
        
         ImageIcon hint = new ImageIcon("tisch2.jpg");
       hinter= new JLabel("");
       hinter.setBounds(0,0,1000,730);
       hinter.setIcon(hint);
       add(hinter);
        
         addWindowListener (new WindowAdapter()
        {
            public void windowClosing(WindowEvent e)
            {
                dispose();
                System.exit(0);
            }
        });
        pack();
        setVisible(true);
        setSize(1000,730);
        setLocation(200,50);
        setResizable(false);
    }
  
    public void speichern(int i, int karte)
    {
        speicher[i].setText(""+karte);
    }
    
    public String holeSpeicher(int i)
    {
       return speicher[i].getText().trim();
    }
  
    public void setKarten()
{
        for (int i=0;i<4;++i)
        {
        int karte=Integer.parseInt(speicher[i].getText().trim());
        ImageIcon icon = new ImageIcon(karte+".jpg");
        int anzKart=0;
         
        while ( anzKart<2)
        {
       
        int pos=(int)(Math.random()*8);
        if (Integer.parseInt(karten[pos].getText().trim())==0)
        {
        karten[pos].setIcon(icon);
        anzKart=anzKart+1;
        karten[pos].setText(""+karte);
        deckkarten[pos].setVisible(true);
        
        }
        
        }   
           
        }
       
        
        }
    
   public void aufdecken(int i)
    {
         
         int nummer =Integer.parseInt( aufNum.getText().trim());
         
         karten[i].setVisible(true);
         deckkarten[i].setVisible(false);
       
        press[i].setVisible(false);
         
       
        if (anzKart.getText().trim().equals("0"))
        {
       
        auf.setText(karten[i].getText().trim());
        aufNum.setText(""+i);
        anzKart.setText("1");
        }
         
        else if (anzKart.getText().trim().equals("1"))
        {
            karten[i].setVisible(true);
         deckkarten[i].setVisible(false);
       
        press[i].setVisible(false);
        
        


            if (auf.getText().trim().equals(karten[i].getText().trim()))
            {
                karten[i].setVisible(false);
                press[i].setVisible(false);
                
                karten[nummer].setVisible(false);
                press[nummer].setVisible(false);
                anzKart.setText("0");
                
                
                 deckkarten[i].setVisible(false);
                deckkarten[nummer].setVisible(false);
            }
            
            else
            {
        
  warten();
  
         karten[i].setVisible(true);
         deckkarten[i].setVisible(false);
       
        press[i].setVisible(false);

        
              karten[i].setVisible(false);
                press[i].setVisible(true);
                
                karten[nummer].setVisible(false);
                press[nummer].setVisible(true);
                deckkarten[i].setVisible(true);
                deckkarten[nummer].setVisible(true);
                anzKart.setText("0");
        
                     
       
         
    }
   }
   }
               
       public void warten()
       {
           Thread warte = new Thread(new Runnable()
         {
             public void run()
             {
                 
                 try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); }
          
             }

         }); 
         warte.start();
       }
    
   
    public void nullen()
    {
        for(int i=0;i<karten.length;++i)
            karten[i].setText(""+0);
    }
      
   
   
    public void sichtbar (int i)
    {
        if (i==1)
        {
            for (int j=0;j<deckkarten.length;++j)
            {
                deckkarten[j].setVisible(true);
                karten[j].setVisible(false);
                press[j].setVisible(true);
            }
        }
    }
            
  
    
    public void anmelden(MemoryStrg strg)
    {
        for(int i=0;i<8;++i)
        {
        press[i].addActionListener(strg);
        }
        los.addActionListener(strg);
    }

}

Die Steuerung:
Code:
import java.awt.*;
import java.awt.event.*;
import java.io.*;

public class MemoryStrg implements ActionListener  {

    private MemoryGUI gui;
    
    
    
   
    
    
     public MemoryStrg(MemoryGUI gui){
        this.gui=gui;
    }
     
     public void actionPerformed (ActionEvent e)
     {
         String cmd= e.getActionCommand().trim();
         if( cmd.equals("0")||cmd.equals("1")||cmd.equals("2")||cmd.equals("3")||cmd.equals("4")||cmd.equals("5")||
                 cmd.equals("6")||cmd.equals("7"))
         {
             gui.aufdecken(Integer.parseInt(cmd));
          
             
             
             
         }
         if(cmd.equals("Los"))
         {
             erzeugen();
         }
     }
     
     public void ende()
     {
         gui.setVisible(false);
         gui.dispose();
         System.exit(0);
        
     }
     
     public void erzeugen()
     {
         gui.nullen();
         for(int i=0;i<4;++i)
         {
             int karte=(int)(Math.random()*8+1);
                  
             int j=0;
             if (i==j)
             {
                 gui.speichern(i, karte);
                    
             }
             while( j<i)
             {
                 
                                
                 int speicher =Integer.parseInt(gui.holeSpeicher(j));
                 if (speicher!=karte)
                 {
                    
                   
                    j=j+1;
                    if (j==i)
                    {
                        gui.speichern(j, karte);
                    
                 }
                 
                 }
                 else
                 {
                   karte=(int)(Math.random()*8+1);
                   j=0;
                 }
                 
             }
         
         }
         gui.setKarten();
         gui.sichtbar(1);
       
     }
     
    
}


Das Hauptproblem liegt in diesem Teil:
Code:
  public void aufdecken(int i)
    {
         
         int nummer =Integer.parseInt( aufNum.getText().trim());
         
         karten[i].setVisible(true);
         deckkarten[i].setVisible(false);
       
        press[i].setVisible(false);
         
       
        if (anzKart.getText().trim().equals("0"))
        {
       
        auf.setText(karten[i].getText().trim());
        aufNum.setText(""+i);
        anzKart.setText("1");
        }
         
        else if (anzKart.getText().trim().equals("1"))
        {
            karten[i].setVisible(true);
         deckkarten[i].setVisible(false);
       
        press[i].setVisible(false);
        
        


            if (auf.getText().trim().equals(karten[i].getText().trim()))
            {
                karten[i].setVisible(false);
                press[i].setVisible(false);
                
                karten[nummer].setVisible(false);
                press[nummer].setVisible(false);
                anzKart.setText("0");
                
                
                 deckkarten[i].setVisible(false);
                deckkarten[nummer].setVisible(false);
            }
            
            else
            {
        
  warten();
  
         karten[i].setVisible(true);
         deckkarten[i].setVisible(false);
       
        press[i].setVisible(false);

        
              karten[i].setVisible(false);
                press[i].setVisible(true);
                
                karten[nummer].setVisible(false);
                press[nummer].setVisible(true);
                deckkarten[i].setVisible(true);
                deckkarten[nummer].setVisible(true);
                anzKart.setText("0");
        
                     
       
         
    }
   }
   }
               
       public void warten()
       {
           Thread warte = new Thread(new Runnable()
         {
             public void run()
             {
                 
                 try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); }
          
             }

         }); 
         warte.start();
       }

Ich weiß, dass mein Programmiersyle etwas rustikal ist, aber daran wird noch gearbeitet. Ich hoffen jedenfalls, dass mir jemand da weiter helfen kann, wie ich es hinbekommen, dass die Karten erst nach einer Pause zugedeckt werden.
 

hdi

Top Contributor
Dein Fehler ist, dass warten() einen neuen Thread erzeugt. Dieser wartet auch schön brav.
Aber leider läuft dein Programm in einem ganz anderen Thread.

Vllt ein Wort zu Threads: Beim Programmstart hat dein Programm (den EDT ausgenommen) genau einen
Thread. Dein Programm halt.
Mehrere Threads laufen (pseudo-) parallel ab, d.h. wenn du einen neuen Thread startest, laufen 2
Programme gleichzeitig. Daher wartet ein für dich gar nicht sichtbarer Thread, während dein Programm
diesen Thread lediglich kurz gestartet hat, und dann parallel dazu weitermacht.

Lege also dein Programm schlafen, nicht einen anderen Thread.

As simple as:

Code:
// warten(); <- löschen
try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); }

sleep() ist eine statische Methode, und sie arbeitet auf dem Thread, von dem sie aufgerufen wurde.

edit: Natürlich kannst du weiterhin das ganze in die warten() Methode auslagern, aber du darfst
halt dort nicht per new einen neuen Thread starten.
 
G

Gast

Gast
Es kommt ja keine Fehlermeldung. Es tut nur nicht das, was es soll und zwar wird gewartet, aber die Karten nicht vorher aufgedeckt.
 

hdi

Top Contributor
Das liegt daran dass man Programme, die etwas mit Swing/AWT grafisch darstellen, auf den EDT legt.
Das heisst "Event Dispatch Thread", und ist speziell für grafische Dinge gedacht. Dieser Thread läuft
immer nebenher, den managed Java selber.
Dort landen dann automatisch so Dinge wie "setVisible()" usw. Aber deine Logik läuft in deinem Hauptprogramm
ab, das ist ein anderer Thread. Und der EDT mag keine anderen parallelen Threads, wie du schon gemerkt hast ;)
Der lässt sich dann gerne mal ein paar Minuten Zeit, bis er etwas neu zeichnet, oder er sagt gleich: "Das Leben ist kein Wunschkonzert-Exception :gaen:"

Lösung: Lege dein komplettes Programm auf diesen EDT, dann kriegt er sich auch nich mehr mit einem
anderen Thread in die Haare:

Code:
public void main (String[] args){
SwingUtilities.invokeLater( new Runnable(){ // Ein neuer Thread wird auf den EDT geschoben
      @Override
      public void run(){
               new MeinSpieleFenster().setVisible(true); // oder was auch immer
      }) .start(); // Thread starten
}
}

Du musst dir diesen EDT als allgegenwärtigen Arschloch-Thread vorstellen, der sofort zicken macht wenn
er arbeiten muss (d.h. es gibt Grafik in deinem Programm), und gleichzeitig ein anderer Thread die Logik
übernimmt. Also so wie bei deiner Freundin und dir.

Anm.: Die Sätze hier sind eher schwammig formuliert und sicher nicht 100% korrekt.
Aber das langt erstmal für den TO, um sein Problem zu lösen
 
Status
Nicht offen für weitere Antworten.
Ähnliche Java Themen
  Titel Forum Antworten Datum
Spencer Reid JavaFX Memory Thread.sleep Java Basics - Anfänger-Themen 1
S Java memory fehler: Exception in thread "AWT-EventQueue-0" java.lang.OutOfMemoryError: Java heap spa Java Basics - Anfänger-Themen 5
B Image Matching in Memory Minigame Java Basics - Anfänger-Themen 7
B Memory Spiel Java Basics - Anfänger-Themen 29
J Memory-Spiel Aktivierung der Methode mit Timer Java Basics - Anfänger-Themen 44
Olis Erste Schritte Simples Memory Spiel möglich? Java Basics - Anfänger-Themen 1
T Art 4 Felder Matrix Memory Java Basics - Anfänger-Themen 2
V Memory Logik Problem/Denkblockade, bitte helft Java Basics - Anfänger-Themen 1
pinar memory spiel Java Basics - Anfänger-Themen 10
P NullPointerException in Memory-Spiel Java Basics - Anfänger-Themen 5
P Layout Manager - Welches Layout für Memory? Java Basics - Anfänger-Themen 7
A Java memory leakage Java Basics - Anfänger-Themen 9
T Out of Memory (Java Heap Space) Java Basics - Anfänger-Themen 9
S Datentypen Memory Problem Java Basics - Anfänger-Themen 12
I Memory-Spiel Feld nur einmal mischen Java Basics - Anfänger-Themen 2
K Memory-Spiel stecke Fest Java Basics - Anfänger-Themen 2
K Ein Memory Spiel ! Java Basics - Anfänger-Themen 6
K Memory-Spiel alle verdeckte karten aufdecken. Java Basics - Anfänger-Themen 26
T Memory Leak und der Garbage Collector Java Basics - Anfänger-Themen 21
A Memory Probleme beim Laden von thumbnails Java Basics - Anfänger-Themen 3
S memory heap problem Java Basics - Anfänger-Themen 9
J Memory Footprint von Objekten Java Basics - Anfänger-Themen 2
I Memory-Spiel Java Basics - Anfänger-Themen 2
W Servlet - out of memory Java Basics - Anfänger-Themen 7
G Memory-Spiel Java Basics - Anfänger-Themen 8
B Memory - Zufällige Anordnung von Buchstabenpaaren Java Basics - Anfänger-Themen 8
J Memory Java Basics - Anfänger-Themen 2
G Memory Projekt, Fragen über Fragen Java Basics - Anfänger-Themen 6
B Memory in Java Java Basics - Anfänger-Themen 16
T Out of Memory Error Java Basics - Anfänger-Themen 7
E Heapspace out of Memory Java Basics - Anfänger-Themen 8
Leyla Thread isInterrupt Java Basics - Anfänger-Themen 18
P Meldung aus Java-Klasse in Thread an aufrufende Klasse Java Basics - Anfänger-Themen 1
A Thread XML-Dateien zusammenfügen Java Basics - Anfänger-Themen 11
F influxdb Upload in eigenem Thread Java Basics - Anfänger-Themen 2
frager2345 Thread - Methoden synchronized deklarieren Java Basics - Anfänger-Themen 10
berserkerdq2 Größter unterschied von extends thread und implements runnable? Java Basics - Anfänger-Themen 2
T Thread beenden aus zweiter Klasse Java Basics - Anfänger-Themen 4
A Thread - Synchronized Java Basics - Anfänger-Themen 10
A Thread Producer - Consumer Java Basics - Anfänger-Themen 1
A Thread-Semhapore Java Basics - Anfänger-Themen 0
A Thread Exchanger Java Basics - Anfänger-Themen 22
A Thread-Cyclicbarrier Java Basics - Anfänger-Themen 4
B In einem Thread Endlosschleife beenden Java Basics - Anfänger-Themen 19
A Thread-Verklemmung Java Basics - Anfänger-Themen 10
A Thread-Schreibe-Lese-Problem Java Basics - Anfänger-Themen 4
A Thread find number Java Basics - Anfänger-Themen 8
F Thread.sleep() Java Basics - Anfänger-Themen 5
F Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 11 at main.main(main.java:11) Java Basics - Anfänger-Themen 2
A Thread Java Basics - Anfänger-Themen 3
M Exception in thread "main" java.util.NoSuchElementException Java Basics - Anfänger-Themen 2
A Thread Java Basics - Anfänger-Themen 8
B Compiler-Fehler Fehlermeldung Exception in thread, falsche Eingabewert Java Basics - Anfänger-Themen 2
M Thread-Zustände Java Basics - Anfänger-Themen 6
CptK For-Schleife in Thread nach jedem Durchlauf pausieren Java Basics - Anfänger-Themen 35
S Kriege Fehler "Exception in thread" beim Benutzen von SubStrings. Java Basics - Anfänger-Themen 2
B Endlosschleife Thread sauber beenden Java Basics - Anfänger-Themen 19
D Java Thread wartet nur ein mal Java Basics - Anfänger-Themen 1
D Java Thread wartet nur ein mal Java Basics - Anfänger-Themen 0
O Exception in thread "main" java.lang.ArithmeticException: / by zero Java Basics - Anfänger-Themen 4
C Thread und TimerTask, Verstädnisproblem Java Basics - Anfänger-Themen 10
amgadalghabra Sorting Thread Launcher Java Basics - Anfänger-Themen 3
B Exception in thread "AWT-EventQueue-0" java.util.ConcurrentModificationException Java Basics - Anfänger-Themen 8
A Thread Java Basics - Anfänger-Themen 4
A Thread Java Basics - Anfänger-Themen 1
A Thread Java Basics - Anfänger-Themen 0
R Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException Java Basics - Anfänger-Themen 5
S Compiler-Fehler Exception in thread "main" java.lang.Error: Unresolved compilation problem: Java Basics - Anfänger-Themen 6
L Liste in anderem Thread laden Java Basics - Anfänger-Themen 1
B Thread / Prozess stoppen? Java Basics - Anfänger-Themen 22
I Compiler-Fehler Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5 Java Basics - Anfänger-Themen 3
B Threads Thread sleep() Method einfache Frage Java Basics - Anfänger-Themen 8
W Thread Aufgabe - Vorgehensweise Java Basics - Anfänger-Themen 8
L Liste in anderem Thread laden Java Basics - Anfänger-Themen 0
J Threads PrograssBar update während thread Java Basics - Anfänger-Themen 13
D Compiler-Fehler Wert auf Datenbank übertragen und Sleep Thread Java Basics - Anfänger-Themen 3
S Thread.sleep mit JProgressBar Java Basics - Anfänger-Themen 1
ralfb1105 Frage zu Thread Synchronisation mit wait() und notify() Java Basics - Anfänger-Themen 3
R Exception in thread "main" java.lang.NullPointerException Java Basics - Anfänger-Themen 10
J JavaFX -> SocketIO -> Thread -> Update Label Java Basics - Anfänger-Themen 13
J Thread Handling Java Basics - Anfänger-Themen 9
A Problem mit Thread.sleep Java Basics - Anfänger-Themen 4
C Thread in Methode + raus aus der Schleife Java Basics - Anfänger-Themen 10
E Threads Thread in While-Schleife nur einmal starten Java Basics - Anfänger-Themen 2
F Daten von Thread an den aufrufenden zurückgeben Java Basics - Anfänger-Themen 22
C Compiler-Fehler Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 2 Java Basics - Anfänger-Themen 3
B Thread Problem Java Basics - Anfänger-Themen 7
N KeyListener in Thread Java Basics - Anfänger-Themen 0
M Thread.sleep() Funktion Java Basics - Anfänger-Themen 1
W JLabel in Main aus Thread verändern. Java Basics - Anfänger-Themen 4
D Ausgeben welcher Thread gerade Arbeitet Java Basics - Anfänger-Themen 8
N Threads Thread-Fehler Java Basics - Anfänger-Themen 2
F Thread um Uhrzeit ausführen Java Basics - Anfänger-Themen 5
F Get/Post als eigener Thread mit Rückgabe Java Basics - Anfänger-Themen 5
J Exception in thread "main" Java Basics - Anfänger-Themen 1
F Thread der auf eine Queue wartet, sicher beenden Java Basics - Anfänger-Themen 4
B Animation mit Thread(s) Java Basics - Anfänger-Themen 23
I Thread.sleep (1000); Java Basics - Anfänger-Themen 1
M Threads Jede Klasse einem Thread zuweisen Java Basics - Anfänger-Themen 7
J Java Thread cancel() und wiederbeleben Java Basics - Anfänger-Themen 4

Ähnliche Java Themen

Neue Themen


Oben