Android多线程学习：线程

已于 2023-10-09 08:52:46 修改
阅读量430 收藏 1
点赞数
分类专栏： Android - 多线程 文章标签： android 学习 java
于 2023-10-08 18:06:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kongqwesd12/article/details/133687332
版权

一、概念

进程：系统资源分配的基本单位，进程之间相互独立，不能直接访问其他进程的地址空间。

线程：CPU调度的基本单位，线程之间共享所在进程的资源，包括共享内存，公有数据，全局变量等。

后台线程：后台线程又称为守护线程（Daemon Thread），JVM的垃圾回收线程就是典型的后台线程。

举例记忆：以下纯属本人瞎编，方便记忆

  • 进程就是一个鞋子工厂，鞋子由鞋带、鞋底、鞋帮三部分组成。线程就是工厂下的流水线，一条流水线做鞋带，一条流水线做鞋底，一条流水线做鞋帮，最后再把做好的组件组装起来变成一个鞋子。
  • 我们会把原材料直接提供给工厂，工厂统一接收而不是里面具体的某个流水线。所以工厂（进程）就是我们系统分配资源的最小单位。
  • 如果想做出鞋子，至少要开启一个流水线工作，这个流水线可以先做鞋带，在做鞋帮，在做鞋底，最后再组装成鞋子，如果没有流水线工作，一双鞋子也做不出来。所以流水线是系统可调度执行的基本单位。
  • 工厂包含多条流水线，即进程包含多个线程，而多条流水线上的工人又共享工厂里的食堂、厕所、宿舍，线程之间共享所在进程的资源。

二、线程三种实现

1、继承Thread类

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //3、创实例，并调用start()方法开启线程。
        new MyThread().start();
        new MyThread().start();
    }

    //1、定义一个类MyThread继承Thread，并重写run方法
    class MyThread extends Thread {

        @Override
        public void run() {
            //2、将执行的代码写在run方法中。
            Log.d(TAG, "线程名字:" + Thread.currentThread().getName());
        }
    }
}

2、实现Runnable接口

public class MainActivity extends AppCompatActivity {
    public static final String TAG = MainActivity.class.getSimpleName();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //3、创建Thread对象, 传入MyRunnable的实例，并调用start()方法开启线程。
        Thread thread = new Thread(new MyRunnable());
        thread.start();
        Thread thread1 = new Thread(new MyRunnable());
        thread1.start();
    }

    // 1、定义一个类MyRunnable实现Runnable接口，并重写run方法。
    class MyRunnable implements Runnable {
        public void run() {
            //2、将执行的代码写在run方法中。
            Log.d(TAG, "线程名字:" + Thread.currentThread().getName());
        }
    }
}

3 、通过Callable和Future创建有返回值的多线程

public class MainActivity extends AppCompatActivity {
    private final String TAG = this.getClass().getSimpleName();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //3、创建线程池对象，调用submit()方法执行MyCallable任务，并返回Future对象
        ExecutorService pool = Executors.newSingleThreadExecutor();
        Future<Integer> f1 = pool.submit(new MyCallable());
        //4、调用Future对象的get()方法获取call()方法执行完后的值
        try {
            Log.d(TAG, "sum = " + f1.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        //5、关闭线程池
        pool.shutdown();
    }

    //1、自定义一个类MyCallable实现Callable接口，并重写call()方法
    public class MyCallable implements Callable<Integer> {
        @Override
        public Integer call() throws Exception {
            //2、将要执行的代码写在call()方法中
            int sum = 0;
            for (int i = 0; i <= 100; i++) {
                sum += i;
            }
            return sum;
        }
    }
}

三、线程的生命周期

1、线程的生命周期包括：新建New，就绪Runnable，运行Running，阻塞Blocked，和死亡Dead，5种状态。

新建：程序使用new关键字之后，该线程就处于新建状态，jvm为其分配内存，并初始化成员变量。

就绪：程序调用start() 方法之后，该线程就处于就绪状态，jvm为其创建方法调用栈和PC计数器。

运行：如果就绪状态的线程获得了CPU，那么程序就处于运行状态。

阻塞：指一个线程在执行过程中暂停，以等待某个条件的触发。

死亡：线程执行体执行结束，以及抛出一个未捕获的Exception或Error，或者直接调用stop()方法结束该线程。可以通过线程对象的isAlive()方法，来判断线程对象的状态。

2、生命周期转换

（1）运行到阻塞：

  • 线程调用sleep()方法，主动放弃所占有的CPU资源；
  • 线程调用了一个阻塞式IO方法，在该方法返回之前，该线程被阻塞；
  • 线程试图获得一个同步监视器，但是该同步监视器被其他线程所持有；
  • 线程等待某个通知notify()，notify()通常与wait()配合使用；
  • 线程调用suspend()，挂起，该方法容易造成死锁，不建议使用。

（2）阻塞到就绪：

  • sleep()方法的线程经过了指定的sleep的时间；
  • 阻塞式IO方法返回值；
  • 成功获得了同步监视器；
  • 线程获得了其他线程发出的通知，被唤醒；
  • 挂起的线程调用了resume()方法恢复。

（3）状态转换图
线程生命周期.png

四、线程常用方法

1、setPriority(int newPriority) - 设置线程优先级

  • 设置线程的优先级来改变线程争抢到时间片的概率，优先级高的争抢到时间片的概率越大；
  • 优先级的取值范围：1~10，默认为5，数字越大，优先级越高；
  • 这个方法的调用必须在start之前，否则没有任何意义；
  • 使用方法getPriority()，获取当前线程优先级。

2、setDeamon（boolean b） - 设置后台线程

  • 如果所有的前台线程死亡，那么后台线程会自动死亡；
  • 默认情况下所有的线程都是前台线程；
  • 这个方法的调用必须在start之前。

3、sleep(long millis) - 设置线程休眠

  • 让当前线程暂停millis毫秒，并进入阻塞状态，睡眠状态的线程不会释放同步监视器，在此期间该线程不会获得执行的机会；
  • 使用sleep方法时需要捕捉InterruptedException或者抛出该异常。

4、interrupt（） - 线程中断

  • 表示的并不是将线程结束，而是表示清除阻塞状态；
  • 中断线程操作实质上是修改了一下中断标示位为true；
  • 如果线程处于阻塞状态，抛出异常InterruptedException。
public class MainActivity extends AppCompatActivity {
    public static final String TAG = MainActivity.class.getSimpleName();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Thread thread = new Thread(new MyRunnable());
        thread.start();

        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //打断休眠线程
        thread.interrupt();
    }

    class MyRunnable implements Runnable {
        public void run() {
            try {
                Log.i(TAG, "----开始休眠-----");
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
                Log.i(TAG, "----线程中断-----");
            }
            Log.i(TAG, "----休眠后执行-----");
        }
    }
}

执行结果：报异常，提示中断，取消线程阻塞，执行休眠后操作。

interrupt.PNG

public class MainActivity extends AppCompatActivity {
    public static final String TAG = MainActivity.class.getSimpleName();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Thread thread = new Thread(new MyRunnable());
        thread.start();
        thread.interrupt();
    }

    class MyRunnable implements Runnable {
        public void run() {
            for (int i = 0; i < 5; i ++){
                Log.i(TAG,"打印： " + i);
                if (Thread.interrupted()){
                    Log.i(TAG, "----线程被中断了-----");
                }
            }
            Log.i(TAG, "----执行完了- interrupt state： " + Thread.interrupted());
        }
    }
}

执行结果：interrupted()只有主线程调用的时候才会是true。for循环结束后再次执行是false。interrupt2.PNG

5、join() - 线程合并

  • 在执行原来的线程的过程中，如果遇到了合并线程，则优先执行合并进来的线程，当合并线程执行完毕之后，再接着执行原来的线程；
  • 调用join方法之前，一定要将线程start；
  • join(0)的意思不是A线程等待B线程0秒，而是A线程等待B线程无限时间，直到B线程执行完毕，即join(0)等价于join()。
public class MainActivity extends AppCompatActivity {
   public static final String TAG = MainActivity.class.getSimpleName();

   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);
       Thread thread1 = new Thread(new JoinRunnable());
       thread1.start();

       for (int i = 0; i < 5; i++) {
       //主线程执行1的时候，把执行权让给了子线程
           if (i == 1) {
               try {
                   thread1.join();
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
           Log.i(TAG, Thread.currentThread().getName() + "正在运行....");
       }
   }


   class JoinRunnable implements Runnable {

       @Override
       public void run() {
           for (int i = 0; i < 3; i++) {
               try {
                   Thread.sleep(1000);
                   Log.i(TAG, Thread.currentThread().getName() + "正在运行....");
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       }
   }
}

执行结果：
join3.PNG
6、yield() - 线程让步

  • 使得正在执行的线程暂停，但不会阻塞线程，释放自己拥有的CPU，线程进入就绪状态。
  • 只有优先级与当前线程相同，或者优先级比当前线程更高的线程才有可能获得执行机会，但是可能是当前线程又进入到“运行状态”继续运行。
public class MainActivity extends AppCompatActivity {
    public static final String TAG = "test";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Thread thread1 = new Thread(new MyRunnable());
        thread1.start();
    }


    class MyRunnable implements Runnable {

        @Override
        public void run() {
            long begainTime = System.currentTimeMillis();
            int count = 0;
            for (int i = 0; i < 5000000; i++) {
                //结果2需要将下面注释放开
                //Thread.yield();
                count = count + (i + 1);
            }
            long endTime = System.currentTimeMillis();
            Log.i(TAG, "用时：" + (endTime - begainTime) + "ms");
        }
    }
}

运行结果1：
yield1.PNG

运行结果2，执行时放开Thread.yield()：
yield3.PNG

  • yield()也不会释放锁标志，示例如下：
public class MainActivity extends AppCompatActivity {
    public static final String TAG = "test";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Thread thread1 = new Thread(new MyRunnable());
        Thread thread2 = new Thread(new MyRunnable());
        thread1.start();
        thread2.start();
    }

    static class MyRunnable implements Runnable {
        private static Object obj = new Object();

        @Override
        public void run() {
            synchronized (obj) {
                for(int i = 0;i < 5;i++) {
                    Log.i(TAG, Thread.currentThread().getName() + "正在执行i: " + i);
                    if(i == 2) {
                        Thread.currentThread().yield();
                    }
                }
            }
        }
    }
}

运行结果，Thread-2获取锁以后，就算yield，也没释放锁：
yield4.PNG
7、stop() - 线程停止

  • 官方不建议使用该方法，因为stop不安全，stop会解除由线程获取的所有锁定，当在一个线程对象上调用stop()方法时，这个线程对象所运行的线程就会立即停止，假如一个线程正在执行：synchronized void { x = 3; y = 4;} 由于方法是同步的，多个线程访问时总能保证x,y被同时赋值，而如果一个线程正在执行到x = 3;时，被调用了stop()方法，即使在同步块中，它也会马上stop了，这样就产生了不完整的脏数据。

参考文章：
对进程、线程、多线程、线程池的理解
带你通俗易懂的理解——线程、多线程与线程池
线程类的常见方法介绍
java多线程以及Android多线程

孔小乐
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
前台线程和后台线程
weixin_42105843的博客
11-23 851
当主程序启动时定义了两个不同的线程，默认情况下显示创建的线程是前台线程，通过手动设置线程的对象IsBackground的属性为True来创建一个后天线程，通过配置来实现第一个线程会比第二个线程先完成，然后终止程序。前台线程与后台线程的主要区别就是：进程会等待所有的前台线程完成后再结束工作，但是如果只剩下后台线程，则会直接结束工作。如果程序定义了一个不会完成的前台线程，主程序不会正常结束。 using System; using System.Collections.Generic; using System
Android 系统开发中如何在后台实现多线程？
m0_70749039的博客
03-16 543
这篇文章主要介绍“Android 系统开发中如何在后台实现多线程”，在日常操作中，相信很多同行开发小伙伴在问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”Android中如何在后台实现多线程”的疑惑有所帮助！后台功能是Android的四大组件之一，其重要程度自然不言而喻，而服务是Android中实现程序后台运行的解决方案，非常适合去执行那些不需要交互，而且要长期运行的任务。而所有的任务默认都是在主线程完成的，也就是说，如果我们没有多线程的编程，就会导致主线程被堵塞多线程。
Android 进程+线程
zenmela2011的专栏
11-14 3961
1.线程 线程是进程中可独立执行的最小单位，也是CPU资源分配的基本单位; 进程是程序向操作系统申请资源的基本条件，一个进程可以包含多个线程，同一个进程中的线程可以共享进程中的资源，如内存空间和文件句柄; 操作系统会把资源分配给进程，但是CPU资源比较特殊，它是分配给线程的，这里说的CPU资源也就是 CPU 时间片; 进程与线程的关系，就像是饭店与员工的关系，饭店为顾客提供服务，而提供服务的具体方式是通过一个个员工实现的; 线程的作用是执行特定任务，这个任务可以是下载文件、加载图片、绘制界面等; 2.线程的
后台线程和前台线程
Love_HBB的专栏
08-23 423
1、获取线程的状态，当我们通过调用Thread对象的Start方法，新线程不是马上进入Runing状态，而是处于UnStarted状态,只有当操作系统的线程调度器选择了要运行的线程，这个线程状态才能修改为Runing状态。线程由操作系统调度，一个CPU同一时间只能做一件事情（运行一个线程中的计算任务），当有很多线程需要CPU去执行的时候，线程调度器会根据线程的优先级去判断先去执行哪一个线程，如果优先级相同的话，就使用一个循环调度对则，逐步执行每个线程。通过BeginXXX方法运行的线程都是后台线程。
在Android中使用Handler和Thread线程执行后台操作
weixin_30855099的博客
03-23 149
标题：在Android中使用Handler和Thread线程执行后台操作 作者：CrazyPebble 时间：2011年3月23日 声明：此文在参考《解密Google Android》一书 和 Android视频教程（www.mars-droid.com）。文中存在错误之处，还请各位批评指正。若转载本文，请指明转载出处：http://www.cnblogs.com。 　　大家都知道，在...
Android多线程学习实例详解
09-01
本文将深入探讨Android多线程的使用方法和注意事项，结合实例进行详细讲解。 首先，理解多线程的基本概念。在计算机编程中，多线程是指一个进程中可以同时执行多个任务或路径。在Android系统中，主线程（UI线程）...
Android多线程文件上传
12-01
本主题聚焦于"Android多线程文件上传"，我们将探讨如何利用多线程技术来优化文件上传过程，提高效率，并确保应用的响应性。 一、多线程基础 多线程是并发执行多个任务的能力，它允许应用程序同时处理多个任务，提高...
Android:多线程下载&网络图片
最新发布
02-06
本文将深入探讨如何在Android平台上实现多线程下载和网络图片下载，同时也会提到断点续传这一高级功能。 首先，我们要理解多线程下载的概念。在单线程下载中，数据是从服务器一次性传输到客户端，如果文件较大，这...
Android多线程自动化框架
08-13
多线程方式在多台手机上同时执行测试，自动获取已连接各设备信息，自动启动已连接设备相同多个appium服务，多个测试用例连续执行，用例执行失败自动截图、录制视频、收集报错信息，列表中高亮显示，全新报告模板，...
Android多线程下载示例详解
08-28
主要为大家详细介绍了Android多线程下载示例，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Android 双进程守护的实现代码
08-27
主要介绍了Android 双进程守护的实现代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Android-工作在后台-使用后台线程
宝爷的专栏
01-05 3532
相应能力对于Android系统来说太重要了。为了确保APP快速地应对用户的交互和系统事件，我们需要将所有的耗时处理和I/O相关的操作移到子线程中去。文件操作、网络查询、数据库事务、还有复杂的计算都应该在后台线程中进行。Android提供了一系列的措施可以让你将处理移到后台。比如：Thread+Handler的组合，AsyncTask。AsyncTask用来执行短期的处理非常合适。但是呢，Activ...
android 工作线程,Android-工作在后台-使用后台线程
weixin_42384267的博客
05-25 278
相应能力对于Android系统来说太重要了。为了确保APP快速地应对用户的交互和系统事件，我们需要将所有的耗时处理和I/O相关的操作移到子线程中去。文件操作、网络查询、数据库事务、还有复杂的计算都应该在后台线程中进行。Android提供了一系列的措施可以让你将处理移到后台。比如：Thread+Handler的组合，AsyncTask。AsyncTask用来执行短期的处理非常合适。但是呢，Activ...
Android中后台线程如何与UI线程交互
zqx198810的专栏
07-24 952
我想关于这个话题已经有很多前辈讨论过了。今天算是一次学习总结吧。 在android的设计思想中，为了确保用户顺滑的操作体验。一些耗时的任务不能够在UI线程中运行，像访问网络就属于这类任务。因此我们必须要重新开启一个后台线程运行这些任务。然而，往往这些任务最终又会直接或者间接的需要访问和控制UI控件。例如访问网络获取数据，然后需要将这些数据处理显示出来。就出现了上面所说的情况。原本这是在正
多线程开发（1）：主线程，前台线程，后台线程，守护线程，子线程，托管线程的关系...
Eric198808的博客
10-19 245
1.主线程当一个程序启动时，就有一个进程被操作系统（OS）创建，与此同时一个线程也立刻运行，该线程通常叫做程序的主线程（Main Thread），因为它是程序开始时就执行的，如果你需要再创建线程，那么创建的线程就是这个主线程的子线程。每个进程至少都有一个主线程，在Winform中，应该就是创建GUI的线程。主线程的重要性体现在两方面：1.是产生其他子线程的线程；2.通常它必须最后完成执行...
java前台线程和后台线程
IT_COOKIE_SAM的博客
01-02 1480
main()函数即主函数，是一个前台线程，前台进程是程序中必须执行完成的，而后台线程则是java中所有前台结束后结束，不管有没有完成，后台线程主要用与内存分配等方面                                                                                                                  前台线程
Android 线程始终运行之我见
soboer
07-07 301
最近做Android手机GPS定位系统应用软件的开发，发现手机通过usb或屏幕亮的时候能够通过三种方式定位，一旦手机在休眠的时候，手机的cpu也休眠了，创建的线程会继续sleep，不会发生自己预期的效果，郁闷的事情困扰着自己，再闷也有解决的方案吧，加上蒸笼似的天气。 我的查阅了好许资料，也许自己的想法是正确的，什么都要靠事实说话，最好的解决方案就是在手机屏幕休眠时让cpu继续，才能让我理想的线程c...
Android中UI线程与后台线程交互设计的5种方法
awodefengduanwu的博客
04-13 316
android提供了以下几种方法，用于实现后台线程与UI线程的交互。 1、handler 2、Activity.runOnUIThread(Runnable) 3、View.Post(Runnable) 4、View.PostDelayed(Runnabe,long) 5、AsyncTask 方法一：handler handler是android中专门用来在线程之间传递信息类的工具。 要讲明han...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值