AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Andorid之用ConditionVariable实现线程同步

2021-12-16 151
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Andorid之用ConditionVariable实现线程同步

一、学习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() : 移除并返回队头元素，如果队列空则阻塞



文章标签：
Java
Android开发
关键词：
conditionvariable线程
码莎拉蒂
目录
相关文章
龙大吉
|
8月前
|
Python
如何在Python中使用ConditionVariable来实现线程同步？
如何在Python中使用ConditionVariable来实现线程同步？
龙大吉
42 10
栈江湖
|
15天前
|
NoSQL Redis
单线程传奇Redis，为何引入多线程？
Redis 4.0 引入多线程支持，主要用于后台对象删除、处理阻塞命令和网络 I/O 等操作，以提高并发性和性能。尽管如此，Redis 仍保留单线程执行模型处理客户端请求，确保高效性和简单性。多线程仅用于优化后台任务，如异步删除过期对象和分担读写操作，从而提升整体性能。
栈江湖
42 1
石小浪♪
|
3月前
|
存储 消息中间件 资源调度
C++ 多线程之初识多线程
这篇文章介绍了C++多线程的基本概念，包括进程和线程的定义、并发的实现方式，以及如何在C++中创建和管理线程，包括使用`std::thread`库、线程的join和detach方法，并通过示例代码展示了如何创建和使用多线程。
石小浪♪
65 1
龙大吉
|
3月前
|
Java 开发者
在Java多线程编程中，创建线程的方法有两种：继承Thread类和实现Runnable接口
【10月更文挑战第20天】在Java多线程编程中，创建线程的方法有两种：继承Thread类和实现Runnable接口。本文揭示了这两种方式的微妙差异和潜在陷阱，帮助你更好地理解和选择适合项目需求的线程创建方式。
龙大吉
43 3
东方睿赢
|
3月前
|
Java 开发者
在Java多线程编程中，选择合适的线程创建方法至关重要
【10月更文挑战第20天】在Java多线程编程中，选择合适的线程创建方法至关重要。本文通过案例分析，探讨了继承Thread类和实现Runnable接口两种方法的优缺点及适用场景，帮助开发者做出明智的选择。
东方睿赢
28 2
东方睿赢
|
3月前
|
Java
Java中多线程编程的基本概念和创建线程的两种主要方式：继承Thread类和实现Runnable接口
【10月更文挑战第20天】《JAVA多线程深度解析：线程的创建之路》介绍了Java中多线程编程的基本概念和创建线程的两种主要方式：继承Thread类和实现Runnable接口。文章详细讲解了每种方式的实现方法、优缺点及适用场景，帮助读者更好地理解和掌握多线程编程技术，为复杂任务的高效处理奠定基础。
东方睿赢
45 2
龙大吉
|
3月前
|
Java 开发者
Java多线程初学者指南：介绍通过继承Thread类与实现Runnable接口两种方式创建线程的方法及其优缺点
【10月更文挑战第20天】Java多线程初学者指南：介绍通过继承Thread类与实现Runnable接口两种方式创建线程的方法及其优缺点，重点解析为何实现Runnable接口更具灵活性、资源共享及易于管理的优势。
龙大吉
53 1
众所周知
|
3月前
|
安全 Java 开发者
Java多线程中的`wait()`、`notify()`和`notifyAll()`方法，探讨了它们在实现线程间通信和同步中的关键作用
本文深入解析了Java多线程中的`wait()`、`notify()`和`notifyAll()`方法，探讨了它们在实现线程间通信和同步中的关键作用。通过示例代码展示了如何正确使用这些方法，并分享了最佳实践，帮助开发者避免常见陷阱，提高多线程程序的稳定性和效率。
众所周知
60 1
众所周知
|
3月前
|
Java
在Java多线程编程中，`wait()` 和 `notify()/notifyAll()` 方法是线程间通信的核心机制。
在Java多线程编程中，`wait()` 和 `notify()/notifyAll()` 方法是线程间通信的核心机制。它们通过基于锁的方式，使线程在条件不满足时进入休眠状态，并在条件成立时被唤醒，从而有效解决数据一致性和同步问题。本文通过对比其他通信机制，展示了 `wait()` 和 `notify()` 的优势，并通过生产者-消费者模型的示例代码，详细说明了其使用方法和重要性。
众所周知
51 1
XIAZHI
|
2月前
|
数据采集 Java Python
爬取小说资源的Python实践：从单线程到多线程的效率飞跃
本文介绍了一种使用Python从笔趣阁网站爬取小说内容的方法，并通过引入多线程技术大幅提高了下载效率。文章首先概述了环境准备，包括所需安装的库，然后详细描述了爬虫程序的设计与实现过程，包括发送HTTP请求、解析HTML文档、提取章节链接及多线程下载等步骤。最后，强调了性能优化的重要性，并提醒读者遵守相关法律法规。
XIAZHI
71 0