Thread和handler，线程，线程池

最新推荐文章于 2022-07-28 09:17:42 发布

置顶刘_海洋

最新推荐文章于 2022-07-28 09:17:42 发布

阅读量2k

点赞数

分类专栏： android 文章标签：线程 Thread

本文链接：https://blog.csdn.net/haiyang497661292/article/details/52918736

版权

android 专栏收录该内容

68 篇文章 0 订阅

订阅专栏

线程Thread

1，线程使用中有两种将使用线程关闭的方法 a.加标志位，b, Thread.interrupt();

2，标志位例子：设置仪表标志位，通过set放发外界进行停止线程中的循环

class MyThread extends Thread{

        private volatile boolean isStop = false;

        @Override

        public void run() {

            int i = 0;

            while(!isStop){

                i++;

            }

        }
        

        public void setStop(boolean stop){

            this.isStop = stop;

        }

    }

Thread.interrupt(); Thread=null;虽然能中断线程但是不能中断线程中已经执行的线程，可以在已经执行的线程中判断一下 isInterrupted()线程是否被终止

Thread.sleep(1000);是让正在执行的线程休眠 Thread mThread=Thread.currentThread();当前线程

异常法停止线程

myThread.setPriority(1);线程优先级，线程的优先级用1-10之间的整数表示，数值越大优先级越高，默认的优先级为5。

在线程调用的外部方法，为了线程安全，调用的方法应该使用同步关键字synchroinzed

线程间通信

1,Handler消息

2,共享内存（全局变量）

3，管道流（PipOutP）

4，Broadcast Receiver

5，EventBus

6，runOnUiThread()，view.post()

7，AsyncTask

sleep和wait的区别有：

1，这两个方法来自不同的类分别是Thread和Object
2，最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
3，wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在
任何地方使用
synchronized(x){
x.notify()
//或者wait()
}
4,sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常
sleep指线程被调用时，占着CPU不工作，形象地说明为“占着CPU睡觉”，此时，系统的CPU部分资源被占用，其他线程无法进入，会增加时间限制。
wait指线程处于进入等待状态，形象地说明为“等待使用CPU”，此时线程不占用任何资源，不增加时间限制。

wait()方法表示，放弃当前对资源的占有权，等啊等啊，一直等到有人通知我，我才会运行后面的代码。
notify()方法表示，当前的线程已经放弃对资源的占有，
通知等待的线程来获得对资源的占有权，但是只有一个线程能够从wait状态中恢复，
然后继续运行wait()后面的语句；
notifyAll()方法表示，当前的线程已经放弃对资源的占有，
通知所有的等待线程从wait()方法后的语句开始运行。

与handler有关

handler机制就是android消息机制

主线程不能执行耗时操作（避免ANR）
子线程不能直接更新UI界面

主线程，ActivityThread被创建的时候就会创建Looper
Looper被创建的时候创建MessageQueue。
也就是说主线程会直接或简介创建出来Looper和MessageQueue。

注意：我们常常用Handler来更新UI，但是不是说Handler就是把用来更新UI的，我们的耗时的I/O操作，读取文件，访问网络等等都是可以在Handler里面操作的

Looper是一个轮询器，它的作用不断轮询MessageQueue，当如果有新的消息就交给Handler处理，如果轮询不到新的消息，那就自身就处于阻塞状态。

new Handler的hanlder不能没有Looper（在主线程默认就有loop，所以每次new不需要获取主线程loop）

Handler主要工作

主要工作：消息的发送 send和 处理handerMessage。

New Handler必须有loop,没有loop就要使用Looper.prepare()方法生成handler，使用hander发送message到消息队列，接着调用Looper.loop()不断遍历消息队列,拿主线程来说，主线程启动时会调用Looper.prepare()方法，会初始化一个Looper，放入Threadlocal中，接着调用Looper.loop()不断遍历Message Queue，

Handler的创建依赖与当前线程中的Looper，如果当前线程没有Looper则必须调用Looper.prepare()。Handler , sendMessage到MessageQueue，Looper不断

从MessageQueue中取出消息，回调handleMessage方法。

处理Handler的内存泄漏

1，弱引用

private NoLeakHandler mHandler;

@Override protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

mHandler = new NoLeakHandler(this);

Message message = Message.obtain();

mHandler.sendMessageDelayed(message,10*60*1000); }

private static class NoLeakHandler extends Handler{

private WeakReference<NoLeakActivity> mActivity;

public NoLeakHandler(NoLeakActivity activity){ mActivity = new WeakReference<>(activity); }

@Override public void handleMessage(Message msg) {

super.handleMessage(msg); }

}

2，页面销毁的时候调用

if (mHandler != null) mHandler.removeCallbacksAndMessages(null);
或者：
mhandler.removeCallbacks(runnable);
mhandler=null;

可以释放将要执行的，但是已经执行的，比如延时需要在操作里面判空处理。

如何更新UI才能不出异常呢？SDK告诉我们，有以下4种方式可以从其它线程访问UI线程：

· Activity.runOnUiThread(Runnable)

· View.post(Runnable)

· View.postDelayed(Runnable, long)

· Handler

(1)安排消息或Runnable 在某个主线程中某个地方执行；

(2)安排一个动作在不同的线程中执行。

Handler中分发消息的一些方法

post(Runnable)

postAtTime(Runnable，long)

postDelayed(Runnable long)

sendEmptyMessage(int)

sendMessage(Message)

sendMessageAtTime(Message，long)

sendMessageDelayed(Message，long)

以上post类方法允许你排列一个Runnable对象到主线程队列中，

sendMessage类方法，允许你安排一个带数据的Message对象到队列中，等待更新。

　　Handler主要有两种用途：

　　1.合理调度安排消息和runnable对象，使它们在将来的某个点被执行。

　　2.将一个动作入队安排在非当前线程执行。

Message：消息，其中包含了消息ID，消息处理对象以及处理的数据等，由MessageQueue统一列队，终由Handler处理。

Handler：处理者，负责Message的发送及处理。使用Handler时，需要实现handleMessage(Message msg)方法来对特定的Message进行处理，例如更新UI等。

MessageQueue：消息队列，用来存放Handler发送过来的消息，并按照FIFO规则执行。当然，存放Message并非实际意义的保存，而是将Message以链表的方式串联起来的，等待Looper的抽取。

Looper：消息泵，不断地从MessageQueue中抽取Message执行。因此，一个MessageQueue需要一个Looper。

Thread：线程，负责调度整个消息循环，即消息循环的执行场所。

· Handler的处理过程运行在创建Handler的线程里

· 一个Looper对应一个MessageQueue

· 一个线程对应一个Looper

· 一个Looper可以对应多个Handler

· 不确定当前线程时，更新UI时尽量调用post方法

private Handler mHandler = new Handler(new Handler.Callback() {
    @Override
    public boolean handleMessage(Message msg) {
        switch (msg.what) {
            case 1:
                     break;
          
        }
        mItemId = -1;
        return true;
    }
});

线程池

2.使用线程池的好处

1.重用已经创建的好的线程，避免频繁创建进而导致的频繁GC

2.控制线程并发数，合理使用系统资源，提高应用性能

3.可以有效的控制线程的执行，比如定时执行，取消执行等

Java代码

public ThreadPoolExecutor(int corePoolSize,  
                              int maximumPoolSize,  
                              long keepAliveTime,  
                              TimeUnit unit,  
                              BlockingQueue<Runnable> workQueue,  
                              ThreadFactory threadFactory,  
                              RejectedExecutionHandler handler) {  
        if (corePoolSize < 0 ||  
            maximumPoolSize <= 0 ||  
            maximumPoolSize < corePoolSize ||  
            keepAliveTime < 0)  
            throw new IllegalArgumentException();  
        if (workQueue == null || threadFactory == null || handler == null)  
            throw new NullPointerException();  
        this.corePoolSize = corePoolSize;  
        this.maximumPoolSize = maximumPoolSize;  
        this.workQueue = workQueue;  
        this.keepAliveTime = unit.toNanos(keepAliveTime);  
        this.threadFactory = threadFactory;  
        this.handler = handler;  
    }

构造方法参数讲解

参数名	作用
corePoolSize	核心线程池大小
maximumPoolSize	最大线程池大小
keepAliveTime	线程池中超过corePoolSize数目的空闲线程最大存活时间；可以allowCoreThreadTimeOut(true)使得核心线程有效时间
TimeUnit	keepAliveTime时间单位
workQueue	阻塞任务队列
threadFactory	新建线程工厂
RejectedExecutionHandler	当提交任务数超过maxmumPoolSize+workQueue之和时，任务会交给RejectedExecutionHandler来处理

重点讲解：
其中比较容易让人误解的是：corePoolSize，maximumPoolSize，workQueue之间关系。

1.当线程池小于corePoolSize时，新提交任务将创建一个新线程执行任务，即使此时线程池中存在空闲线程。
2.当线程池达到corePoolSize时，新提交任务将被放入workQueue中，等待线程池中任务调度执行
3.当workQueue已满，且maximumPoolSize>corePoolSize时，新提交任务会创建新线程执行任务
4.当提交任务数超过maximumPoolSize时，新提交任务由RejectedExecutionHandler处理
5.当线程池中超过corePoolSize线程，空闲时间达到keepAliveTime时，关闭空闲线程
6.当设置allowCoreThreadTimeOut(true)时，线程池中corePoolSize线程空闲时间达到keepAliveTime也将关闭

线程管理机制图示：

总结：

随着任务数量的增加，会增加活跃的线程数。

当活跃的线程数 = 核心线程数，此时不再增加活跃线程数，而是往任务队列里堆积。

当任务队列堆满了，随着任务数量的增加，会在核心线程数的基础上加开线程。

直到活跃线程数 = 最大线程数，就不能增加线程了。

如果此时任务还在增加，则：任务数 > 最大线程数 + 队列长度，抛出异常RejectedExecutionException，拒绝任务。

Java通过Executors提供四种线程池，分别为：

newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

4.FixedThreadPool

FixedThreadPool是一个核心线程数量固定的线程池，创建方式如下：

Thread和handler，线程，线程池

线程Thread

异常法停止线程

线程间通信

sleep和wait的区别有：

与handler有关

new Handler的hanlder不能没有Looper（在主线程默认就有loop，所以每次new不需要获取主线程loop）

Handler主要工作

处理Handler的内存泄漏

1，弱引用

2，页面销毁的时候调用

线程池

2.使用线程池的好处

Java通过Executors提供四种线程池，分别为：

4.FixedThreadPool

5.SingleThreadExecutor

6.CachedThreadPool

7.ScheduledThreadPool

8.线程池其他常用功能

线程池的关闭

线程造成的内存泄漏处理

自定义线程池管理

Timer定时器

取消定时器

线程同步

ThreadLocal

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