Question

我正在尝试访问和修改java中另一个线程中的线程变量，我真的不知道该怎么做。

前：

Runnable r1 = new Runnable() {
    int value = 10;
    public void run() {
        // random stuff
    }
}
Runnable r2 = new Runnable() {
   public void run() {
        // of course the bellow line will not work
        r1.value--; // I want here to be able to decrement the variable "value" of r1
    }
}
Thread t1 = new Thread(r1);
Thread t2 = new Thread(r2);
t1.start();
t2.start();

谢谢你，如果你有任何想法！

有没有办法在java中为线程创建一个getter和setter？

编辑：答案很好，但我的问题并不清楚，我会尝试提出更好的问题

Answer 1

你可以做一些工作，但我建议你使用一个在线程之间共享的AtomicInteger。

final AtomicInteger value = new AtomicInteger(10);
Runnable r1 = new Runnable() {
    public void run() {
        // random stuff using value
    }
}
Runnable r2 = new Runnable() {
   public void run() {
        value.decrementAndGet();
    }
}

您可以使用AtomicReference来引用对象。

Answer 2

创建一个runnable，并使用你在runnable中定义的setter和getter。

public class MyRunnable implements Runnable{
    private volatile String myString;
    public String setString(String value){this.myString = value;}
    public String getString(){
        return myString;
    }
    public void run(){}
}

此处使用了volatile个关键字。 volatile关键字确保此String在一个线程中发生更改，所有线程都将看到更改。相反，如果我确保对String对象的唯一访问是通过synchronized上下文，则不需要volatile关键字。

为了证明我的观点，上面的代码和下面的代码都是线程安全的，但是不同，因为在下面的示例中没有2个线程可以同时输入setString和getString。

public class MyRunnable implements Runnable{
    private String myString;
    public synchronized String setString(String value){this.myString = value;}
    public synchronized String getString(){
        return myString;
    }
    public void run(){}
}

线程实际上只是在执行runnable。您可以像这样使用它：

MyRunnable runnable = new MyRunnable();
Thread myThread = new Thread(runnable);
myThread.start();
String myString = runnable.getString();

使用原语的原子值很好，但是如果你想分享一个更复杂的对象，你必须阅读threading and synchronization.

例如：

public class Stats{
    int iterations;
    long runtime;
    public Stats(){
        iterations = 0;
        runtime=0;
    }
    public synchronized void setIterations(int value){this.iterations = value;}
    public synchronized void setRuntime(long milliseconds){
        this.runtime = milliseconds;
    }
    public synchronized int getIterations(){
         return iterations;
    }
    public synchronized long getRuntime(){return runtime;}
}

public class StatRunnable implements Runnable{
    Stats stats;
    boolean active;
    public StatRunnable(){
        this.active=true;
    }
    public Stats getStats(){
        return stats;
    }
    long calculateRuntime(){return 0L;}
    public void run(){
        while(active){
            //i'm synchronizing with stats to ensure no other thread alters values
            //simultaneously.
            synchronized(stats){
                stats.setIterations(stats.getIterations()+1);
                stats.setRuntime(calculateRuntime());
            }
        }
    }
}

此代码显示了通过synchronized关键字与非基本对象同步的示例。在方法定义中使用synchronized关键字将类本身锁定为同步对象。

最后一点，synchronized关键字不仅仅用在方法定义中。您可以使用它来同步方法中的实例，就像我在run中的StatRunnable方法中所做的那样。

从java中的另一个线程访问线程的变量

2 个答案: