✔ Thread

[Bobiq]

Hallo,
es geht hier allgemein um Threads.

Die Class Basic hat Atribute zb. Metal ,Papier ,Holz und Plastik.Alle diese werden in kg gemessen und sind verfuegbar in begrenzten Mengen.

Zb metal 10 (verfuegbar 10kg)

Metal soll ein fester Wert sein der int Wert (10) soll sich aendern koennen.

Eine Class Lager ist ein Thread und soll diese Atribute fuellen mit werten(int) wenn sie lehr sind.Am besten noch mit einer random Methode.

Die klasse Roboter ist ein Thread die noch 2 Threads besizt Roboter 1 und Roboter 2 die diese Mengen verbrauchen und in einem konkurenz kampf sind.


Ih bin jezt dran und versuche die Class Basic zu schreiben,bin mir nur nicht sicher
wie ich die 2 Werte String und Integer schpeichern soll.

Hier mal ein Grundgedanke vom mir

      import java.util.*;

      public class Basic

      {

          public static void main (String[] args)
          {

      ArrayList <String> a1 = new ArrayList<String>(); // adding ArrayList fuer String
      ArrayList <Integer> a2 = new ArrayList<Integer>(); // adding ArrayList fuer Integer

      a1.add("Metal :"); // adding String into ArrayList
      a1.add("Papier :");
      a1.add("Holz :");
      a1.add("Stifte :");

      a2.add(50); // adding Integer into ArrayList (startwert)
      a2.add(30);
      a2.add(20);
      a2.add(20);

      System.out.print(a1);// print arraylists
      System.out.print(a2);

      }

      }

Die will ich dan zuerst mal mit dem thread immer per random fuellen und testen.

Ausgabe soll dann so aussehen : Metal: 20, Papier: 50

Ich bin fuer jede Idee dankbar

 

[Core-Dump]

Um die Werte zu speichern wär eine HashMap<Typ, Integer> ganz gut.
So kannst du einfach den wert zu einem Typ Material auslesen.

Hab grad ein kleines Beispiel geamcht

package roboter;

import roboter.Material.MaterialTyp;

public class Main {
    public static void main(String[] args) {
        // Das Lager mit Material Vorrat
        Material material = new Material();
        // Die Verbraucher
        Roboter robi1 = new Roboter("robi1", material, MaterialTyp.METAL);
        robi1.start();
        Roboter robi2 = new Roboter("robi2", material, MaterialTyp.STIFTE);
        robi2.start();
        Roboter robi3 = new Roboter("robi3", material, MaterialTyp.HOLZ);
        robi3.start();
    }
}

package roboter;

import java.util.HashMap;

/**
 * Das Materiallager.
 * Hier ist der Bestand pro Material gespeichert.
 * Mit der verbrauche() Methode, wird der Bestand um eins verringert.
 */
public class Material {
    public enum MaterialTyp {
        HOLZ,
        METAL,
        PAPIER,
        STIFTE,
    }
    private HashMap<MaterialTyp, Integer> lagerbestand;
    
    public Material() {
        lagerbestand = new HashMap<MaterialTyp, Integer>();
        lagerbestand.put(MaterialTyp.HOLZ, 50);
        lagerbestand.put(MaterialTyp.METAL, 50);
        lagerbestand.put(MaterialTyp.STIFTE, 50);
        lagerbestand.put(MaterialTyp.PAPIER, 50);
    }
    
    public int getBestand(MaterialTyp typ) {
        return lagerbestand.get(typ);
    }
    
    public void printBestand() {
        for (Material.MaterialTyp typ : Material.MaterialTyp.values()) {
            System.out.print(typ +":" +getBestand(typ) +" ");
        }
        System.out.println();
    }
    synchronized void verbrauche(MaterialTyp typ) {
        Integer bestand = lagerbestand.get(typ);
        bestand --;
        lagerbestand.put(typ, bestand);
        printBestand();
    }
}

package roboter;

import roboter.Material.MaterialTyp;

/**
 * Ein roboter hat ein name, und verbraucht ein bestemmtes Material.
 * Ausserdem weiss er wo es das Material zu holen gibt.
 */
public class Roboter extends Thread {
    Material material;
    MaterialTyp typ;
    String name;
    
    public Roboter(String name, Material material, MaterialTyp typ) {
        this.material = material;
        this.typ = typ;
        this.name = name;
    }
    
    /**
     * Es wird so lange Material verbraucht, bis nix mehr da ist.
     */
    @Override
    public void run() {
        super.run();
        
        // so lange material vorhanden ist
        while (material.getBestand(typ) > 0) {
            // ein stück verbrauchen
            material.verbrauche(typ);
            try {
                // etwas warten
                sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(name +" verbraucht " +typ);
        }
        // nix mehr da
        System.out.println(name +" ist verhnngert!");
    }
}

 

[Bobiq]

Hallo Core-Dump,
danke fuer deine schnelle Antwort und Hilfe.Ich werde mal komplett drueber gehen.
Auch mit den Threads Super