纯净、安全、绿色的下载网站

首页|软件分类|下载排行|最新软件|IT学院

当前位置:首页IT学院IT技术

Android多线程操作 Android中实现多线程操作的几种方式

哗啦啦啦啦   2021-06-08 我要评论
想了解Android中实现多线程操作的几种方式的相关内容吗哗啦啦啦啦在本文为您仔细讲解Android多线程操作 的相关知识和一些Code实例欢迎阅读和指正我们先划重点:Android多线程操作,Android多线程下面大家一起来学习吧

前言

多线程一直是一个老大难的问题首先因为它难以理解其次在实际工作中我们需要面对的关于线程安全问题也并不常见今天就来总结一下实现多线程的几种方式可能并不全面还请各位看官多多补充

最基础的方式

继承Thread类并实现run()方法

class MyThread extends Thread{
 @Override
 public void run() {
  System.out.println("我是子线程");
 }
}

new MyThread().start();

匿名内部类

public class ManyThread {
 public static void main(String[] args) {
  new Thread(){
   public void run() {
    System.out.println("我是子线程");
   };
  }.start();
 }
}

实现Runnable接口

class MyRunnable implements Runnable{
 @Override
 public void run() {
  System.out.println("我是子线程");
 }
}
Thread thread = new Thread(new MyRunnable());
thread.start();

太简单了吧!!别着急这只是热身~

callable+FutureTask

Callable接口类似于Runnable区别在于使用callable可以拿到结果
FutureTask实现了RunnableFuture

public class FutureTask<V> implements RunnableFuture<V> {
    ...
}

RunnableFuture又实现了Runnable和Future

public interface RunnableFuture<V> extends Runnable, Future<V> {
    /**
     * Sets this Future to the result of its computation
     * unless it has been cancelled.
     */
    void run();
}

所以FutureTask既可以当Runnable使用又可以当Future使用get()来拿到结果

future的API:get():当任务结束后返回一个结果如果调用时任务还没有结束则会阻塞线程直到任务执行完毕可以设置等待时间超出时间或者返回结果为null则抛出异常cancel():

//自定义CallAble并实现call()方法
class MyCallable implements Callable<Integer>{

 @Override
 public Integer call() throws Exception {
  
  int a = 1;
  for (int i = 0; i <100000; i++) {
   a++;
  }
  Thread.sleep(2000);
  return a;
 }
 
}

public static void main(String[] args) {
  
                //新建CallAble
  MyCallable callable = new MyCallable();
                
                //新建FutureTask任务
  FutureTask<Integer> futureTask = new FutureTask<Integer>(callable);
                
                //新建Thread并与FutureTask关联
  Thread thread = new Thread(futureTask, "A");
  thread.start();
  int sum;
  try {
                        //拿到callable的结果
   sum = futureTask.get();
   System.out.println(sum);
  } catch (InterruptedException e) {
   e.printStackTrace();
  } catch (ExecutionException e) {
   e.printStackTrace();
  }
 }

线程池

线程池的创建方式有两种

手动创建线程池

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

要注意线程池的几个参数:

  • corePoolSize :核心线程数
  • maximumPoolSize :允许创建的最大线程数
  • keepAliveTime :这是空闲线程保持存活的最大时间
  • unit : keepAliveTime的时间单位
  • workQueue :任务队列保存等待执行的任务的阻塞队列
  • threadFactory :用于设置创建线程的工厂可以通过线程工厂给每个创建出来的线程设置更有含义的名字
  • handler :饱和策略当队列和线程池都满了说明线程处于饱和状态必须采取一种策略处理提交的新任务默认情况下是AbortPolicy表示无法处理新任务时抛出异常

向线程池提交任务execute()和submit():

ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 2, 1, TimeUnit.SECONDS, new LinkedBlockingDeque<Runnable>());
//使用execute提交任务
threadPoolExecutor.execute(new Runnable() {
    @Override
    public void run() {
 System.out.println("我是线程池");
    }
});

//之前说的callable
MyCallable callable = new MyCallable();
//使用submit提交任务 返回一个future
Future<Integer> future = threadPoolExecutor.submit(callable);
try {
    //通过future拿到执行callable的结果
    int x = future.get();
    System.out.println(x);
} catch (InterruptedException e) {
    //中断异常
    e.printStackTrace();
} catch (ExecutionException e) {
    //无法执行任务异常
    e.printStackTrace();
}finally {
    //关闭线程池
    threadPoolExecutor.shutdown();
}

使用自定义线程池要合理的配置各个参数

  • 根据任务的性质:CPU密集型还是IO密集型设置核心线程数的大小cpu密集型应配置尽可能小的线程可以配置为 CPU个数+1由于IO密集型任务线程并不是一直在执行任务应配置尽可能多的线程可以配置为 2*cpu个数
  • 优先级不同的任务可以使用优先级队列PriorityBlockingQueue来处理它可以让优先级高的任务先执行
  • 建议使用有界队列有界队列能增加系统的稳定性和预警能力

使用Executors创建线程池

这种创建方式本质上也是对ThreadPoolExecutor的参数进行不同的配置每条创建后边把源码中不同的配置放到后边以便更清晰的展示出来

//会根据需要创建新线程的线程池
ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
//核心线程数设置为0最大线程数则是无界的也就是说某些情况下会有无限多的线程被创建从而导致一些问题空闲线程最大等待时长是60秒
public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
}

//使用单个worker线程
ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();
//核心线程数和最大线程数都设置为1并使用无界队列作为线程池的工作队列其容量为无限大某些情况下会导致队列中有太多的任务而出错
public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
}

//可重用固定线程数的线程池
ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(10);
//核心线程数和最大线程数都设置为创建时传入的数量空闲等待时长为0说明空闲线程会立即终止而任务队列容量也是无限大可能会导致同样的问题
public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
}

//可以用来在给定延时后执行异步任务或者周期性执行任务
ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(2);
//核心线程的个数为指定的数量允许的最大线程数是无限的
public ScheduledThreadPoolExecutor(int corePoolSize,
                                   ThreadFactory threadFactory,
                                   RejectedExecutionHandler handler) {
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
          new DelayedWorkQueue(), threadFactory, handler);
}

Android中特有的实现多线程

使用HandlerThread

HandleThread本质上就是一个线程其继承了Thread它的内部有自己的looper对象,并在run方法中通过Looper.prepare()来创建消息队列并通过Looper.loop()开启消息循环这样在使用中就允许在HandlerThread中创建Handler了

HandlerThread和普通的Thread是有显著的区别的普通的Thread主要在run方法中执行一个耗时任务而HandlerThread在内部创建了消息队列外界需要通过Handler的消息方式来通知HandlerThread执行一个具体的任务由于handlerThread的run方法是一个无限循环因此当明确不需要再使用HandlerThread时可以通过其quit或者quitSafely方法来终止线程的执行

public class HandlerThread extends Thread {
    
    Looper mLooper;
    private @Nullable Handler mHandler;

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

具体使用:

        //创建handlerThread标记一个名字
        HandlerThread handlerThread = new HandlerThread("MyHandlerThread");
        //启动线程
        handlerThread.start();

        //创建工作线程的handler关联handlerThread的Looper对象
        //复写handleMessage处理消息
        Handler myHandler = new Handler(handlerThread.getLooper()) {
            @Override
            public void handleMessage(@NonNull Message msg) {

                Log.i(msg.what + msg.obj.toString());
                super.handleMessage(msg);
            }
        };

        //定义消息
        Message msg = new Message();
        msg.what = 1;
        msg.obj = "A";
        //发送消息到其绑定的消息队列中
        myHandler.sendMessage(msg);
        //结束线程停止线程的消息循环
        handlerThread.quit();

使用IntentService

本质上是一个Service,可以看做是Service和HandlerThread的结合体它继承了Service并且是一个抽象类因此需要创建它的子类才能使用IntentService可以用于执行后台耗时任务由于是服务所以它的优先级比单纯的线程要高很多并且不容易被系统杀死有如下几个特点

  • IntentService是继承自service并处理异步请求的一个类其内部有一个工作线程处理耗时请求
  • 任务执行完毕会自动销毁
  • 如果IntentService启动多次每个耗时操作会以队列的方式在IntentService的onHandleIntent方法中依次执行串行执行结束后会自动销毁

首先看一下IntentService的源码:

//继承自service
public abstract class IntentService extends Service {
    private volatile Looper mServiceLooper;
    @UnsupportedAppUsage
    private volatile ServiceHandler mServiceHandler;

    private final class ServiceHandler extends Handler {
        public ServiceHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            //处理消息时调用onHandleIntent方法 我们需要重写这个方法实现自己的处理逻辑
            onHandleIntent((Intent)msg.obj);
            stopSelf(msg.arg1);
        }
    }
    ...
    
    @Override
    public void onCreate() {
        super.onCreate();
        //创建handlerThread并启动
        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
        thread.start();
        mServiceLooper = thread.getLooper();
        //初始化handler并绑定handlerThread的looper
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }
    
    @Override
    public void onStart(@Nullable Intent intent, int startId) {
        Message msg = mServiceHandler.obtainMessage();
        msg.arg1 = startId;
        msg.obj = intent;
        //通过handler发送消息给HandlerThread处理
        mServiceHandler.sendMessage(msg);
    }
    ...

当IntentService被启动时它的onCreate方法被调用onCreate方法会创建一个HandlerThread然后使用它的Looper来构造一个Handler对象这样通过Handler发送的消息最终会在HandlerThread中执行每次启动IntentService它的onStartCommand方法就会调用一次IntentService在onStartCommand中处理每个后台任务的IntnetonStartCommond调用了onStart在onStart方法中IntentService通过handler发送一个消息这个消息会在HandlerThread中处理当onHandleIntent方法执行结束后IntentService会通过stopSelf方法尝试停止服务onHandlerIntent是一个抽象方法需要我们在子类中实现它的作用是从Intent参数中区分具体的任务并执行这些任务

如何使用?

  • 新建service类并继承自IntentService
  • 实现service的构造方法
  • 在manifast.xml中注册服务
  • 在服务的onHandleIntent方法中实现业务逻辑

自定义一个IntentService

public class MyIntentService extends IntentService {

    public MyIntentService(String name) {
        super(name);
    }

    @Override
    protected void onHandleIntent(@Nullable Intent intent) {
        if(intent != null){
            String action = intent.getAction();
            if(action.equals("A")){
                doSomeThingA();
            }else if(action.equals("B")){
                doSomeThingB();
            }
        }
    }
}

JobIntentService/JobScheduler

系统不允许后台应用创建后台服务因此8.0引入了Context.startForegroundService()以在前台启动新服务
由于Android O的后台限制创建后台服务需要使用JobScheduler来由系统进行调度任务的执行而使用JobScheduler的方式比较繁琐8.0及以上提供了JobIntentService帮助开发者更方便的将任务交给JobScheduler调度其本质是Service后台任务在他的OnhandleWork()中进行子类重写该方法即可使用较简单

public class SimpleJobIntentService extends JobIntentService {
    /**
     * 这个Service 唯一的id
     */
    static final int JOB_ID = 1000;

    /**
     * 将工作加入此服务的方法使用中调用这个方法
     */
    static void enqueueWork(Context context, Intent work) {
        enqueueWork(context, SimpleJobIntentService.class, JOB_ID, work);
    }

    //在这里执行耗时任务
    @Override
    protected void onHandleWork(Intent intent) {
        Log.i("SimpleJobIntentService", "Executing work: " + intent);
        String label = intent.getStringExtra("label");
        if (label == null) {
            label = intent.toString();
        }
        toast("Executing: " + label);
        for (int i = 0; i < 5; i++) {
            Log.i("SimpleJobIntentService", "Running service " + (i + 1)
                    + "/5 @ " + SystemClock.elapsedRealtime());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
        }
        Log.i("SimpleJobIntentService", "Completed service @ " + SystemClock.elapsedRealtime());
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        toast("All work complete");
    }

    final Handler mHandler = new Handler();

    // Helper for showing tests
    void toast(final CharSequence text) {
        mHandler.post(new Runnable() {
            @Override public void run() {
                Toast.makeText(SimpleJobIntentService.this, text, Toast.LENGTH_SHORT).show();
            }
        });
    }
}

activity中通过调用enqueueWork()方法来启动

    Intent workIntent = new Intent();
    num++;
    Log.d("houson", "onClick: "+num);
    workIntent.putExtra("work","work num:"+num);
    //调用enqueueWork方法
    MyJobIntentService.enqueueWork(getApplicationContext(),workIntent);

WorkManager

根据需求的不同Android为后台任务提供了多种解决方案如JobSchedulerLoaderService等如果这些API没有被适当地使用可能会消耗大量的电量WorkManager的出现为应用程序中那些不需要及时完成的任务提供统一的解决方案以便在设备电量和用户体验之间达到一个比较好的平衡

WorkManager最低可以兼容API Level 14在API Level 23+通过JobScheduler来完成任务23一下的设备通过AlarmManager和BroadCastReceivers组合完成任务

WorkManager主要针对不需要及时完成的任务如发送日志同步应用程序数据备份等并且可以保证任务一定会被执行即使应用当前不在运行中WorkManager有自己的数据库关于任务的所有信息和数据都保存在这个数据库中因此只要你的任务交给了WorkManager哪怕你的应用程序彻底退出或者设备重新启动WorkManager依然能够保证完成你交给的任务
如何使用?

添加依赖

dependencies {
    def versions = "2.2.0"
    implementation "androidx.work:work-runtime:$versions"
}

定义Worker任务:

worker是任务的执行者是一个抽象类需要继承它实现要执行的任务

//继承worker自定义worker
class MyWork extends Worker{

    public MyWork(@NonNull Context context, @NonNull WorkerParameters workerParams) {
        super(context, workerParams);
    }

    //执行耗时任务
    @NonNull
    @Override
    public Result doWork() {
        //拿到传进来的数据
        String input_data = getInputData().getString("input_data");
        // 任务执行完成后返回数据
        Data outputData = new Data.Builder().putString("output_data", "Success!").build();
//        执行成功返回Result.success()
//        执行失败返回Result.failure()
//        需要重新执行返回Result.retry()
        return Result.success(outputData);
    }
}

使用WorkRequest配置任务

WorkRequest指定让哪个 Woker 执行任务指定执行的环境执行的顺序等要使用它的子类 OneTimeWorkRequest(执行一次) 或 PeriodicWorkRequest(周期执行)
通过WorkRequest配置我们的任务何时运行以及如何运行
 

       //设置任务的触发条件
        Constraints constraints = new Constraints.Builder()
                .setRequiresCharging(true) // 在充电时执行
                .setRequiresStorageNotLow(true) // 不在存储容量不足时执行  
                
                // 网络状态
                //NOT_REQUIRED--没有要求
                //CONNECTED--网络连接
                //UNMETERED--连接无限流量的网络
                //METERED--连接按流量计费的网络
                //NOT_ROAMING--连接非漫游网络
                .setRequiredNetworkType(NetworkType.CONNECTED)
                .setRequiresDeviceIdle(true) // 在待机状态下执行需要 API 23
                .setRequiresBatteryNotLow(true)// 不在电量不足时执行
                .build();
        //然后将该Constraints设置到WorkRequestWorkRequest是一个抽象类
        //它有两种实现OneTimeWorkRequest和PeriodicWorkRequest分别对应的是一次性任务和周期性任务
        //定义要传递的数据
        Data inputData = new Data.Builder().putString("input_data", "Hello").build();
        OneTimeWorkRequest oneTimeWorkRequest = new OneTimeWorkRequest.Builder(MyWork.class)
                .setConstraints(constraints)
                .setInputData(inputData)
                .build();

WorkManager

将任务提交给系统管理任务请求和任务队列发起的 WorkRequest 会进入它的任务队列WorkManager.enqueue()方法会将你配置好的WorkRequest交给系统来执行

WorkManager.getInstance(this).enqueue(oneTimeWorkRequest);

观察任务的状态

任务在提交给系统后通过WorkInfo获知任务的状态WorkInfo包含了任务的idtag以及Worker对象传递过来的outputData以及任务当前的状态有三种方式可以得到WorkInfo对象

通过LiveData我们便可以在任务状态发生变化的时候收到通知同时通过LiveData的WorkInfo.getOutputData()得到从Worker传递过来的数据

WorkManager.getInstance(this).getWorkInfoByIdLiveData(oneTimeWorkRequest.getId()).observe(
                MainActivity.this, new Observer<WorkInfo>() {
                    @Override
                    public void onChanged(WorkInfo workInfo) {
                        Log.d("onChanged()->", "workInfo:"+workInfo);
                        if (workInfo != null && workInfo.getState() == WorkInfo.State.SUCCEEDED) {
                            String outputData = workInfo.getOutputData().getString("output_data");
                            Log.d("onChanged()->", "outputData:"+outputData);
                        }
                    }
                }
        );

取消任务

WorkManager.getInstance(MainActivity.this).cancelAllWork();

以上就是WorkManager的一些基本使用更详细的可以参照官方文档或者其他文章这里就不仔细讲解了工作中我们经常需要处理后台任务如果处理后台任务所采用的API没有被正确使用那么很可能会消耗大量设备的电量Android出于设备电量的考虑为开发者提供了WorkManager旨在将一些不需要及时完成的任务交给它来完成

使用协程

协程是一种并发设计模式您可以在 Android 平台上使用它来简化异步执行的代码协程是轻量级的线程为什么是轻量的?因为它基于线程池API协程可以使用阻塞式的方式写出非阻塞式的代码解决回调地狱的问题

协程有如下的特点:

  • 轻量:您可以在单个线程上运行多个协程因为协程支持挂起不会使正在运行协程的线程阻塞挂起比阻塞节省内存且支持多个并行操作
  • 内存泄漏更少:使用结构化并发机制在一个作用域内执行多项操作
  • 内置取消支持:取消操作会自动在运行中的整个协程层次结构内传播
  • Jetpack 集成:许多 Jetpack 库都包含提供全面协程支持的扩展某些库还提供自己的协程作用域可供您用于结构化并发

引入协程

dependencies {
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.9")
}

使用

 fun main() = runBlocking {
    launch {
        delay(1000L)
        println("World!")
    }
    println("Hello") 
}

协程的使用当然不是这么简单有很多的API这里限于篇幅就不深入讲解了

AsyncTask

是一个轻量级的异步任务类在高版本中已经过时了但研究一下还是很有意义的他可以在线程池中执行后台任务然后把执行的进度和最终结果传递给主线程并在主线程中更新uiAsyncTask封装了Thread和Handler通过AsyncTask可以更加方便的执行后台任务以及在主线程中访问ui

AsyncTask提供了四个核心方法:

  • onPreExecute:在主线程中执行在异步任务执行之前此方法会被调用一般用于一些准备工作
  • doInBackground:在线程池中执行此方法用于执行异步任务params参数表示异步任务的输入参数此方法中可以通过publishProgress来更新任务的进度
  • onProgressUpdata(Progress...values):在主线程中执行当后台任务的执行进度发生改变时调用此方法
  • onPostExecute:在主线程中执行在异步任务执行之后此方法会被调用result参数是后台任务的返回值即doInbackground的返回值

AsyncTask在使用过程中有一些限制条件:

  • AsyncTask必须在主线程中加载也就是第一次访问AsyncTask必须发生在主线程
  • AsyncTask的对象须在主线程中创建
  • execute方法必须在ui线程调用
  • 不要在程序中直接调用onPreExecute、onPostExecute、doInBackground、onProgressUpdate方法
  • 一个AsyncTask对象只能执行一次也就是只能调用一次execute方法否则会报异常

原理分析:

从execute方法开始分析调用executeOnExecutor方法sDefaultExecutor是一个串行的线程池如下:

    @MainThread
    public final AsyncTask<Params, Progress, Result> execute(Params... params) {
        return executeOnExecutor(sDefaultExecutor, params);
    }
    
    
    @MainThread
    public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
            Params... params) {
        if (mStatus != Status.PENDING) {
            switch (mStatus) {
                case RUNNING:
                    throw new IllegalStateException("Cannot execute task:"
                            + " the task is already running.");
                case FINISHED:
                    throw new IllegalStateException("Cannot execute task:"
                            + " the task has already been executed "
                            + "(a task can be executed only once)");
            }
        }

        mStatus = Status.RUNNING;
       
        onPreExecute();

        mWorker.mParams = params;
        //线程池开始执行 封装为Futuretask交个线程池处理
        exec.execute(mFuture);

        return this;
    }

sDefaultExecutor是一个串行线程池,一个进程中所有的AsyncTask任务都在这个线程池中排队执行首先系统会把AsyncTask的Params参数封装为FutureTask对象这里FutureTask充当Runnable接着这个FutureTask会交给SerialExecutor的execute方法处理SerialExecute的execute方法首先把FutureTask对象插入到任务队列中接着调用scheduleNext方法执行FutureTask任务从队列中取出任务交给THREAD_POOL_EXECUTOR线程池去真正执行任务InternalHandler用于将执行环境从线程池切换到主线程

    //串行线程池
    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
    //线程池用于真正执行任务
    public static final Executor THREAD_POOL_EXECUTOR;
    //用于将执行环境从线程池切换到主线程
    private static InternalHandler sHandler;
   
    //初始化执行任务的线程池
    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;
    }
    
    //用于调度任务的串行线程池
    private static class SerialExecutor implements Executor {
        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
        Runnable mActive;

        public synchronized void execute(final Runnable r) {
            mTasks.offer(new Runnable() {
                public void run() {
                    try {
                        r.run();
                    } finally {
                        scheduleNext();
                    }
                }
            });
            if (mActive == null) {
                scheduleNext();
            }
        }

        protected synchronized void scheduleNext() {
            
            //从队列中取出任务交个THREAD_POOL_EXECUTOR线程池去真正执行任务
            if ((mActive = mTasks.poll()) != null) {
                THREAD_POOL_EXECUTOR.execute(mActive);
            }
        }
    }

再看一下任务futurecall方法中调用postResult方法通过handler发送消息最终在handleMessage方法中进行处理

    private final WorkerRunnable<Params, Result> mWorker;
    private final FutureTask<Result> mFuture;
     mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
                mTaskInvoked.set(true);
                Result result = null;
                try {
                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                    //noinspection unchecked
                    result = doInBackground(mParams);
                    Binder.flushPendingCommands();
                } catch (Throwable tr) {
                    mCancelled.set(true);
                    throw tr;
                } finally {
                    postResult(result);
                }
                return result;
            }
        };

        mFuture = new FutureTask<Result>(mWorker) {
            @Override
            protected void done() {
                try {
                    postResultIfNotInvoked(get());
                } catch (InterruptedException e) {
                    android.util.Log.w(LOG_TAG, e);
                } catch (ExecutionException e) {
                    throw new RuntimeException("An error occurred while executing doInBackground()",
                            e.getCause());
                } catch (CancellationException e) {
                    postResultIfNotInvoked(null);
                }
            }
        };

结语

以上介绍了几种实现多线程操作的方式有些并没有深入分析当然了实现多线程的方式不止以上的几种还请各位看官多多补充如有错误的地方还请指出


相关文章

猜您喜欢

  • vue引入iconfont vue引入iconfont图标库的优雅实战记录

    想了解vue引入iconfont图标库的优雅实战记录的相关内容吗Kay_在本文为您仔细讲解vue引入iconfont的相关知识和一些Code实例欢迎阅读和指正我们先划重点:vue引入iconfont,vue引入iconfont.js,vue引入第三方js文件下面大家一起来学习吧..
  • go处理表单输入 go web 处理表单的输入的说明

    想了解go web 处理表单的输入的说明的相关内容吗chengqiuming在本文为您仔细讲解go处理表单输入的相关知识和一些Code实例欢迎阅读和指正我们先划重点:go处理表单输入,go表单输入下面大家一起来学习吧..

网友评论

Copyright 2020 www.fresh-weather.com 【世纪下载站】 版权所有 软件发布

声明:所有软件和文章来自软件开发商或者作者 如有异议 请与本站联系 点此查看联系方式