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(); }
}
}?