android开发中的多线程与线程池

1  多线程的意义

（1）提高用户体验或者避免ANR(Application is not responding)

（2）异步

       在应用程序中，有些情况下并不一定需要同步阻塞去等待返回结果，可以通过多线程来实现异步，如异步加载云端图片

2  多线程的创建

（1）继承Thread类实现多线程

通过继承Thread类不能用一个实例创建多个线程，一般不能资源共享，但是也可以共享Thread类是static变量

（2）实现Runnable接口方式实现多线程

     调用Thread类创建线程时，可以使用同一个Runnable实例，则创建的多线程对象也是共享的，所以实现Runnable接口适合于资源共享

3  线程池的应用

（1）new Thread的弊端

       a）每次new Thread新建对象性能差

       b）线程缺乏统一管理，可能无限制新建线程，相互竞争，可能占用过多系统资源导致死机或内存溢出oom

       c）缺乏更多功能，如定时执行、定期执行、线程中断

（2）线程池好处

        a）重用存在的线程，减少对象创建、消亡的开销，性能佳

        b）可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞

        c）提供定时执行、定期执行、单线程、并发数控制等功能

4． 线程池实现方式

（1）newCachedThreadPool

     创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

（2）newFixedThreadPool

     创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

（3）newSingleThreadPool

     创建一个单线程化的线程池，只会用唯一的工作线程来执行任务，保证所有任务按照指定的顺序（FIFO LIFO 优先级）执行。

（4）newScheduledThreadPool

     创建一个定长线程池，支持定时、周期性任务执行。

案例：

package com.example.m;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class MainActivity extends AppCompatActivity {

    private Button btnthread;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        btnthread = (Button)findViewById(R.id.btnthread);
        btnthread.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                ExecutorService cacheThreadPool = Executors.newCachedThreadPool();
                ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
                ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
                ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
                for(int i=1;i<=100;i++){
                    singleThreadPool.execute(new MyTask(i));
                } 
            }
        });
    }

    public void testThread(){
        MyThread mt1 = new MyThread();
        MyThread mt2 = new MyThread();
        mt1.start();
        mt2.start();
    }
    public void testRunnable(){
        MyRunnable mr1 = new MyRunnable();
        MyRunnable mr2 = new MyRunnable();
        Thread t1 = new Thread(mr1);
        Thread t2 = new Thread(mr2);
        t1.start();
        t2.start();
    }
    public void testSale(){
        SaleTicket saleTicket = new SaleTicket();
        Thread t1 = new Thread(saleTicket,"A代理");
        Thread t2 = new Thread(saleTicket,"B代理");
        t1.start();
        t2.start();
    }
    public void testScheduled(){
        Log.e("TAG:","testScheduled");
        ScheduledExecutorService scheduledExecutorService = Executors.newSingleThreadScheduledExecutor();
//        scheduledExecutorService.schedule(new Runnable() {
//            @Override
//            public void run() {
//                Log.e("TAG:"," delay 3 seconds");
//            }
//        },3, TimeUnit.SECONDS);
        scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                Log.e("TAG:"," delay 2 seconds, and excute every 3 seconds ");
            }
        },2,3, TimeUnit.SECONDS);
    }
}
class MyThread extends Thread{
    @Override
    public void run() {
        super.run();
        Log.e("TAG:",Thread.currentThread().getName()+".run");
    }
}
class MyRunnable implements Runnable{

    @Override
    public void run() {
        Log.e("TAG:",Thread.currentThread().getName()+".run");
    }
}
class SaleTicket implements Runnable{
    private int ticket = 20;
    @Override
    public void run() {
        while (true){
            synchronized (this){
                if(ticket>0){
                    Log.e("TAG:",Thread.currentThread().getName()+"卖出了第"+(20-ticket+1)+"张票");
                    ticket--;
                }else {
                    break;
                }
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }

    }
}
class MyTask implements Runnable{
    int index = 0;
    public MyTask(int i){this.index = i;}
    @Override
    public void run() {
        Log.e("TAG:",Thread.currentThread().getName()+" "+index);
        try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); }
    }
}