Und Threads public void run()

1). Sie wollen Ihren code kompilieren.

Ihrer Zusammenstellung Probleme sind, weil Sie zu erklären, Ihre run-Methoden in der main-Methode. Trennen Sie Methodendeklarationen und dann nur mit main-erstellen & führen Sie Ihre threads.

2). Sie möchten zwei threads Betrieb gleichzeitig.

Das heißt, wir müssen entweder zwei unterschiedliche thread-Klassen oder ein einzelner thread mit Logik zu behandeln, sowohl Inkrementieren und Dekrementieren. Andrew Mao ' s Antwort gibt Ihnen einen Anfang, wie Sie definieren können zwei separate threads. Mein code oben verwendet, eine einheitliche definition für eine run-Methode, die einen parameter verwendet, um Arbeit aus dem Weg zu gehen.

3). Sie möchten zwei threads Betriebssysteme, die gleichzeitig auf die gleichen Daten, weil, während Sie das Inkrementieren/Dekrementieren getrennt, die Sie benötigen, zu prüfen, Kollisionen.

Einen einfachen Weg, dies zu tun ist erstellen Sie die Objekte, die Sie Bearbeiten möchten (num1 und num2) in deiner main-Methode, und dann geben Sie nur Verweise auf diese Objekte, um deine threads. Beispiel in meinem code oben.

4). Sie wollen, Dinge zu testen

Alle von java.lang.* ist irgendwie davon ausgegangen werden automatisch importiert. Kein Schaden, indem es für Klarheit, aber auto-Importeur-Befehle auf der dev das Werkzeug der Wahl wird wahrscheinlich entfernen Sie es so überflüssig.

public class ThreadExperiment implements Runnable {
    /* these fields are unique to each instance of ThreadExperiment */
    private int increment = 0;

    /* these are used to point to the original num1 and num2 instances created in your main method */ 
    private Integer myNumber;
    private Integer theOtherNumber;


/** 
 * Constructor.   
 */
public ThreadExperiment(int increment, Integer num1Ref, Integer num2Ref) {
    this.increment = increment;
    this.myNumber = num1Ref;
    this.theOtherNumber = num2Ref;
}


@Override
public void run() {
    do {
        myNumber += increment;
        try {
            Thread.sleep(400);
        } catch (InterruptedException e) {
        }
        System.out.println(Thread.currentThread().getName() + " -- " + myNumber);
    } while (!myNumber.equals(theOtherNumber));
}


/** 
 * Your static main method used to instantiate & start threads 
 */
public static void main(String[] args) {
    Integer num1 = 0;
    Integer num2 = 10;

    Thread t = new Thread(new ThreadExperiment(1, num1, num2), "Thread 1");
    Thread t2 = new Thread(new ThreadExperiment(-1, num2, num1), "Thread 2");
    t.start();
    t2.start();
}

}

Den run Methode wird implementiert, indem ein thread muss in einer separaten Klasse. Sie können sicherlich setzen Sie in Ihrem ThreadExperiment Klasse, aber es kann nicht beides sein. In diesem Fall, Sie können trennen die beiden threads in innere Klassen:

class ThreadExperiment {

  static int num = 1;
  static int num2 = 10;

  class Thread1 implements Runnable {
    @Override
    public void run(){      
        do {
            num++;
            try {
                Thread.sleep(400);
            } catch (InterruptedException e){
            }
        } while (num >= 0);
    }
  }

  class Thread2 implements Runnable {
    @Override
    public void run() {
        do {
            num2--;
            try {
                Thread.sleep(400);
            } catch (InterruptedException e){
            }
        } while (num >= 1);
    }
  }

  public static void main(String[] args) {

    Thread t = new Thread(new Thread1());    
    Thread t2 = new Thread(new Thread2());    

    t.start();
    t2.start();

    if (num == num2) {
        t.interrupt();
        t2.interrupt();
    }
  }
}

Nun, wir sind immer irgendwo, aber Sie noch brauchen, um zu beheben einige Probleme mit der Logik:

• Mit der ints als statische ist nicht gute Praxis. (Aber es ist okay für dieses Test-Szenario.)
• Ihre num == num2 Prüfung wird nur einmal und es gibt keine Garantien, was die Werte da sein, wenn das passiert. Es ist sehr unwahrscheinlich, dass die threads unterbrochen werden.
• Sie brauchen, um zu erklären, die ints volatile da Sie werden Lesen von verschiedenen threads.
• Die while Zustand, in Thread1 führt in eine Endlosschleife.