（四） 结合AsyncTask探讨static在Android中的作用域

最新推荐文章于 2024-02-29 10:54:02 发布
最新推荐文章于 2024-02-29 10:54:02 发布
阅读量487 收藏
点赞数
分类专栏： Android 文章标签： AsyncTask static
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_20059415/article/details/79331663
版权
前言：大家新年快乐哈，今天在老家，只有笔记本，各种装备都没带上，就把之前写的博客的细节拿出来特意总结下。主要是就 （三）AsyncTask中所述的静态SerialExecutor和静态的默认线程池讨论一下static变量在Android中的作用域。

1.AsyncTask静态变量作用

首先回顾一下之前博客中说的以下这两个变量。源码如下：
  1. private static class SerialExecutor implements Executor {  
  2.         final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();  
  3.         Runnable mActive;  
  4.   
  5.         public synchronized void execute(final Runnable r) {  
  6.             mTasks.offer(new Runnable() {  
  7.                 public void run() {  
  8.                     try {  
  9.                         r.run();  
  10.                     } finally {  
  11.                         scheduleNext();  
  12.                     }  
  13.                 }  
  14.             });  
  15.             if (mActive == null) {  
  16.                 scheduleNext();  
  17.             }  
  18.         }  
  19.   
  20.         protected synchronized void scheduleNext() {  
  21.             if ((mActive = mTasks.poll()) != null) {  
  22.                 THREAD_POOL_EXECUTOR.execute(mActive);  
  23.             }  
  24.         }  
  25.     }  
private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));  
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;  
private static final int KEEP_ALIVE_SECONDS = 30;  
static {  
    ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(  
            CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,  
            sPoolWorkQueue, sThreadFactory);  
    threadPoolExecutor.allowCoreThreadTimeOut(true);  
    THREAD_POOL_EXECUTOR = threadPoolExecutor;  
}

SerialExecutor和threadPoolExecutor都被声明为static类型的变量，SerialExecutor主要负责的工作将陆续来的AsyncTask调用存储起来，等上一个任务做完就将接下来的任务取出来给threadPoolExecutor来执行，这也是AsyncTask默认执行方式是串行的原因。


2.讨论一下static变量的作用域

我之前我做了三次这样的探讨，分别如下，主要代码和之前一样。

  1. 一个activity中
  2. 同一Application中的两个activity中
  3. 两个Application中

package com.example.asynctasktest;  
  
import android.os.AsyncTask;  
import android.support.v7.app.AppCompatActivity;  
import android.os.Bundle;  
import android.widget.ProgressBar;  
import android.widget.TextView;  
  
public class MainActivity extends AppCompatActivity {  
    ProgressBar progressBar;  
    TextView txView;  
    @Override  
    protected void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
        progressBar = findViewById(R.id.progressBar);  
        txView = findViewById(R.id.textView);  
        new Task.execute((Object)null);  
  
    }  
  
    class Task extends AsyncTask<Object,Integer,Object>{  
        @Override  
        protected void onPostExecute(Object o) {  
            super.onPostExecute(o);  
            txView.setText("end");  
        }  
  
        @Override  
        protected Object doInBackground(Object[] objects) {  
            for(int i = 0; i <= 100; i++){  
                try {  
                    Thread.sleep(200);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
                publishProgress(i);  
            }  
            return null;  
        }  
  
        @Override  
        protected void onProgressUpdate(Integer[] values) {  
            super.onProgressUpdate(values);  
            progressBar.setProgress(values[0]);  
            txView.setText(values[0] + "%");  
        }  
  
        @Override  
        protected void onPreExecute() {  
            super.onPreExecute();  
            txView.setText("begin");  
            try {  
                Thread.sleep(500);  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
    }  
}

上面的代码很简单，就是简单的执行一下任务就更新一下进度条。


2.1 一个activity中

        new Task().execute(1);
        new Task().execute(2);
        new Task().execute(3);
02-10 17:30:59.675 22003-22003/com.example.asynctasktest D/asyncTest: begin
02-10 17:30:59.676 22003-22003/com.example.asynctasktest D/asyncTest: begin
02-10 17:30:59.676 22003-22003/com.example.asynctasktest D/asyncTest: begin
02-10 17:30:59.678 22003-22078/com.example.asynctasktest D/asyncTest: 1
02-10 17:31:20.092 22003-22714/com.example.asynctasktest D/asyncTest: 2
02-10 17:31:20.112 22003-22003/com.example.asynctasktest D/asyncTest: end
02-10 17:31:40.404 22003-22720/com.example.asynctasktest D/asyncTest: 3
02-10 17:31:40.410 22003-22003/com.example.asynctasktest D/asyncTest: end
02-10 17:32:00.728 22003-22003/com.example.asynctasktest D/asyncTest: end

以之前的代码为模板，多次执行异步任务，从log可以看出20s执行一个任务，依次执行，将三个任务执行完。

从以上结论可以推论出：一个activity中多个AsyncTask共享同一个static变量SerialExecutor和threadPoolExecutor。


2.2 同一Application中的两个activity中

为了这个猜想，我以最初的activity为模板复制了一份，让这第一个activity启动的时候，将它的模板也带起来，log对应于AsyncTest2 
02-10 17:57:04.016 31010-31080/com.example.asynctasktest2222 D/asyncTest: begin  
02-10 17:57:04.016 31010-31080/com.example.asynctasktest2222 D/asyncTest: 1  
02-10 17:57:24.307 31010-31080/com.example.asynctasktest2222 D/asyncTest: end  
02-10 17:57:24.310 31010-31538/com.example.asynctasktest2222 D/asyncTest: begin  
02-10 17:57:24.310 31010-31538/com.example.asynctasktest2222 D/asyncTest: 2  
02-10 17:57:44.573 31010-31538/com.example.asynctasktest2222 D/asyncTest: end  
02-10 17:57:44.575 31010-31546/com.example.asynctasktest2222 D/asyncTest: begin  
02-10 17:57:44.575 31010-31546/com.example.asynctasktest2222 D/asyncTest: 3  
02-10 17:58:04.857 31010-31546/com.example.asynctasktest2222 D/asyncTest: end  
02-10 17:58:04.859 31010-31664/com.example.asynctasktest2222 D/asyncTest2: begin  
02-10 17:58:04.859 31010-31664/com.example.asynctasktest2222 D/asyncTest2: 1  
02-10 17:58:25.168 31010-31664/com.example.asynctasktest2222 D/asyncTest2: end  
02-10 17:58:25.170 31010-31676/com.example.asynctasktest2222 D/asyncTest2: begin  
02-10 17:58:25.171 31010-31676/com.example.asynctasktest2222 D/asyncTest2: 2  
02-10 17:58:45.487 31010-31676/com.example.asynctasktest2222 D/asyncTest2: end  
02-10 17:58:45.488 31010-31682/com.example.asynctasktest2222 D/asyncTest2: begin  
02-10 17:58:45.488 31010-31682/com.example.asynctasktest2222 D/asyncTest2: 3  
02-10 17:59:05.799 31010-31682/com.example.asynctasktest2222 D/asyncTest2: end

从以上log可以发现第二个activity是在第一个activity的任务依次执行完后再依次执行的。

从以上结论可以推论出：一个application中不同的activity的多个AsyncTask共享同一个static变量SerialExecutor和threadPoolExecutor。


2.3 两个application中

为了这个猜想，我复制了初始的activity，改了一下包名，使之有两个逻辑一样但是两个application的存在。包名为com.example.aysnctasktest2222就是第二个包了。

02-10 17:46:52.274 27250-27269/com.example.asynctasktest D/asyncTest: begin  
02-10 17:46:52.274 27250-27269/com.example.asynctasktest D/asyncTest: 1  
02-10 17:46:53.735 27281-27300/com.example.asynctasktest2222 D/asyncTest: begin  
02-10 17:46:53.735 27281-27300/com.example.asynctasktest2222 D/asyncTest: 1  
02-10 17:47:12.555 27250-27269/com.example.asynctasktest D/asyncTest: end  
02-10 17:47:12.557 27250-27320/com.example.asynctasktest D/asyncTest: begin  
02-10 17:47:12.557 27250-27320/com.example.asynctasktest D/asyncTest: 2  
02-10 17:47:14.026 27281-27300/com.example.asynctasktest2222 D/asyncTest: end  
02-10 17:47:14.027 27281-27321/com.example.asynctasktest2222 D/asyncTest: begin  
02-10 17:47:14.028 27281-27321/com.example.asynctasktest2222 D/asyncTest: 2  
02-10 17:47:32.829 27250-27320/com.example.asynctasktest D/asyncTest: end  
02-10 17:47:32.831 27250-27326/com.example.asynctasktest D/asyncTest: begin  
02-10 17:47:32.831 27250-27326/com.example.asynctasktest D/asyncTest: 3  
02-10 17:47:34.337 27281-27321/com.example.asynctasktest2222 D/asyncTest: end  
02-10 17:47:34.339 27281-27327/com.example.asynctasktest2222 D/asyncTest: begin  
02-10 17:47:34.339 27281-27327/com.example.asynctasktest2222 D/asyncTest: 3  
02-10 17:47:53.097 27250-27326/com.example.asynctasktest D/asyncTest: end  
02-10 17:47:54.658 27281-27327/com.example.asynctasktest2222 D/asyncTest: end

从上面的log可以看出这两个应用的任务执行互不影响，为并行执行。

从以上结论可以推论出：两个application中activity的多个AsyncTask并不共享同一个static变量SerialExecutor和threadPoolExecutor。


2.4 总结

static变量可以在同一个application中共享，不能在不同的application中共享。（其实还可以探讨Service、Fragment之类的共享行为，这样才更有说服力）


3.探讨结论的正确性

1）我先在网上搜了下static变量的基础，如下：

static

 1. static变量
    按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。
两者的区别是： 
　 对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），
当然也可以通过对象来访问（但是这是不推荐的）。对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响
（灵活）。
 
2. static代码块
    static代码块是类加载时，初始化自动执行的。如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。
 
3. static方法
    static方法可以直接通过类名调用，任何的实例也都可以调用，因此static方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法
(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。
    static方法只能访问static的变量和方法，因为非static的变量和方法是需要创建一个对象才能访问的，而static的变量/方法不需要创建任何对象。
 
********
static的数据或方法，属于整个类的而不是属于某个对象的，是不会和类的任何对象实例联系到一起。所以子类和父类之间可以存在同名的static方法名，这里不涉及重载。所以不能把任何方法体内的变量声明为static，例如：
fun() {
   static int i=0; //非法。
}
其实理解static是只有一个存储地方，而使用时直接使用，不需要创建对象，就能明白以上的注意事项。
 
另外，一般的类是没有static的，只有内部类可以加上static来表示嵌套类。

我其实对进程线程以及它们所携带的存储堆栈什么的一直没搞清楚，这里先有个猜想。每个进程有自己的存储仓库，是分别独立的，static就存储在各个进程的存储仓库里，由于进程是互相独立的（好像是数据安全考虑），所以static应该也是互相独立的。

2）下面我还找到一个相关的：

在Android开发中，我们经常会使用到static来修饰我们的成员变量，其本意是为了让多个对象共用一份空间，
节省内存,或者是使用单例模式，让该类只生产一个实例而在整个app中使用。然而在某些时候不恰当的使用或者
是编程的不规范却会造成了内存泄露现象(java上的内存泄漏指内存得不到gc的及时回收，从而造成内存占用过多的现象)
这里直接是以结论的形式给出，static变量由整个app共享，并没有说具体原因。

3）下面找到的也是证明static是由进程所共享的例子。

点击打开链接

当窗口消毁时，Activity的静态变量是存在的，因为静态变量是属全局变量、静态变量是整个应用程序的公共变量（即使上面写的是私有），所以Activity消毁时，静态变量是不会清除的。但当什么时候才会清除呢，

重写onDestory方法，在onDestory里添加android.os.Process.killProcess(android.os.Process.myPid());把线程干掉，再次调用就正常了。



上面说过静态变量是整个应用程序的，所以只有当各个应用程序的进程消毁时，静态变量才会毁，所以调用android.os.Process.killProcess(android.os.Process.myPid());就正常了。

算了，找不到直接探讨这个问题的。结论结合实验大致是正确的，暂且先这样认为吧。。。


4. 总结

static变量可以在同一个application中共享，不能在不同的application中共享。

本文主要还是从实际测试角度解释这个问题，没有真正从理论层面解释，待后续有更深理解后补充。

i加加
关注
专栏目录
Android —— 静态AsyncTask解决内存泄漏
womengmengyan的博客
08-25 1万+
Android中我们经常需要开启子线程去获取网络数据，或者说做一些耗时操作，开发者经常使用的就是AsyncTask,Android 1.5提供的工具类AsyncTask使我们创建异步线程更加便捷。如果你还没有AsyncTask的基础，那么先阅读一下这篇博文吧。 Android多线程编程(异步通信)—>Handler和AsyncTask本博文编写的理由： 线程的关闭，可以通过在activity的d
Android 中使用 AsyncTask 异步读取网络图片
09-02
在本文中，我们将深入探讨如何使用`AsyncTask`来实现异步读取网络图片。 首先，我们创建一个新的Android项目，并在`activity_main.xml`布局文件中设置一个`GridView`，用于展示加载的网络图片。`GridView`通常用来...
《Android程序设计》一2.3 作用域
weixin_33804990的博客
08-02 143
2.3 作用域 作用域决定了程序中的变量、方法和其他符号的可见范围。任何符号在其作用域外都是完全不可见的，不能被使用。在这一节我们将简要地介绍作用域的主要内容，从最高层开始。 2.3.1 Java包 Java包提供了一种机制，它把相关类型分组到一个全局唯一的命名空间。这种分组机制可以防止在一个包的命名空间内的标识符和其他开发人员在其他命名空间内创建和使用...
Be Careful With Static Stuff on AsyncTask
zhjp4295216的专栏
02-29 948
http://commonsware.com/blog/2012/01/24/be-careful-asynctask.html I was writing a sample app to run on the WIMM One wearable Android device, and I ran into a strange error. The flow was: Run
异步AsyncTask的使用与原理分析
weixin_41205419的博客
04-04 569
在Android中，我们更新UI的操作必须要在主线程（UI线程）中进行，而下载图片、文件这种操作必须要在子线程中进行，Android为我们提供了Handler机制，实现了子线程与主线程之间的通信。通常做法就是先new出一个子线程Thread，在子线程中完成下载操作后，通过handler发送一条Message给主线程，主线程收到消息后，就可以进行UI的更新工作了，如下：Handler mHadler...
AsyncTask基础（笔记）
逆风的方向 更适合飞翔
04-13 2250
安卓异步任务 ---AsyncTask 为什么要异步任务： 1.Android单线程模型 2.耗时操作放在非主线程中执行 AsyncTask为何而生 1.子线程中更新UI 2.封装，简化异步操作 构造AsyncTask子类的参数 AsyncTask是一个抽象类，通常用于被继承，继承AsyncTask需要指定如下三个泛型参数： Params: 启动任务时输入的参数的
Android中AsyncTask异步任务使用详细实例(一)
09-02
在Android开发中，AsyncTask是一种常用的轻量级异步处理工具，尤其适用于那些需要在后台执行但需要更新UI的任务。AsyncTask允许开发者在后台线程执行耗时操作，如网络请求或数据库操作，同时能够安全地在UI线程中...
Android中异步类AsyncTask用法总结
01-04
本文总结分析了Android中异步类AsyncTask用法。分享给大家供大家参考，具体如下： 最近整理笔记的时候，看到有关AsyncTask不是很理解，重新疏导了一下，有在网上找了一些资料，个人不敢独享，一并发在这里与大家共勉...
在Android中使用AsyncTask下载多个文件
04-03
在Android开发中，有时我们需要实现从网络下载多个文件的功能，比如更新应用的资源或提供离线阅读的内容。本文将深入探讨如何使用`AsyncTask`、`ProgressBar`和`Notification`来实现这一目标。 首先，`AsyncTask`是...
Android实战技巧：深入解析AsyncTask
热门推荐
稀有猿诉
09-16 10万+
AsyncTask的介绍及基本使用方法 关于AsyncTask的介绍和基本使用方法可以参考官方文档和Android实战技巧：多线程AsyncTask这里就不重复。 AsyncTask引发的一个问题 上周遇到了一个极其诡异的问题，一个小功能从网络上下载一个图片，然后放到ImageView中，是用AsyncTask来实现的，本身逻辑也很简单，仅是在doInBackground中用HTTP请求把图
异步编程Task、Async、await
weixin_37648525的博客
03-11 778
异步编程Task、Async、await 自从C# 5.0时代引入async和await关键字后，异步编程就变得流行起来。尤其在现在的.NET Core时代，我们的代码中更是充斥着async、Task和await关键字。这种异步编程的方式无侵入式的，和同步的代码的写法没什么区别，不用我们像以前一样用Thread去开启子线程。 使用异步编程的方式，在执行一些如数据库操作、IO操作、Http调用这些耗时操作时，能够提高我们代码的性能，它能够更好的调用机器的CPU、IO寄存器等硬件同时工作，而不用阻塞整个应用程序
第十五节：深入理解async和await的作用及各种适用场景和用法
sinolover的专栏
02-29 1560
一. 同步VS异步 1. 同步 VS 异步 VS 多线程 同步方法：调用时需要等待返回结果，才可以继续往下执行业务 异步方法：调用时无须等待返回结果，可以继续往下执行业务 开启新线程：在主线程之外开启一个新的线程去执行业务 同步方法和异步方法的本质区别：调用时是否需要等待返回结果才能继续执行业务 2. 常见的异步方法（都以Async结尾） 　　① HttpClient类：Pos...
在 C# 中使用 async、await、Task 进行异步编程
allway2的博客
02-26 3787
C# 和 .NET Framework（4.5 和核心）支持使用一些本机函数、类和保留关键字的异步编程。 在我们了解什么是异步编程之前，让我们通过下面的控制台示例来了解什么是同步编程。 示例：异步程序 Copy static void Main(string[] args) { LongProcess(); ShortProcess(); } static void LongProcess() { Console.WriteLine("Lo.
Spring @Async使用方法总结
weixin_42073629的博客
07-04 453
在Java应用中，绝大多数情况下都是通过同步的方式来实现交互处理的；但是在处理与第三方系统交互的时候，容易造成响应迟缓的情况，之前大部分都是使用多线程来完成此类任务，其实，在spring3.x之后，就已经内置了@Async来完美解决这个问题，本文将完成介绍@Async的用法。 1. 何为异步调用？ 在解释异步调用之前，我们先来看同步调用的定义；同步就是整个处理过程顺序执行，当各个过程都执行完毕，并返回结果。 异步调用则是只是发送了调用的指令，调用者无需等待被调用的方法完全执行完毕；而是继续执...
C# 中的Async 和 Await 的用法详解
weixin_41883890的博客
07-31 1万+
在这里，我们使用异步编程从文件中读取所有内容，所以它不会等待从这个方法获得一个返回值并执行其他代码行，但是它必须等待下面给出的代码行，因为我们使用的是等待关键字，我们将对下面给出的代码行使用返回值。我们将创建一个新的方法，作为CallMethod，在这个方法中，我们将调用我们的所有方法，分别为Method1、Method2和Method3。在这里，在传递Method3中的参数之前，我们必须使用AWAIT关键字，为此，我们必须使用调用方法中的async关键字。在这种情况下，异步编程将非常有用。...
c# 任务（Task）以及异步 await(等待) 、Async（异步）
最新发布
baidu_16370559的博客
02-29 4103
Task出现之前，微软的多线程处理方式有：Thread→ThreadPool→委托的异步调用，虽然也可以基本业务需要的多线程场景，但它们在多个线程的等待处理方面、资源占用方面、线程延续和阻塞方面、线程的取消方面等都显得比较笨拙，ThreadPool相比Thread来说具备了很多优势，但是ThreadPool却又存在一些使用上的不方便。Task.WhenAny(tasks.ToArray()).ContinueWith(x => Console.WriteLine("某个Task执行完毕"));
c#中async、await的几个注意点
DHZYKN
03-22 2224
1.先举例说明异步方法的执行顺序 class Program { static void Main(string[] args) { Console.WriteLine($"线程Id: '{Thread.CurrentThread.ManagedThreadId}' 主线程开始"); Async(); ...
C#5.0特性之 async异步方法
zhulongxi的博客
09-03 2319
//1.方法用async关键字修饰 //2.返回值只能是void,Task,或Task //3.方法以Async为后缀 public static async Task AccessTheWebAsync() { HttpClient client = new HttpClient();
AsyncTask在Android中的问题与替代方案剖析
尽管AsyncTask在简化开发过程中起着重要作用，但它并非完美，存在一些潜在问题。 首先，关于AsyncTask的生命周期，很多人错误地认为它随Activity的销毁而终止，但实际上，AsyncTask的doInBackground()方法会在后台...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值