ConditionVariable在Android应用开发中的用法

首先来看下ConditionVariable类的定义：

C:\Program Files\Android\android-sdk\platforms\android-21\android.jar

package android.os;

public class ConditionVariable

{

    private volatile boolean mCondition;

    /**

     * Create the ConditionVariable in the default closed state.

     */

    public ConditionVariable()

    {

        mCondition = false;

    }

    /**

     * Create the ConditionVariable with the given state.

     * Pass true for opened and false for closed.

     */

    public ConditionVariable(boolean state)

    {

        mCondition = state;

    }

    /**

     * Open the condition, and release all threads that are blocked.

     * Any threads that later approach block() will not block unless close()

     * is called.

     */

    public void open()

    {

        synchronized (this) {

            boolean old = mCondition;

            mCondition = true;

            if (!old) {

                this.notifyAll();

            }

        }

    }

    /**

     * Reset the condition to the closed state.

     * Any threads that call block() will block until someone calls open.

     */

    public void close()

    {

        synchronized (this) {

            mCondition = false;

        }

    }

    /**

     * Block the current thread until the condition is opened.

     * If the condition is already opened, return immediately.

     */

    public void block()

    {

        synchronized (this) {

            while (!mCondition) {

                try {

                    this.wait();

                }

                catch (InterruptedException e) {

                }

            }

        }

    }

    /**

     * Block the current thread until the condition is opened or until

     * timeout milliseconds have passed.

     * @param timeout the minimum time to wait in milliseconds.

     *

     * @return true if the condition was opened, false if the call returns

     * because of the timeout.

     */

    public boolean block(long timeout)

    {

        // Object.wait(0) means wait forever, to mimic this, we just

        // call the other block() method in that case.  It simplifies

        // this code for the common case.

        if (timeout != 0) {

            synchronized (this) {

                long now = System.currentTimeMillis();

                long end = now + timeout;

                while (!mCondition && now < end) {

                    try {

                        this.wait(end-now);

                    }

                    catch (InterruptedException e) {

                    }

                    now = System.currentTimeMillis();

                }

                return mCondition;

            }

        } else {

            this.block();

            return true;

        }

    }

}

这里详述了ConditionVariable类的实现过程及其内部函数。该类内部定义了一个volatile 类型的 mCondition 变量，通过控制这个变量的值，来实现对wait()函数的调用，达到控制线程是否阻塞的目的。

这里写了一个简单的实例来模拟整个控制过程

public class MainActivity extends Activity implements OnClickListener {

    private Button btn_output;

    private TextView textView;

    private MyHandler mHandler;

    private boolean isStart;

    private String str = "";

    private ConditionVariable mConditionVariable;

    private final int REFRESHTEXT = 1;

    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);

        btn_output = (Button) findViewById(R.id.btn);

        btn_output.setOnClickListener(this);

        textView = (TextView) findViewById(R.id.txt);

        mHandler = new MyHandler();

        mConditionVariable = new ConditionVariable();

        isStart = true;

        new Thread(new Runnable() {

            @Override

            public void run() {

                // TODO Auto-generated method stub

                while(isStart) {

                    //延时等待3秒

                    mConditionVariable.block(3000);

                    //如果是点击了按钮，则先将条件重置，否则block会失效

                    mConditionVariable.close();

                    //线程唤醒后通知主线程更新TextView的文本

                    mHandler.sendEmptyMessage(REFRESHTEXT);

                }

            }

        }).start();

    }

   

    private class MyHandler extends Handler {

        @Override
public void handleMessage(Message msg) {

            switch(msg.what) {

            case REFRESHTEXT:

textView.setTextSize(20.0f);

                textView.setText(str += 's');

                break;

            }

        }

    }

       

    @Override

    public void onClick(View v) {

        // TODO Auto-generated method stub

        mConditionVariable.open();

    }

   

    @Override

    protected void onDestroy() {

        // TODO Auto-generated method stub

        super.onDestroy();

        isStart = false;

    }

}

运行该实例，你会发现按钮旁边的字符串会由hello world变为S，并且S会一直增加，每隔3秒增加一个S；

如果你有手动点击按钮的话，就会直接增加一个S，而不用等待3秒；

这个案例是从别处借鉴过来的，思路不错，就实验了一把，并且效果也不错。

但这个代码有一处不严谨的地方就是在退出该Activity时，并未将mConditionVariable对象重置，建议在onDestroy()函数中增加mConditionVariable.close()调用会显得更为严谨。