Android多线程开发核心知识点

最新推荐文章于 2024-05-02 16:22:09 发布
最新推荐文章于 2024-05-02 16:22:09 发布
阅读量127 收藏 1
点赞数
文章标签： android java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36828822/article/details/132465786
版权

什么是线程并发安全

  • 线程安全的本质是能够让并发线程，有序的运行(这个有序可能是先来后到的排队，有可能有人插队，但是不管怎么着，同一时刻只能一个线程有权访问同步资源)，线程执行的结果，能够对其他线程可见。

线程安全的几种分类

  • synchronized关键字
  • ReentrantLock锁
  • AtomicInteger…原子类

在这里插入图片描述

  • 锁适合写操作多的场景，先加锁可以保证写操作时数据正确。
  • 原子类适合读操作多的场景，不加锁的特点能够使其读操作的性能大幅提升。

如何保证线程安全

  • AtomicInteger原子包装类，CAS实现无锁数据更新。自旋的设计有效避免线程因阻塞-唤醒带来的系统资源开销。自旋其实就是一个do-while循环。
  • 适用场景：多线程计数，原子操作，并发数量小的场景。

在这里插入图片描述
在这里插入图片描述

  • synchronized
    锁java对象，锁class对象，锁代码块

    • 锁方法。加在方法上，未获取到对象锁的其他线程都不可以访问该方法。
      在这里插入图片描述

    • 锁class对象。加在static方法上相当于给class对象加锁，哪怕是不同的java对象实例，也需要排队执行。
      在这里插入图片描述

    • 锁代码块。未获取到对象锁的其他线程可以执行同步块之外的代码。
      在这里插入图片描述
      在这里插入图片描述

  • ReentrantLock 悲观锁，可重入锁，公平锁，非公平锁

    1. 基本用法
package com.example.myapplication.demo;

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockDemo {

    static class ReentrantLockTask{
        ReentrantLock reentrantLock = new ReentrantLock();

        void buyTicket(){
            String name= Thread.currentThread().getName();
            try {
                reentrantLock.lock();
                System.out.println(name+":准备好了");
                Thread.sleep(100);
                System.out.println(name+":买好了");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                reentrantLock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        final ReentrantLockTask task = new ReentrantLockTask();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                task.buyTicket();
            }
        };

        for (int i = 0; i < 10; i++) {
            new Thread(runnable).start();
        }
    }
}

//执行结果：
/*
Thread-2:准备好了
Thread-2:买好了
Thread-3:准备好了
Thread-3:买好了
Thread-4:准备好了
Thread-4:买好了
Thread-5:准备好了
Thread-5:买好了
Thread-6:准备好了
Thread-6:买好了
Thread-7:准备好了
Thread-7:买好了
Thread-8:准备好了
Thread-8:买好了
Thread-9:准备好了
Thread-9:买好了
Thread-10:准备好了
Thread-10:买好了
Thread-11:准备好了
Thread-11:买好了
*/
  1. 可重入，避免死锁
package com.example.myapplication.demo;

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockDemo {

    static class ReentrantLockTask{
        ReentrantLock reentrantLock = new ReentrantLock();

        void buyTicket(){
            String name= Thread.currentThread().getName();
            try {
                reentrantLock.lock();
                System.out.println(name+":准备好了");
                Thread.sleep(100);
                System.out.println(name+":买好了");
                reentrantLock.lock();
                System.out.println(name+":又准备好了");
                Thread.sleep(100);
                System.out.println(name+":又买好了");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                reentrantLock.unlock();
                reentrantLock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        final ReentrantLockTask task = new ReentrantLockTask();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                task.buyTicket();
            }
        };

        for (int i = 0; i < 10; i++) {
            new Thread(runnable).start();
        }
    }
}
/*
Thread-2:准备好了
Thread-2:买好了
Thread-2:又准备好了
Thread-2:又买好了
Thread-3:准备好了
Thread-3:买好了
Thread-3:又准备好了
Thread-3:又买好了
Thread-4:准备好了
Thread-4:买好了
Thread-4:又准备好了
Thread-4:又买好了
Thread-5:准备好了
Thread-5:买好了
Thread-5:又准备好了
Thread-5:又买好了
Thread-6:准备好了
Thread-6:买好了
Thread-6:又准备好了
Thread-6:又买好了
Thread-7:准备好了
Thread-7:买好了
Thread-7:又准备好了
Thread-7:又买好了
Thread-8:准备好了
Thread-8:买好了
Thread-8:又准备好了
Thread-8:又买好了
Thread-9:准备好了
Thread-9:买好了
Thread-9:又准备好了
Thread-9:又买好了
Thread-10:准备好了
Thread-10:买好了
Thread-10:又准备好了
Thread-10:又买好了
Thread-11:准备好了
Thread-11:买好了
Thread-11:又准备好了
Thread-11:又买好了

*/

  1. 公平锁与非公平锁

    • 公平锁，所有进入阻塞的线程排队依次均有机会执行。使用场景：交易
    • 默认非公平锁，允许线程插队，避免每一个线程都进入阻塞，再唤醒，性能高。因为线程可以插队，导致队列中可能会存在线程饿死的情况，一直得不到锁，一直得不到执行。
ReentrantLock reentrantLock = new ReentrantLock(true/false);//true:公平；false不公平

package com.example.myapplication.demo.lock;

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockDemo2 {
    static class ReentrantLockTask{
        ReentrantLock lock = new ReentrantLock(false);

        void print(){
            String name = Thread.currentThread().getName();
            try {
                lock.lock();
                System.out.println(name+"第一次打印");
                Thread.sleep(1000);
                lock.unlock();

                lock.lock();
                System.out.println(name+"第二次打印");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        final ReentrantLockTask task = new ReentrantLockTask();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                task.print();
            }
        };

        for (int i = 0; i < 10; i++) {
            new Thread(runnable).start();
        }
    }
}
/*
  Thread-2第一次打印
Thread-2第二次打印
Thread-3第一次打印
Thread-3第二次打印
Thread-4第一次打印
Thread-4第二次打印
Thread-5第一次打印
Thread-5第二次打印
Thread-6第一次打印
Thread-6第二次打印
Thread-7第一次打印
Thread-7第二次打印
Thread-8第一次打印
Thread-8第二次打印
Thread-9第一次打印
Thread-9第二次打印
Thread-10第一次打印
Thread-10第二次打印
Thread-11第一次打印
Thread-11第二次打印
*/

package com.example.myapplication.demo.lock;

import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockDemo2 {
    static class ReentrantLockTask{
        ReentrantLock lock = new ReentrantLock(true);

        void print(){
            String name = Thread.currentThread().getName();
            try {
                lock.lock();
                System.out.println(name+"第一次打印");
                Thread.sleep(1000);
                lock.unlock();

                lock.lock();
                System.out.println(name+"第二次打印");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        final ReentrantLockTask task = new ReentrantLockTask();
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                task.print();
            }
        };

        for (int i = 0; i < 10; i++) {
            new Thread(runnable).start();
        }
    }
}
/*
Thread-2第一次打印
Thread-3第一次打印
Thread-4第一次打印
Thread-5第一次打印
Thread-6第一次打印
Thread-7第一次打印
Thread-8第一次打印
Thread-9第一次打印
Thread-10第一次打印
Thread-11第一次打印
Thread-2第二次打印
Thread-3第二次打印
Thread-4第二次打印
Thread-5第二次打印
Thread-6第二次打印
Thread-7第二次打印
Thread-8第二次打印
Thread-9第二次打印
Thread-10第二次打印
Thread-11第二次打印
*/
  1. ReentrantLock进阶用法 ——Condition条件对象
    可以使用它的await-singnal指定唤醒一个(组)线程。相比于wait-notify要么全部唤醒，要么只能唤醒一个，更加灵活可控。
package com.example.myapplication.demo.lock;

import java.util.Random;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class ReentrantLockDemo3 {
    static class ReentrantLockTask {

        private Condition workerCondition, worker2Condition;
        ReentrantLock lock = new ReentrantLock(true);

        volatile int flag = 0;

        public ReentrantLockTask() {
            workerCondition = lock.newCondition();
            worker2Condition = lock.newCondition();
        }

        void work1() {
            try {
                lock.lock();
                if (flag == 0 || flag % 2 == 0) {
                    System.out.println("worker1 休息会");
                    workerCondition.await();
                }
                System.out.println("worker1 搬到的砖是：" + flag);
                flag = 0;
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }

        void work2() {
            try {
                lock.lock();
                if (flag == 0 || flag % 2 != 0) {
                    System.out.println("worker2 休息会");
                    worker2Condition.await();
                }
                System.out.println("worker2 搬到的砖是：" + flag);
                flag = 0;
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }

        void boss() {
            try {
                lock.lock();
                flag = new Random().nextInt(100);
                if (flag % 2 == 0) {
                    worker2Condition.signal();
                    System.out.println("唤醒工人2:"+flag);
                }else {
                    workerCondition.signal();
                    System.out.println("唤醒工人1:"+flag);
                }
            } finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        final ReentrantLockTask lockTask = new ReentrantLockTask();

        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true){
                   lockTask.work1();
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true){
                    lockTask.work2();
                }
            }
        }).start();

        for (int i = 0; i < 10; i++) {
            lockTask.boss();
        }
    }
}
/*

worker1 休息会
唤醒工人2:82
worker2 搬到的砖是：82
唤醒工人1:17
worker2 休息会
worker1 搬到的砖是：17
唤醒工人1:71
worker1 搬到的砖是：71
唤醒工人1:59
worker1 搬到的砖是：59
唤醒工人1:77
worker1 搬到的砖是：77
唤醒工人1:87
worker1 搬到的砖是：87
唤醒工人2:54
worker1 休息会
worker2 搬到的砖是：54
唤醒工人2:80
worker2 搬到的砖是：80
唤醒工人2:42
worker2 搬到的砖是：42
唤醒工人2:56
worker2 搬到的砖是：56
worker2 休息会
*/

  1. ReentrantReadWriteLock 共享锁、排他锁

    • 共享锁，所有线程均可同时获得，并发量高，比如在线文档查看
    • 排他锁，同一时刻只有一个线程有权修改资源，比如在线文档编辑
