我有两个主题。第一个更改变量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;
...
}
}
答案 0 :(得分：0)
既然你提到了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 来完成这项工作的线程，这将基本上阻止主线程直到将来完成，验证结果，只需读取变量结果< /强> ..
答案 1 :(得分：0)
您可以在线程中使用notify（）和notifyAll（）方法。查看此链接：https://docs.oracle.com/javase/tutorial/essential/concurrency/guardmeth.html
HOR答案 2 :(得分：0)
你必须查找更多关于并发编程的数据，我现在可以告诉你一些基础知识，好吧，不是那么基本，但我会尽我所能：
在这里，你有一个监视器，它是一个抽象概念，在简历中，监视器是一个 所有的课程 使用“同步”的方法 作为修饰语，它意味着， 只有 一个线程 可以访问 方法 马上，所以， 在里面 监视器是 变量 那个你 想要打印， 和“旗帜”， 告诉你是否 变量 被修改了。最后， 您可以 看到了 最重要的是，“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();
}
}
}