Andorid之用ConditionVariable实现线程同步
【摘要】 一、学习ConditionVariable之前的复习
如果你不懂wait()、notify()怎么使用，最好先复习下我之前的这篇博客，怎么使用wait()、notify()实现生产者和消费者的关系
java之wait()、notify()实现非阻塞的生产者和消费者
二、看下...
一、学习ConditionVariable之前的复习
如果你不懂wait()、notify()怎么使用，最好先复习下我之前的这篇博客，怎么使用wait()、notify()实现生产者和消费者的关系
java之wait()、notify()实现非阻塞的生产者和消费者
二、看下ConditionVariable源代码实现
-
package android.os;
-
-
/**
-
* Class that implements the condition variable locking paradigm.
-
*
-
* <p>
-
* This differs from the built-in java.lang.Object wait() and notify()
-
* in that this class contains the condition to wait on itself. That means
-
* open(), close() and block() are sticky. If open() is called before block(),
-
* block() will not block, and instead return immediately.
-
*
-
* <p>
-
* This class uses itself as the object to wait on, so if you wait()
-
* or notify() on a ConditionVariable, the results are undefined.
-
*/
-
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.
-
*
-
* <p>
-
* Pass true for opened and false for closed.
-
*/
-
public ConditionVariable(boolean state)
-
{
-
mCondition = state;
-
}
-
-
/**
-
* Open the condition, and release all threads that are blocked.
-
*
-
* <p>
-
* 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.
-
*
-
* <p>
-
* 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.
-
*
-
* <p>
-
* 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.
-
*
-
* <p>
-
* If the condition is already opened, return immediately.
-
*
-
* @param timeout the maximum 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;
-
}
-
}
-
}
-
三、我们分析怎么使用
比如有多个线程需要执行同样的代码的时候，我们一般希望当一个线程执行到这里之后，后面的线程在后面排队，然后等之前的线程执行完了再让这个线程执行，我们一般用synchronized实现，但是这里我们也可以用ConditionVariable实现，从源码可以看到，我们初始化可以传递一个boolean类型的参数进去，我们可以传递true进去
-
public ConditionVariable(boolean state)
-
{
-
mCondition = state;
-
}
然后你看下ConditionVariable类里面这个方法
-
public void block()
-
{
-
synchronized (this) {
-
while (!mCondition) {
-
try {
-
this.wait();
-
}
-
catch (InterruptedException e) {
-
}
-
}
-
}
-
}
如果第一次初始化的时候mCondition是true,那么第一次调用这里就不会走到wait函数，然后我们应该需要一个开关让mCondition变成false,让第二个线程进来的时候我们应该让线程执行wait()方法，阻塞在这里，这不看下ConditionVariable类里面这个函数
-
public void close()
-
{
-
synchronized (this) {
-
mCondition = false;
-
}
-
}
这不恰好是我们需要的，我们可以马上调用这个函数close(),然后让程序执行我们想执行的代码，最后要记得调用open方法，如下
-
public void open()
-
{
-
synchronized (this) {
-
boolean old = mCondition;
-
mCondition = true;
-
if (!old) {
-
this.notifyAll();
-
}
-
}
-
}
因为这里调用了notifyAll方法，把之前需要等待的线程呼唤醒
所以我们使用可以这样使用
1、初始化
ConditionVariable mLock = new ConditionVariable(true);
2、同步的地方这样使用
-
mLock.block();
-
mLock.close();
-
/**
-
你的代码
-
**/
-
mLock.open();
四、测试代码分析
我先给出一个原始Demo
-
public class MainActivity extends ActionBarActivity {
-
-
public static final String TAG = "ConditionVariable_Test";
-
@Override
-
protected void onCreate(Bundle savedInstanceState) {
-
super.onCreate(savedInstanceState);
-
setContentView(R.layout.activity_main);
-
for (int i = 0; i < 10; i++) {
-
new Mythread("" + i).start();
-
}
-
}
-
-
public int num = 5;
-
-
class Mythread extends Thread {
-
-
String name;
-
-
public Mythread(String name) {
-
this.name = name;
-
}
-
-
@Override
-
public void run() {
-
while (true) {
-
try {
-
Thread.sleep(1);
-
} catch (InterruptedException e) {
-
e.printStackTrace();
-
}
-
num--;
-
if (num >= 0)
-
Log.i(TAG, "thread name is:" + name + " num is:" + num);
-
else
-
break;
-
}
-
}
-
}
-
}
运行的结果是这样的：
-
ConditionVariable_Test I thread name is:0 num is:4
-
I thread name is:1 num is:3
-
I thread name is:2 num is:2
-
I thread name is:3 num is:1
-
I thread name is:4 num is:0
很明显不是我们想要的结果，因为我想一个线程进来了，需要等到执行完了才让另外一个线程才能进来
我们用ConditionVariable来实现下
-
package com.example.conditionvariable;
-
-
import java.util.concurrent.locks.Lock;
-
import java.util.concurrent.locks.ReentrantLock;
-
-
import android.os.Bundle;
-
import android.os.ConditionVariable;
-
import android.support.v7.app.ActionBarActivity;
-
import android.util.Log;
-
-
public class MainActivity extends ActionBarActivity {
-
-
public static final String TAG = "ConditionVariable_Test";
-
@Override
-
protected void onCreate(Bundle savedInstanceState) {
-
super.onCreate(savedInstanceState);
-
setContentView(R.layout.activity_main);
-
mCondition = new ConditionVariable(true);
-
for (int i = 0; i < 10; i++) {
-
new Mythread("" + i).start();
-
}
-
}
-
-
public int num = 5;
-
-
class Mythread extends Thread {
-
-
String name;
-
-
public Mythread(String name) {
-
this.name = name;
-
}
-
-
@Override
-
public void run() {
-
mCondition.block();
-
mCondition.close();
-
while (true) {
-
try {
-
Thread.sleep(1);
-
} catch (InterruptedException e) {
-
e.printStackTrace();
-
}
-
num--;
-
if (num >= 0)
-
Log.i(TAG, "thread name is:" + name + " num is:" + num);
-
else
-
break;
-
}
-
mCondition.open();
-
}
-
}
-
}
运行的结果如下
-
onditionVariable_Test I thread name is:0 num is:4
-
I thread name is:0 num is:3
-
I thread name is:0 num is:2
-
I thread name is:0 num is:1
-
I thread name is:0 num is:0
很明显这是我想要的效果，还有其它办法吗？当然有
我们还可以使用ReentrantLock重入锁，代码修改如下
-
public class MainActivity extends ActionBarActivity {
-
-
public static final String TAG = "ConditionVariable_Test";
-
private Lock lock = new ReentrantLock();
-
@Override
-
protected void onCreate(Bundle savedInstanceState) {
-
super.onCreate(savedInstanceState);
-
setContentView(R.layout.activity_main);
-
for (int i = 0; i < 10; i++) {
-
new Mythread("" + i).start();
-
}
-
}
-
-
public int num = 5;
-
-
class Mythread extends Thread {
-
-
String name;
-
-
public Mythread(String name) {
-
this.name = name;
-
}
-
-
@Override
-
public void run() {
-
lock.lock();
-
while (true) {
-
try {
-
Thread.sleep(1);
-
} catch (InterruptedException e) {
-
e.printStackTrace();
-
}
-
num--;
-
if (num >= 0)
-
Log.i(TAG, "thread name is:" + name + " num is:" + num);
-
else
-
break;
-
}
-
lock.unlock();
-
}
-
}
-
}
运行的结果如下
-
onditionVariable_Test I thread name is:0 num is:4
-
I thread name is:0 num is:3
-
I thread name is:0 num is:2
-
I thread name is:0 num is:1
-
I thread name is:0 num is:0
很明显这是我想要的效果，还有其它办法吗？当然有，那就是用synchronized同步块，代码改成如下
-
package com.example.conditionvariable;
-
-
import java.util.concurrent.locks.Lock;
-
import java.util.concurrent.locks.ReentrantLock;
-
-
import android.os.Bundle;
-
import android.os.ConditionVariable;
-
import android.support.v7.app.ActionBarActivity;
-
import android.util.Log;
-
-
public class MainActivity extends ActionBarActivity {
-
-
public static final String TAG = "ConditionVariable_Test";
-
@Override
-
protected void onCreate(Bundle savedInstanceState) {
-
super.onCreate(savedInstanceState);
-
setContentView(R.layout.activity_main);
-
for (int i = 0; i < 10; i++) {
-
new Mythread("" + i).start();
-
}
-
}
-
-
public int num = 5;
-
-
class Mythread extends Thread {
-
-
String name;
-
-
public Mythread(String name) {
-
this.name = name;
-
}
-
-
@Override
-
public void run() {
-
synchronized (MainActivity.class) {
-
while (true) {
-
try {
-
Thread.sleep(1);
-
} catch (InterruptedException e) {
-
e.printStackTrace();
-
}
-
num--;
-
if (num >= 0)
-
Log.i(TAG, "thread name is:" + name + " num is:" + num);
-
else
-
break;
-
}
-
}
-
}
-
}
-
}
运行的结果如下
-
onditionVariable_Test I thread name is:0 num is:4
-
I thread name is:0 num is:3
-
I thread name is:0 num is:2
-
I thread name is:0 num is:1
-
I thread name is:0 num is:0
很明显这是我想要的效果
五、总结
在Android开发里面我们一般实现线程通过可以用ConditionVariable、ReentrantLock(重入锁)、synchronized、阻塞队列(ArrayBlockingQueue、LinkedBlockingQueue)
put(E e) : 在队尾添加一个元素，如果队列满则阻塞
size() : 返回队列中的元素个数
take() : 移除并返回队头元素，如果队列空则阻塞
文章来源: chenyu.blog.csdn.net，作者：chen.yu，版权归原作者所有，如需转载，请联系作者。
原文链接：chenyu.blog.csdn.net/article/details/80905528
【版权声明】本文为华为云社区用户转载文章，如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱：
cloudbbs@huaweicloud.com
- 点赞
- 收藏
- 关注作者
评论（0）