package com.example.myapplication.demo.lock;

import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReentrantLockDemo4 {

    static class ReentrantReadWriteLockTask{
        private final ReentrantReadWriteLock.ReadLock readLock;
        private final ReentrantReadWriteLock.WriteLock writeLock;
        ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

        ReentrantReadWriteLockTask(){
            readLock  = lock.readLock();
            writeLock = lock.writeLock();
        }

        void read(){
            String name = Thread.currentThread().getName();
            try {
                readLock.lock();
                System.out.println("线程"+name+" 正在获取数据...");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                readLock.unlock();
                System.out.println("线程"+name+" 释放了读锁...");
            }
        }

        void write(){
            String name = Thread.currentThread().getName();
            try {
                writeLock.lock();
                System.out.println("线程"+name+" 正在写入数据...");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                writeLock.unlock();
                System.out.println("线程"+name+" 释放了写锁...");
            }
        }
    }

    public static void main(String[] args) {
        final ReentrantReadWriteLockTask task = new ReentrantReadWriteLockTask();

        for (int i = 0; i < 3; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    task.read();//因为是读写锁，所以3个线程的日志会一起打印出来
                }
            }).start();
        }

        for (int i = 0; i < 3; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    task.write();
                }
            }).start();
        }
    }
}
/*
线程Thread-2 正在获取数据...
线程Thread-3 正在获取数据...
线程Thread-4 正在获取数据...
线程Thread-3 释放了读锁...
线程Thread-6 正在写入数据...
线程Thread-2 释放了读锁...
线程Thread-4 释放了读锁...
线程Thread-6 释放了写锁...
线程Thread-5 正在写入数据...
线程Thread-5 释放了写锁...
线程Thread-7 正在写入数据...
线程Thread-7 释放了写锁...
*/

如何正确的使用锁&原子类

  • 减少持锁时间
    在这里插入图片描述

  • 锁分离
    在这里插入图片描述

  • 锁粗化
    多次加锁，释放锁合并成一次
    在这里插入图片描述
    在这里插入图片描述

hzulwy
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Android开发之多进程详解
feiyang877647044的博客
06-14 4555
相信很多做Android开发的同学对进程在Android中这个概念，都不怎么说的清楚，网路上有的说是一个应用程序，这其实是不对的，w为了研究Android中进程的概念，我这里写了一个很简单的代码， <application android:name="com.example.nine.MyApplication" android:allowBackup="true"
Android 开发知识点汇总
叁叁啊啊啊啊
11-08 286
基础组件 Application PackageManager Activity Activity生命周期Activity启动模式Stack与TaskActivityManager Service Service创建方式（2种）IntentServiceServiceManager ContentProvider 联系人Demo Broad
Android 锁、线程
qq_32506429的博客
01-16 1612
1、线程生命周期： 正常执行一次就结束的：new->runnable->runing->treminer(怎么拼忘了，结束)； 执行多次结束的：new->runnable->runing->调用wait()变成wating->调用notify()变成runnable->runing->treminer 锁类型，保存在对象的对象头中： 无锁 偏向锁 轻量锁 ： 重量锁 ：monitor介入，必定有一个线程会获得锁 2、单例： 这个懒汉式
Android 线程及线程安全（一）
kakakk_k的博客
04-11 780
当调用了wait()方法时，会释放持有对象的锁，只有等待调用notify()/notifyAll()唤醒，才会重新去获取持有对象的锁。（3）其他阻塞：如调用了sleep()/join()方法，或调用了阻塞式的IO方法等。异同点：当synchronized执行完成，会自动释放同步监视器，而调用了lock()方法后需要调用unlock()之后，其他线程才会获得使用lock的对象。（2）就绪Runnable：当线程对象调用start()方法后，等待CPU调度器的调度，此时线程处于Runnable状态。
Android 多线程——线程安全/线程同步
最新发布
liuning1985622的博客
05-02 306
单一程序中每次只能做一件事情，它是串行执行的；但多线程程序是可以异步并发处理同一件事情，这样就会发生两个线程抢占资源的问题，使如一个线程正在写数据，而另一个线程刚才在读数据，那么就会产生很多未知的错误情况出现，这也是多线程最危险的事情。
Android基础学习（二十）—— 线程安全
123
12-09 1015
线程安全
android——线程池（单例）、线程1等待线程2执行完才往下走、线程锁(synchronized关键字和ReentrantLock)
wy313622821的博客
01-11 3170
所以在我们使用线程池的时候，需要把线程池做成单例（有的同学会想着new一个线程池放到全局来使用，其实正确的做法是做成单例最好），创建的时候定义好多少个线程。如果把new ThreadPoolExecutor放进循环，会造成内存溢出。
Android开发核心知识点笔记_安卓开发_
10-02
这份"Android开发核心知识点笔记"涵盖了初学者至进阶者所需的重要概念和技术。以下是对这些知识点的详细解释： 1. **环境搭建**：首先，开发者需要安装Java Development Kit (JDK)、Android Studio以及Android SDK...
原版Android核心知识点笔记V202003301
08-03
在深入探讨Android核心知识点之前，我们先来理解Java虚拟机（JVM）的工作流程，这是Android应用开发的基础。JVM是Java程序运行的平台，它的主要任务是执行字节码，提供了一个“一次编写，到处运行”的环境。 1.1.1 ...
android 多线程下载机制
11-18
在Android平台上，多线程下载机制是提升应用性能和用户体验的关键技术之一，特别是在处理大...通过理解和实践这些知识点，开发者可以创建出高效、稳定且用户体验良好的多线程下载功能，从而提升Android应用的整体性能。
Java、Android多线程、线程安全、线程同步
03-27
NoHttp核心架构之多线程通信、线程安全、线程同步；synchronized锁，Lock锁；具体讲解请移步博客：http://blog.csdn.net/yanzhenjie1003/article/details/50992468
JAVA核心知识点整理.docx
06-10
JAVA核心知识点整理 JAVA 是一种流行的编程语言，广泛应用于 Android 应用开发、Web开发、企业软件开发等领域。随着技术的发展，JAVA 的知识点也在不断增加和更新。本文将从 JVM、线程、JVM 内存区域、垃圾回收、...
Android核心知识.pdf
05-19
在Android开发领域，掌握核心知识点至关重要，这有助于开发者提高效率，避免不必要的问题。这份"Android核心知识.pdf"文档深入探讨了Android开发中的关键概念，包括Java基础知识，这对于Android程序员来说是必不可少...
Android 线程安全+volatile
zenmela2011的专栏
01-18 1858
1.数据依赖性 如果两个操作访问同一个变量，且这两个操作中有一个为写操作，此时这两个操作之间就存在数据依赖。 数据依赖分下列三种类型： ①写后读（a = 1;b = a;） 写一个变量之后，再读这个位置。 ②写后写 （a = 1;a = 2;） 写一个变量之后，再写这个变量。 ③读后写（a = b;b = 1;） 读一个变量之后，再写这个变量。 上面三种情况，只要重排序两个操作的执行顺序，程序的执行结果将会被改变。所以，编译器和处理器在重排序时，会遵守数据依赖性，编译器和处理器不会改变存在数据依赖关系的两个
Android 线程死锁场景与优化
Androiddddd的博客
12-30 1072
本文主要是对死锁的问题的优化建议，至于性能问题，其实我们遵循一个原则：在保证流畅度的情况下线程越少越好。对于必要存在的线程，可以使用队列缓冲、逃逸分析、对象标量化、锁消除、锁粗化、降低锁范围、多路复用、消除同步屏障、协程的角度去优化。如果想要成为架构师或想突破20~30K薪资范畴，那就不要局限在编码，业务，要会选型、扩展，提升编程思维。此外，良好的职业规划也很重要，学习的习惯很重要，但是最重要的还是要能持之以恒，任何不能坚持落实的计划都是空谈。
Android进阶宝典 --- 多线程（并发，引入锁概念）
qq_33235287的博客
05-01 1015
多线程基础知识
Android并发编程与多线程
weixin_42277946的博客
11-17 563
Android异步
Android 进程+线程
zenmela2011的专栏
11-14 3971
1.线程 线程是进程中可独立执行的最小单位，也是CPU资源分配的基本单位; 进程是程序向操作系统申请资源的基本条件，一个进程可以包含多个线程，同一个进程中的线程可以共享进程中的资源，如内存空间和文件句柄; 操作系统会把资源分配给进程，但是CPU资源比较特殊，它是分配给线程的，这里说的CPU资源也就是 CPU 时间片; 进程与线程的关系，就像是饭店与员工的关系，饭店为顾客提供服务，而提供服务的具体方式是通过一个个员工实现的; 线程的作用是执行特定任务，这个任务可以是下载文件、加载图片、绘制界面等; 2.线程的
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值