7

在我的 android 程序中，一个 Activity 调用一个新的表面视图类，然后它又调用一个新的线程类。我希望能够从活动的 onPause 和 onResume 方法将值传递给线程类，这样我就可以暂停和恢复线程。我知道传递这些数据的唯一方法是创建一个新实例，它只会创建一个不同的线程。我应该如何在不创建新线程实例的情况下解决这个问题？

public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(new GameSurface(this));
}

@Override
protected void onResume() {
    super.onResume();
            //Would like to pass this value
            int state = 1;
}

@Override
protected void onPause() {
    super.onPause();
            //Would like to pass this value
            int state = 2;
}
4

3 回答 3

5

关于并发的一点背景

并发传递值是容易的部分。查看AtomicInteger数据类型（此处有更多信息）。原子性也意味着All or nothing。这种数据类型不一定是在线程或处理器之间发送数据（就像你会使用的那样mpi），但它只是在其共享内存上共享数据。

但是什么是原子动作？......

原子操作是作为单个工作单元执行的操作，不会受到其他操作的干扰。

在 Java 中，语言规范保证读取或写入变量是原子的（除非变量是 long 或 double 类型）。Long 和 double 只有在声明为 volatile 时才是原子的......

学分（Java 并发/多线程 - Lars Vogel 的教程）

我强烈建议您阅读这篇文章，它涵盖了从atomicity、thread pools和.deadlocksthe "volatile" and "synchronized" keyword

Start Class 这将执行一个新线程（也可以称为我们的Main Thread）。

import java.util.concurrent.atomic.AtomicInteger;
/**
 * @author Michael Jones
 * @description Main Thread
 */
public class start {
    private AtomicInteger state;
    private Thread p;
    private Thread r;
    /**
     * constructor
     * initialize the declared threads
     */
    public start(){
        //initialize the state
        this.state = new AtomicInteger(0);
        //initialize the threads r and p
        this.r = new Thread(new action("resume", state));
        this.p = new Thread(new action("pause", state));
    } //close constructor

    /**
     * Start the threads
     * @throws InterruptedException 
     */
    public void startThreads() throws InterruptedException{
        if(!this.r.isAlive()){
            r.start(); //start r
        }
        if(!this.p.isAlive()){
            Thread.sleep(1000); //wait a little (wait for r to update)...
            p.start(); //start p
        }
    } //close startThreads

    /**
     * This method starts the main thread
     * @param args
     */
    public static void main(String[] args) {
         //call the constructor of this class
        start s = new start();
        //try the code
        try {
            s.startThreads();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } //start the threads
    } //close main

} //close class start

因为整数是原子的，所以你也可以main method在除Start Class之外的任何地方检索它System.out.println("[run start] current state is... "+state.intValue());。（如果您希望从 中检索它main method，则必须设置一个 Setter/Getter，就像我在Action Class中所做的那样）

Action Class 这是我们的线程（也可以称为 our Slave Thread）。

import java.lang.Thread.State;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author Michael Jones
 * @description Slave Thread
 */
public class action implements Runnable {

    private String event = "";
    private AtomicInteger state;

    /**
     * The constructor (this represents the current instance of a thread).
     * 
     * @param event
     * @param state
     */
    public action(String event, AtomicInteger state) {
        this.event = event; // update this instance of event
        this.state = state; // update this instance of state
    } // constructor

    /**
     * This method will be called after YourThreadName.Start();
     */
    @Override
    public void run() {
        if (this.event == "resume") {
            this.OnResume(); // call resume
        } else {
            this.OnPause(); // call pause
        }
    } // close Runnable run() method

    /**
     * The resume function Use the auto lock from synchronized
     */
    public synchronized void OnResume() {
        System.out.println("[OnResume] The state was.." + this.getAtomicState()
                + " // Thread: " + Thread.currentThread().getId());
        this.setAtomicState(2); // change the state
        System.out.println("[OnResume] The state is.." + this.getAtomicState()
                + " // Thread: " + Thread.currentThread().getId());
    } // close function

    /**
     * The pause function Use the auto lock from synchronized
     */
    public synchronized void OnPause() {
        System.out.println("[OnPause] The state was.." + this.getAtomicState()
                + " // Thread: " + Thread.currentThread().getId());
        this.setAtomicState(1); // change the state
        System.out.println("[OnPause] The state is.." + this.getAtomicState()
                + " // Thread: " + Thread.currentThread().getId());
    } // close function

    /**
     * Get the atomic integer from memory
     * 
     * @return Integer
     */
    private Integer getAtomicState() {
        return state.intValue();
    }// close function

    /**
     * Update or Create a new atomic integer
     * 
     * @param value
     */
    private void setAtomicState(Integer value) {
        if (this.state == null) {
            state = new AtomicInteger(value);
        } else
            state.set(value);
    } // close function

} // close the class

控制台输出

[OnResume] The state was..0 // Thread: 9
[OnResume] The state is..2 // Thread: 9
[OnPause] The state was..2 // Thread: 10
[OnPause] The state is..1 // Thread: 10

如您所见，AtomicInteger state我们的线程r和p.

解决方案和要寻找的东西...

做并发时唯一需要注意的是Race Conditions// Deadlocks。Livelocks有些RaceConditions发生是因为Threads是按随机顺序创建的（并且大多数程序员都认为顺序是顺序的）。

由于线程的随机顺序，我有这条线Thread.sleep(1000);，以便我Main Thread给从属线程r一点时间来更新state（在允许p运行之前）。

1）保持对线程的引用并使用方法传递值。 学分 ( SJuan76 , 2012)

在我发布的解决方案中，我将我的Main Thread（又名class start）作为我的主要沟通者，以跟踪Atomic Integer我的奴隶使用（又名class action）。我的主线程也是我updating的从属线程（内存缓冲区的更新发生在应用程序的后台并由类处理）。memory bufferAtomic IntegerAtomicInteger

于 2012-07-21T23:59:15.080 回答
4

1）保持对线程的引用并使用方法传递值。

2）在线程创建期间，传递一个与Activity共享的对象。将要传递的值放入对象中，让线程定期检查它，直到找到值。

于 2012-07-21T23:54:53.057 回答
2

我使用我命名的参考类Share Class。它具有带volatile类型的变量。

volatile用于表示一个变量的值将被不同的线程修改。

public class Share {
   public static volatile type M_shared;
}

要更改此变量，您应该锁定它并在更改值后释放锁定。您可以使用Share.M_shared.

于 2012-07-22T00:31:33.090 回答