Question

本周我开始使用Java线程并同意;我需要帮助我使用Thread而不是Runnable实现的下一个代码：

类

package hilos;

public class Hilo extends Thread {

//Atributos

public static int concurso = 0;
private int veces;
private boolean incrementoDecremento;

//Método constructor

public Hilo(boolean inc, int numeroVeces){

    this.incrementoDecremento = inc;
    this.veces = numeroVeces;
}

//Método run

@Override

public void run(){

    for(int i = 0; i < this.veces; i++){    

        if(this.incrementoDecremento == true){

            concurso++;
            System.out.println("La variable introducida es: " + concurso);

        }else{

            concurso--;
            System.out.println("La variable introducida es: " + concurso);
        }
    }
}
}

主要

package hilos;

public class Usa_Hilos {

public static void main(String[] args) {

    int prueba = 5;
    Hilo positivo = new Hilo(true, prueba);
    Hilo negativo = new Hilo(false, prueba);


    positivo.start();
    negativo.start();

    try{

        positivo.join();
        negativo.join();
    }catch(InterruptedException ex){

        System.out.println("Se ha producido un error.");
    }
}

}

我的目标是，如果我有两个任务使用相同的值，它们都会随机开始递增和递减，所以基本上它会产生一个由变量prueba确定的随机值，该变量位于{{ 1}} class。

问题在于，出于某种原因，我一次又一次地进行测试，我的最终结果总是为零。使用Main语句和synchronized执行此操作时没有问题，但我无法使用Runnable。

Answer 1

尝试大于5的数字。您的线程可能运行得如此之快，以至于第一个线程在第二次启动之前完成。

10000证明了这个问题很好：

public class BadThreads {
    public static void main(String[] args) {
        MyThread t1 = new MyThread( 10000);
        MyThread t2 = new MyThread(-10000);
        t1.start();
        t2.start();
        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            System.out.println("interrupted");
        }
        System.out.println(MyThread.shared);
    }

    private static class MyThread extends Thread {
        public static int shared;
        private int change;

        public MyThread(int change) {
            this.change = change;
        }

        public void run() {
            while (change < 0) {
                change++;
                shared--;
            }
            while (change > 0) {
                change--;
                shared++;
            }
        }
    }
}

结果：

tmp$ javac BadThreads.java && java BadThreads
-8680

...所以我们成功地证明了并发问题。只有5个人的运行只是“幸运” - 或者在你的情况下不幸，因为你试图证明这个问题。：）

Answer 2

不要使用静态int。使用AtomicInteger。它专为这种情况而设计。

如果您不想使用它，请concurso volatile。你看到了缓存的值。

不成功演示并发增量/减量

2 个答案: