android 多线程实现方式、并发与同步学习总结

最新推荐文章于 2024-09-26 22:33:16 发布
最新推荐文章于 2024-09-26 22:33:16 发布
阅读量4k 收藏 13
点赞数 2
分类专栏： android 文章标签： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mingtiannihao623/article/details/78017786
版权

参考地址：http://blog.csdn.net/qq_30379689/article/details/72550701#面向对象和面向过程的区别
http://blog.csdn.net/csdn_aiyang/article/details/65442540
http://blog.csdn.net/lmj623565791/article/details/47079737/

一、多线程的三种实现方式

  1. 继承Thread类，重写run函数方法
  2. 实现Runnable接口，重写run函数方法
  3. 实现Callable接口，重写call函数方法,ExecutorService、Callable、Future实现有返回结果的多线程

  4. Callable和Runnable的不同之处:

        ①Callable规定的方法是call()，而Runnable规定的方法是run().
    ②Callable的任务执行后可返回值，而Runnable的任务是不能返回值的
    ③call()方法可抛出异常，而run()方法是不能抛出异常的。
    ④运行Callable任务可拿到一个Future对象，Future表示异步计算的结果。通过Future对象可了解任务执行情况,可取消任务的执行。

二、如何停止一个线程

  1. 创建一个标识（flag），当线程完成你所需要的工作后，可以将标识设置为退出标识
  2. 使用Thread的interrupt()方法和nterrupted()方法，两者配合break退出循环，或者return来停止线程，有点类似标识（flag）
  3. 可以使用try-catch语句，在try-catch语句中抛出异常，强行停止线程进入catch语句，这种方法可以将错误向上抛，使线程停止事件得以传播

三、Thread 线程状态和相关方法

这里写图片描述
此图来自http://blog.csdn.net/qq_30379689/article/details/72550701#面向对象和面向过程的区别，如果不能用请告知，我这里主要以做笔记为主，此图直观的反映线程的变化状态

  1. 可运行(runnable)：线程对象创建后，线程调用start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu的使用权
  2. 运行(running)：可运行状态(runnable)的线程获得了cpu使用权，执行程序代码

  3. 阻塞(block)：线程因为某种原因放弃了cpu使用权，即让出了cpu使用权，暂时停止运行，直到线程进入可运行(runnable)状态，才有机会再次获得cpu使用权转到运行(running)状态。阻塞的情况分三种：

    • 等待阻塞：运行(running)的线程执行o.wait()方法，JVM会把该线程放入等待队列(waitting queue)中
    • 同步阻塞：运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池(lock pool)中
    • 其他阻塞：运行(running)的线程执行Thread.sleep(long ms)或t.join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入可运行(runnable)状态
  4. 死亡(dead)：线程run()、main() 方法执行结束，或者因异常退出了run()方法，则该线程结束生命周期，且死亡的线程不可再次复生

sleep和wait的区别

  • sleep()是Thread类的方法,wait()是Object类中的方法;
  • 调用sleep()，在指定的时间里，暂停程序的执行，让出CPU给其他线程，当超过时间的限制后，又重新恢复到运行状态，在这个过程中，线程不会释放对象锁;调用wait()时，线程会释放对象锁，进入此对象的等待锁池中，只有此对象调用notify()时，线程进入运行状态

什么叫守护线程，用什么方法实现守护线程

守护线程：指为其他线程的运行提供服务的线程，可通过setDaemon(boolean on)方法设置线程的Daemon模式，true为守护模式，false为用户模式

方法介绍

  1. wait() :使一个线程处于等待状态，并且释放所有持有对象的lock锁，直到notify()/notifyAll()被唤醒后放到锁定池(lock blocked pool )，释放同步锁使线 程回到可运行状态（Runnable）。
  2. sleep():使一个线程处于睡眠状态，是一个静态方法，调用此方法要捕捉Interrupted异常，醒来后进入runnable状态，等待JVM调度。
  3. notify():使一个等待状态的线程唤醒，注意并不能确切唤醒等待状态线程，是由JVM决定且不按优先级。
  4. notifyAll():使所有等待状态的线程唤醒，注意并不是给所有线程上锁，而是让它们竞争。
  5. join()：使一个线程中断，IO完成会回到Runnable状态，等待JVM的调度。
  6. Synchronized():使Running状态的线程加同步锁使其进入(lock blocked pool ),同步锁被释放进入可运行状态(Runnable)。

五、如何实现线程的同步

1. Synchronized方法

当用此关键字修饰方法时， 内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。注： synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类。

  • 同步方法:给一个方法增加synchronized修饰符之后就可以使它成为同步方法，这个方法可以是静态方法和非静态方法，但是不能是抽象类的抽象方法，也不能是接口中的接口方法。当任意一个线程进入到一个对象的任意一个同步方法时，这个对象的所有同步方法都被锁定了，在此期间，其他任何线程都不能访问这个对象的任意一个同步方法，直到这个线程执行完它所调用的同步方法并从中退出，从而导致它释放了该对象的同步锁之后。在一个对象被某个线程锁定之后，其他线程是可以访问这个对象的所有非同步方法的。
  • 同步块：同步块是通过锁定一个指定的对象，来对同步块中包含的代码进行同步；而同步方法是对这个方法块里的代码进行同步，而这种情况下锁定的对象就是同步方法所属的主体对象自身。如果这个方法是静态同步方法呢？那么线程锁定的就不是这个类的对象了，也不是这个类自身，而是这个类对应的java.lang.Class类型的对象。同步方法和同步块之间的相互制约只限于同一个对象之间，所以静态同步方法只受它所属类的其它静态同步方法的制约，而跟这个类的实例（对象）没有关系。
    如果一个对象既有同步方法，又有同步块，那么当其中任意一个同步方法或者同步块被某个线程执行时，这个对象就被锁定了，其他线程无法在此时访问这个对象的同步方法，也不能执行同步块。synchronized 关键字用于保护共享数据。

2. 使用特殊域变量(volatile)实现线程同步

volatile关键字为域变量的访问提供了一种免锁机制，相当于告诉虚拟机该域可能会被其他线程更新，因此每次使用该域就要重新计算，而不是使用寄存器中的值，不能用来修饰final类型的变量

3. 使用重入锁ReentrantLock类实现线程同步

ReentrantLock类是可重入、互斥、实现了Lock接口的锁，方法：
ReentrantLock() : 创建一个ReentrantLock实例
lock() : 获得锁
unlock() : 释放锁，通常在finally代码释放锁

private Lock lock = new ReentrantLock();
public void save(int money) {
                lock.lock();
                try{
                    account += money;
                }finally{
                    lock.unlock();
                }

            }

4. 使用ThreadLocal局部变量实现线程同步

如果使用ThreadLocal管理变量，则每一个使用该变量的线程都获得该变量的副本，副本之间相互独立，这样每一个线程都可以随意修改自己的变量副本，而不会对其他线程产生影响。

 private static ThreadLocal<Integer> account = new ThreadLocal<Integer>(){
                @Override
                protected Integer initialValue(){
                    return 100;
                }
            };

ThreadLocal与同步机制都是为了解决多线程中相同变量的访问冲突问题，前者采用以”空间换时间”的方法，后者采用以”时间换空间”的方式

5. 使用阻塞队列LinkedBlockingQueue实现线程同步

LinkedBlockingQueue是一个基于已连接节点的，范围任意的blocking queue。 队列是先进先出的顺序（FIFO
LinkedBlockingQueue 类常用方法：
LinkedBlockingQueue() : 创建一个容量为Integer.MAX_VALUE 的 LinkedBlockingQueue
put(E e) : 在队尾添加一个元素，如果队列满则阻塞
size() : 返回队列中的元素个数
take() : 移除并返回队头元素，如果队列空则阻塞
代码实例： 实现商家生产商品和买卖商品的同步
当队列满时：
　　add()方法会抛出异常
　　offer()方法返回false
　　put()方法会阻塞

6. 使用原子变量AtomicXxx实现线程同步

Xxx 可以是 String ,Integer等
原子操作就是指将读取变量值、修改变量值、保存变量值看成一个整体来操作即-这几种行为要么同时完成，要么都不完成。
AtomicInteger类常用方法：
AtomicInteger(int initialValue) : 创建具有给定初始值的新的AtomicInteger
addAddGet(int dalta) : 以原子方式将给定值与当前值相加
get() : 获取当前值
原子操作主要有：
对于引用变量和大多数原始变量(long和double除外)的读写操作；　　
对于所有使用volatile修饰的变量(包括long和double)的读写操作。

7. 使用线程池进行管理及优化

1. Android HandlerThread
public class HandlerThreadActivity extends AppCompatActivity{

private HandlerThread mCheckMsgThread;
    private Handler mCheckMsgHandler;
    //与UI线程管理的handler
    private Handler mHandler = new Handler();

    @Override
    protected void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_thread_handler);

        //创建后台线程
        initBackThread();

    }

    private void initBackThread()
    {
        mCheckMsgThread = new HandlerThread("check-message-coming");
        mCheckMsgThread.start();
        mCheckMsgHandler = new Handler(mCheckMsgThread.getLooper())
        {
            @Override
            public void handleMessage(Message msg)
            {
                checkForUpdate();
                if (isUpdateInfo)
                {
                    mCheckMsgHandler.sendEmptyMessageDelayed(MSG_UPDATE_INFO, 1000);
                }
            }
        };
    }

    /**
     * 模拟从服务器解析数据
     */
    private void checkForUpdate()
    {
        try
        {
            //模拟耗时
            Thread.sleep(1000);
            mHandler.post(new Runnable()
            {
                @Override
                public void run()
                {
                    String result = "实时更新中，当前大盘指数：<font color='red'>%d</font>";
                    result = String.format(result, (int) (Math.random() * 3000 + 1000));
                    mTvServiceInfo.setText(Html.fromHtml(result));
                }
            });

        } catch (InterruptedException e)
        {
            e.printStackTrace();
        }

    }

    @Override
    protected void onDestroy()
    {
        super.onDestroy();
        //释放资源
        mCheckMsgThread.quit();
    }
}

HandlerThread 的源码

public class HandlerThread extends Thread {
    int mPriority;
    int mTid = -1;
    Looper mLooper;

    public HandlerThread(String name) {
        super(name);
        mPriority = Process.THREAD_PRIORITY_DEFAULT;
    }

    protected void onLooperPrepared() {
    }

    @Override
    public void run() {
        mTid = Process.myTid();
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
            notifyAll();
        }
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        Looper.loop();
        mTid = -1;
    }

Looper.loop()的核心代码：

while (true) {  
    Message msg = queue.next(); // might block  
    if (msg != null) {  
        if (msg.target == null) {  
            // No target is a magic identifier for the quit message.  
            return;  
        }  

        long wallStart = 0;  
        long threadStart = 0;  

        // This must be in a local variable, in case a UI event sets the logger  
        Printer logging = me.mLogging;  
        if (logging != null) {  
            logging.println(">>>>> Dispatching to " + msg.target + " " +  
                    msg.callback + ": " + msg.what);  
            wallStart = SystemClock.currentTimeMicro();  
            threadStart = SystemClock.currentThreadTimeMicro();  
        }  

        msg.target.dispatchMessage(msg); 


public void quit() {  
    Message msg = Message.obtain();  
    // NOTE: By enqueueing directly into the message queue, the  
    // message is left with a null target.  This is how we know it is  
    // a quit message.  
    mQueue.enqueueMessage(msg, 0);  
}

是一个无限循环，退出循环的条件是：msg.target == null;
也就是说，如果我们向此looper的MessageQueue发送一个target为null的message，就可以停止这个线程的远行。

停止HandlerThread的方法就是使用quit方法，具体调用形式如下：
mHandlerThread.getLooper().quit();

2. 线程池管理

new Thread(new Runnable() {

@Override
public void run() {
    // TODO Auto-generated method stub
}

}).start();

这样new出来的匿名对象会存在一些问题

  • 由于是匿名的，无法对它进行管理
  • 如果需要多次执行这个操作就new多次，可能创建多个，占用系统资源
  • 无法执行更多的操作

使用线程池的好处：
可以重复利用存在的线程，减少系统的开销；利用线程池可以执行定时、并发数的控制

线程池的作用：
线程池作用就是限制系统中执行线程的数量。

原理：根据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果；少了浪费了系统资源，多了造成系统拥挤效率不高。用线程池控制线程数量，其他线程排队等候。一个任务执行完毕，再从队列的中取最前面的任务开始执行。若队列中没有等待进程，线程池的这一资源处于等待。当一个新任务需要运行时，如果线程池中有等待的工作线程，就可以开始运行了；否则进入等待队列。

为什么要用线程池:

1.减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
2.可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器瘫痪(每个线程需要大约
1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。

Java通过Executors提供四种线程池

newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。

newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

Android并发与竞争：解析多线程编程
ByteJolt的博客
08-18 146
我们了解了线程和进程的概念，主线程和后台线程的作用，以及如何处理竞争条件。通过正确地使用并发编程技术，我们可以提高应用的性能和响应能力，并确保数据的一致性和可靠性。线程安全是指多个线程通过适当的同步机制访问共享资源时，不会导致数据的不一致性或者错误的结果。在多线程环境中，我们需要注意共享资源的访问权限和同步机制，以避免出现竞争条件。使用线程池可以减少线程创建和销毁的开销，并且能够控制并发线程的数量。通过合理地选择和使用这些同步机制，我们可以有效地处理竞争条件，确保多线程环境下的数据一致性和可靠性。
Android 多线程及线程通信
03-19 2万+
AsyncTask AsyncTask，它使创建需要与用户界面交互的长时间运行的任务变得更简单。相对来说AsyncTask更轻量级一些，适用于简单的异步处理，不需要借助线程和Handler即可实现。  AsyncTask是抽象类.AsyncTask定义了三种泛型类型 Params，Progress和Result。  　　Params 启动任务执行的输入参数，比如HTTP请求的URL。
Android知识归纳--线程
最新发布
qq_39958103的博客
09-26 895
主线程是指进程拥有的线程，或叫UI线程，Java中默认情况下一个进程只有一个线程，这个线程就是主线程。主线程不能执行耗时的任务,所以在一些耗时处理时，就得使用子线程。Android沿用了Java的线程模型，从Android3.0开始系统要求网络访问也必须在子线程中进行，否则网络访问将会失败并抛出NetworkOnMainThreadException异常。在Android里如果主线程被执行耗时任务导致阻塞后还会造成ANR的发生。
android 多线程实现方式
android开发实习生面试中一些问题
08-17 711
android 多线程实现方式： 由于android是单线程模式，所有的ui操作必须在主线程里进行操作，但有些耗时的ui操作又会阻塞主线程，所以需要一种方式来在其他线程里处理耗时操作，handler应运而生。 1.handler方式 这是android 最基本的线程实现方式–异步消息处理机制，在其中涉及到4个概念。 message,looper,handler,messageQueue.
Android 多线程并发详解
袁震的博客
10-08 980
中央处理器（CPU），是电子计算机的主要设备之一，电脑中的核心配件。其功能主要是解释计算机指令以及处理计算机软件中的数据。CPU是计算机中负责读取指令，对指令译码并执行指令的核心部件。中央处理器主要包括两个部分，即控制器、运算器，其中还包括高速缓冲存储器及实现它们之间联系的数据、控制的总线。电子计算机三大核心部件就是CPU、内部存储器、输入/输出设备。中央处理器的功效主要为处理指令、执行操作、控制时间、处理数据。进程是操作系统进行资源分配的最小单位。
android线程并发
cf8833的博客
05-16 715
1.概念： Java是一种多线程编程语言，它包含两个或多个可以同时运行的部分，每个部分可以同时处理不同的任务， 特别是当您的计算机有多个CPU时，可以充分利用可用资源。 2.线程的生命周期： 创建、启动、运行、死亡 new - 新线程在新状态下开始其生命周期。它一直处于这种状态，直到程序启动线程。它也被称为天生的线程。 Runnable - 启动新生成的线程后，线程变为可运行。...
Android多线程实现方式及并发与同步，聪明人已经收藏了！
m0_53537576的博客
04-21 417
前言 对于android开发，我们大部分工作都是在应用层，但为了体现"技术含量"，以及"知其所以然"，以便在遇到具体问题时不至于束手无策，因此有必要了解底层的工作机制。 比如Android NDK 开发可能在平时的项目开发中不常用到，但是这并不代表其不重要。相反NDK的学习有助于加深开发者在阅读框架的源码理解，是Android开发人员的进阶过程中必须要掌握的技能。 为什么NDK越来越重要了？ 一是短视频、直播等行业迅猛发展。音视频+社交成为流量新的增长点。近两年，短视频、直播、网络视频等行业不断爆热，其中抖
android播放视频！Android多线程实现方式及并发与同步，深度好文
fanzhang_vip0723的博客
03-11 494
前言 本人毕业于非211、985一本，学的是计算机网络，大一在一位师哥的引导下接触了Android开发，随着近一步的接触，慢慢的喜欢上了Android开发。于是大二开始，我开始自学Android开发。 大四的时候开始找实习工作， 因为喜欢Android开发，找的都是Android开发岗位，最后经过一段时间的面试，拿到了阿里的实习offer。 今天就分享一下我的阿里面经和面试前的准备和学习方法，希望的想进大厂实习的同学提供一些帮助。 笔记部分展示 全部资料展示 PS：由于文章篇幅问题，小编挑了一个大家应该都
Android 多线程实现重复启动与停止的服务
08-29
总结来说，Android多线程环境下，正确管理服务的启动和停止，需要保证数据同步的正确性和原子性。使用并发工具，如`AtomicBoolean`，可以有效地防止竞态条件。同时，根据服务的重启需求，选择适当的启动模式也是实现...
JAVA多线程之并发与同步，Lock与Syncronized
热门推荐
csdn_aiyang的博客
03-23 2万+
说到线程，就不得不先说线程和进程的关系。进程是系统的执行单位，一般一个应用程序即是一个进程，程序启动时系统默认有一个主线程，即是UI线程，我们知道不能做耗时任务，否则ANR程序无响应。这时需要借助子线程实现，即多线程。由于线程是系统CPU的最小单位，用多线程其实就是为了更好的利用cpu的资源。一、多线程创建方式//线程休眠1000毫秒，sleep使线程进入Block状态，并释放资源xx.start();//启动线程，run函数运行@Override@Override。
Android中多线程实现
老猿的自留地
03-11 670
我们使用Thread类时，可以创建Thread的子类并重写其run方法， 或者自定义一个实现Runable协议的类，然后将其与Thread进行绑定。AsyncTask只能在UI线程调用，一般作为Activity的子类， 以便在重写的方法中访问 Activity中的属性和数据。Android中多线程主要有三种实现方式：通过Thread类、AsyncTask或者RxJava。使用RxJava的好处是，通过采用这种封装好的异步调度框架，可以大大简化线程间切换的过程。2. 通过AsyncTask。
Android中的Handler与多线程应用实例
09-03
主要介绍了Android中的Handler与多线程应用实例,本文首先解释一下handler是用来干嘛的,然后通过例子介绍其在多线程中的应用,需要的朋友可以参考下
Android（Java）线程的两种实现方式
08-30
Android（Java）线程的两种实现方式
Android和Java之并发多线程（详细归纳和讲述）
Frank浩的博客
11-06 455
如果关注了本人的博客，前面有一篇这样的博客，讲述是：Java单机模式下重要的两个知识点(数据检索和并发线程) https://blog.csdn.net/zh_android/article/details/90721884 这里我们来详细谈谈并发线程。 Android和Java之并发多线程 有些工程师将并发和多线程当成一个概念，在软件开发中这样概念还不少，如：依赖注入和控制反转，高...
Android 性能之多线程并发优化
程序员Android
07-23 491
和你一起终身学习，这里是程序员Android经典好文推荐，通过阅读本文，您将收获以下知识点:一、Thread 使用二、Android Thread三.线程优先级一、Thread 使用在讲解...
Android并发编程与多线程
weixin_42277946的博客
11-17 650
Android异步
android 中的多线程实现方式
qq_42447739的博客
03-08 3211
AsyncTask： 实现多线程，在工作线程中执行任务，如耗时任务 它属于抽象类 public abstract class AsyncTask<Params, Progress, Result> { … } // 类中参数为3种泛型类型 // 整体作用：控制AsyncTask子类执行线程任务时各个阶段的返回类型 // 具体说明： // a. Params：开始异步任务执行时传入的参数类型，对应excute（）中传递的参数 // b. Progress：异步任务执行过程中，返回下载进度值的类型
Android中的线程和并发处理
CodeHeroicX的博客
10-07 75
在多线程环境中，线程同步是确保多个线程按照预期顺序执行的重要机制。在Android开发中，线程和并发处理是非常重要的概念。线程是一种执行单元，用于在应用程序中执行并发任务。在本文中，我们将深入探讨Android中的线程和并发处理，并提供相应的源代码示例。在实际开发中，合理地使用线程和并发处理可以提高应用程序的性能和响应能力。然而，需要注意线程安全、避免死锁和合理管理线程等问题，以确保应用程序的稳定性和可靠性。在Android中，主线程是应用程序的默认线程，用于处理用户界面和事件响应。
Android多线程的几种实现方式
Chimoshi的博客
10-01 1480
提示：本文不涉及多线程框架，只采用安卓原生提供的多线程技术去实现多线程处理 1、通过继承Thread类或者实现Runnable接口去实现 class TheadTask extends Thread{ @Override public void run() { Log.d("MainActivity","TheadTask is running"); } } class ThreadRunnable impleme
优化Android多线程下载：控制并发与高效利用线程池
在Android开发中，多线程下载是...总结来说，本文介绍了如何在Android开发中使用线程池和信号量机制来合理控制并发数，以实现高效且稳定的多线程下载。通过合理的线程管理，可以优化资源利用，提高应用程序的整体性能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值