Question

我有两个主题。第一个更改变量Data的值。如果值已更改，则第二个打印该值。我试图做第二个线程只是每次变量的值改变时打印，但我没有取得成功。有人可以帮帮我吗？

主题1

<WrapPanel>
    <TextBlock>Long Text 1</TextBlock>
    <TextBlock>Long Text 2</TextBlock>
</WrapPanel>

线程2

 class someservice{

     volatile int data;
     Boolean Flag = false;

     public void mymethod(){

         flag = true;

         for (Integer i = 1; i < sheet.getRows(); i++) {

             data = someMethod();  //this method when called return a new 
                                   //value  
         }

         flag = false;
         ...
     }
  }

Answer 1

既然你提到了Promises，我推断你熟悉+ C ++ 11

中的未来/承诺

在java中有一种类似的方法，将来可以调用...

public class HW5 {
    public static void main(String[] argv) throws InterruptedException, ExecutionException {
    FutureTask<Boolean> myFutureTask = new FutureTask<>(new Callable<Boolean>() {

        @Override
        public Boolean call() throws Exception {
        // implement the logic here and return true if everything was
        // ok, false otherwise.
        Thread.sleep(5000);
        System.out.println("dddd");
        return System.currentTimeMillis() % 2 == 0;
        }
    });

    ExecutorService executor = Executors.newFixedThreadPool(1);
    executor.execute(myFutureTask);
    Boolean result = myFutureTask.get();
    System.out.println("Done!");
    }
}

FutureTask在一个类中，它接受一个可以在其作业完成后返回Object的可调用...为了执行Future任务，您可以使用Executor服务，特别是调用方法execute，因为您需要等待那么你需要调用 Future.get 来完成这项工作的线程，这将基本上阻止主线程直到将来完成，验证结果，只需读取变量结果< /强> ..

Answer 2

您可以在线程中使用notify（）和notifyAll（）方法。查看此链接：https://docs.oracle.com/javase/tutorial/essential/concurrency/guardmeth.html

HOR

Answer 3

你必须查找更多关于并发编程的数据，我现在可以告诉你一些基础知识，好吧，不是那么基本，但我会尽我所能：

在这里，你有一个监视器，它是一个抽象概念，在简历中，监视器是一个所有的课程使用“同步”的方法作为修饰语，它意味着，只有一个线程可以访问方法马上，所以，在里面监视器是变量那个你想要打印，和“旗帜”，告诉你是否变量被修改了。最后，您可以看到了最重要的是，“wait（）”和“notify（）”方法，那些方法停止线程，或“播放” 他们又来了。

你问

printValue（）方法，如果您的变量被更改，如果变量没有变化，则使用wait（）方法将thead置于睡眠状态，而当另一个

时

执行方法changeValue（），修改值，调用notify（）方法，唤醒线程，这样做，你可以保证三件事：

安全：意味着线程会做你想要的没有死锁：意味着将要进入睡眠状态的线程将来会被唤醒。 Mutex：意味着只有一个线程正在执行关键代码，例如op。 “++”不是原子的，在更多的一个动作中进行细分，创建局部变量，读取var，sum和asign，因此，如果游戏中有多个线程，则值可能不是连续的，例如：

i = 0;
i ++;
output: 1;
output: 2;
output: 3;
output: 5;
output: 4;
output: 7;

这可能会发生，即使如此，这也会发生在下一个代码中，因为执行了多个线程。好吧，这是使用多个线程编程的方法，或多或少

    public class Monitor {

        private int value = 0;
        public static boolean valueHasChanged = false;

        public synchronized int changeValue(int newValue){
            this.value = newValue;
            Monitor.valueHasChanged = true;
            this.notify();
            return this.value + 1;
        }

        public synchronized void printValue(){
            while(!Monitor.valueHasChanged){
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
            System.out.println(this.value);
            Monitor.valueHasChanged = false;
        }

        public static void main(String[] args) {
            Monitor ac = new Monitor();

            BClass t1 = new BClass(ac);
            AClass t2 = new AClass(ac);

            t1.start();
            t2.start();
        }

        public int getValue() {
            return this.value;
        }
    }

现在线程：

    public class AClass extends Thread{

        private Monitor ac;

        public AClass(Monitor ac) {
            this.ac = ac;
        }

        @Override
        public void run() {
            while(true){
                this.ac.printValue();
            }
        }

    }

最后：

    public class BClass extends Thread{

        private Monitor ac;

        public BClass(Monitor ac) {
            this.ac = ac;
        }

        @Override
        public void run() {
            int v = 0;
            while(true){
                this.ac.changeValue(v);
                v++; // this sum is not secure, if you want to print an 
                     // ascending order, the code is diferent, I will show in
                     // above.
            }
        }

现在，如果你想要一个有序的印刷品：

显示器将如下所示：

    public class Monitor {

        private int value = 0;
        public boolean valueHasChanged = false;
        private boolean hasPrint = true;

        public synchronized void changeValue(int newValue) {
            this.value = newValue;
            this.valueHasChanged = true;
            this.notify();
        }

        public synchronized void changeValuePlusOne() {
            while (!hasPrint) {
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            this.value++;
            this.valueHasChanged = true;
            this.hasPrint = false;
            this.notifyAll();
        }

        public synchronized void printValue() {
            while (!this.valueHasChanged) {
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println(this.value);

            this.valueHasChanged = false;
            this.hasPrint = true;
            this.notifyAll();
        }

        public static void main(String[] args) {
            Monitor ac = new Monitor();

            BClass t1 = new BClass(ac);
            AClass t2 = new AClass(ac);

            t1.start();
            t2.start();
        }

        public int getValue() {
            return this.value;
        }

    }

线程：

    public class BClass extends Thread{

        private Monitor ac;

        public BClass(Monitor ac) {
            this.ac = ac;
        }

        @Override
        public void run() {
            while(true){
                this.ac.changeValuePlusOne();
            }
        }

        }

另一个Thread看起来等于：

public class AClass extends Thread{

    private Monitor ac;

    public AClass(Monitor ac) {
        this.ac = ac;
    }

    @Override
    public void run() {
        while(true){
            this.ac.printValue();
        }
    }

}

如何通知变量的第二个线程发生变化

3 个答案: