Java多线程

最新推荐文章于 2022-09-18 17:12:01 发布

魏华达

最新推荐文章于 2022-09-18 17:12:01 发布

阅读量272

点赞数

CC 4.0 BY-SA版权

分类专栏： Android

本文链接：https://blog.youkuaiyun.com/a820703048/article/details/86760704

Android 专栏收录该内容

49 篇文章

订阅专栏

1.线程和进程的区别

进程作为拥有资源的基本单位

线程作为调度和分配的基本单位，使用线程能提高cpu的利用率

2.线程的状态

(1)新创建状态（2）可运行状态（3）阻塞状态 (4)等待状态（5）终止状态

3.线程使用方式

（1）一个类继承Thread 重写run方法调用这个类的start()方法

（2）一个类接上runnable接口实现run方法调用start()方法（一般使用）

（3）实现callable接口重写call方法

（4）可以使用interrupt或者 cancel方法来中断或者取消线程

4.线程如何同步

使用synchonized 关键字在方法中或者代码块可以进行同步锁

使用Volatile这个可以保证可见性但是不能保证原子性因为Volatile大概能保存每个线程的变量都从主存中获取一次最新的，但是不能保证原子性比如线程从主存拿出一份出来到自己的临时存储中时候，被中断了，然后被唤醒但是这个时候主存中的变量已经被修改了

Volatile这个关键字用到的地方一个是双层检查的单例模式，单例对象用这个关键字修饰可以保证不会重复创建一个是状态第二个是状态标志，如果这个状态被修改了这个另外一个线程就会停止下来

5.阻塞队列

所谓阻塞队列就是当队列中没有数据的情况下，那么就会消费者的线程被挂起，如果阻塞队列中队列全部满的情况下那么生成线程会被挂起

（1）java中常见的阻塞队列

ArrayBlockingQueue:数组结构有界阻塞队列

LinkBlockingQueue:链表结构有界阻塞队列

PriorityBlockingQueue:支持优先级别排序阻塞队列

SynchronousBlockingQueue:不存储元素的阻塞队列

LinkedBlockingDeque:由链表结构组成双向的阻塞队列

总结：其实阻塞队列就相当于一条水管里面的水，谁来喝水和放水到被管理起来了如果有消费者要喝水那么得先判断有没有水如果有就喝没有就挂起来，生产者相当于判断水有没有满出来如果没有满出来那么加水，如果有那么生产者挂起来，但是如果使用java提供的一些现有上述的线程池那么就会将这些判断管理起来不需要我们自己去判断就很方便

6.线程池

（1）如何使用线程池直接new ThreadPollExecutor 里面有四个参数

（1）核心线程数维护一个合理线程数在运行少了就自动创建

（2）线程池可以创建的线程数

（3）非核心线程闲置超过时间

（4）上（3）的数字类型比如毫秒秒

（5）阻塞队列类型

一般是如果线程池中没有达到核心线程数量那么创建核心线程处理任务，如果线程数大于核心线程数将任务加入任务队列，如果任务队列满了，就会创建非核心线程去处理任务如果线程超过最大线程数那么执行饱和策略

6.线程池的种类

(1) FixedThreadPool 其实就是在Executors这个类中封装了一下，底层就是new了一下ThreadPollExecutor 这个对象传入你的线程数量就是核心和最大都传你的线程数非核心线程闲置超过时间为0秒

（2）CachedThreadPool 其实就是在Executors这个类中封装了一下，底层就是new了一下ThreadPollExecutor 这个对象核心是传0 最大数是无限制最长等待是60秒

（3）singleThreadExecutor其实是核心和最大都传了1 所以能保证所有任务在一个线程中执行

7AsyncTask原理

（1）使用教程

一个类继承 AsyncTask 实现三个抽象方法一个是onPreExecute这个是线程开始前操作一个是doInBackground操作 onPostUpdate操作 onPostExecute（）操作要开启线程就是调用execute方法

（1）最新源码分析

public AsyncTask() {
        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);//最后调用子类的postResult将结果返回回去
                }
                return result;
            }
        }
    }

这个是主线程使用方法调用executeOnExecutor方法

 @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;//参数
        exec.execute(mFuture);//

        return this;
    }

exec.execute(mFuture);相当于执行线程池最终会调用我们最上面提到的call方法最后postResult出去我们将代码沾出来，我们看源码不要纠结于细枝末节这样的话会陷入迷茫之中，我们要走主流程，对于细节可以不太理解，因为可能作者是出于某种考虑但是这种考虑你没有经历过是很难去理解的，所以我们看源码主要是走主流程

  private Result postResult(Result result) {
        @SuppressWarnings("unchecked")
        Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
                new AsyncTaskResult<Result>(this, result));
        message.sendToTarget();
        return result;
    }


 private static Handler getHandler() {
        synchronized (AsyncTask.class) {
            if (sHandler == null) {
                sHandler = new InternalHandler();
            }
            return sHandler;
        }
    }

 private static class InternalHandler extends Handler {
        public InternalHandler() {
            super(Looper.getMainLooper());
        }

        @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
        @Override
        public void handleMessage(Message msg) {
            AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
            switch (msg.what) {
                case MESSAGE_POST_RESULT:
                    // There is only one result
                    result.mTask.finish(result.mData[0]);
                    break;
                case MESSAGE_POST_PROGRESS:
                    result.mTask.onProgressUpdate(result.mData);
                    break;
            }
        }
    }

 private void finish(Result result) {
        if (isCancelled()) {
            onCancelled(result);
        } else {
            onPostExecute(result);
        }
        mStatus = Status.FINISHED;
    }