Android 多线程的那些事

并发就是同时做几件事情，比如网络数据获取，文件下载，数据库读写等这些耗时的业务逻辑，都需要我们使用子线程去处理，每个线程分工明确，主线程才能更好地处理其他事情，避免 ANR。

其实，我们的应用看似很多个线程，因为 CPU 计算速度太快，能迅速地进行线程间的创建与切换，把时间拉宽来看，就好像有多个线程在同时执行，但是，如果把时间拉短来看，它还是执行完该线程后才去执行另一个线程。

进程和线程的区别

• 进程是操作系统资源分配的基本单位，每个进程有不同的虚拟地址空间，相互之间彼此独立。Android 应用程序在运行时，就会创建一个进程来承载这个应用程序，这个进程是由系统分配管理的，包括该进程所占用的内存等资源。在 Android 中，每个应用程序都会运行在独立的进程内，这样可以保证应用程序之间的互相隔离，提高系统的稳定性。
• 线程是进程内单个执行路径，一个进程可以同时运行多个线程。线程之间使用共享内存的方式进行通信，因此线程之间访问共享数据时需要考虑线程安全。在 Android 中，我们需要创建子线程来执行耗时的操作，这样主线程才能保持流畅地响应用户操作。

线程按照特定的顺序执行

利用 join

join 可以处理一些需要等待任务完成后才能继续往下执行的场景。

Thread t1 = new Thread(() -> System.out.println("Executing thread 1"));
Thread t2 = new Thread(() -> System.out.println("Executing thread 2"));
Thread t3 = new Thread(() -> System.out.println("Executing thread 3"));
try {
    t1.start();
    t1.join();
    t2.start();
    t2.join();
    t3.start();
} catch (InterruptedException e) {
    e.printStackTrace();
}

利用单线程化的线程池

Thread t1 = new Thread(() -> System.out.println("Executing thread 1"));
Thread t2 = new Thread(() -> System.out.println("Executing thread 2"));
Thread t3 = new Thread(() -> System.out.println("Executing thread 3"));

ExecutorService executorService = Executors.newSingleThreadExecutor();
executorService.submit(t1);
executorService.submit(t2);
executorService.submit(t3);

利用 wait/notify 等待通知机制

wait 是 Object 的方法，作用是让当前线程进入等待状态，让当前线程释放它所持有的锁，直到其他线程调用此对象的 notify 或 notifyAll 方法，当前线程被唤醒。

boolean run1, run2;
final Object lock1 = new Object();
final Object lock2 = new Object();

Thread t1 = new Thread(() -> {
    synchronized (lock1) {
        System.out.println("Executing thread 1");
        run1 = true;
        lock1.notify();
    }
});

Thread t2 = new Thread(() -> {
    synchronized (lock1) {
        try {
            if (!run1) {
                lock1.wait();
            }
            synchronized (lock2) {
                System.out.println("Executing thread 2");
                lock2.notify();
            }

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
});

Thread t3 = new Thread(() -> {
    synchronized (lock2) {
        try {
            if (!run2) {
                lock2.wait();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    System.out.println("Executing thread 3");
});

t1.start();
t2.start();
t3.start();

Thread.sleep(0) 到底睡没睡

操作系统是在一个线程释放 CPU 资源以后，重新计算所有线程的优先级来重新分配 CPU 资源，所以 sleep 真正的意义不是暂停，而是在接下去的时间内不参与 CPU 的竞争，等到 CPU 重新分配完以后，如果优先级没变，那么继续执行，所以 sleep(0) 的真正含义是触发 CPU 资源重新分配。

synchronized 到底锁住了啥

实例方法

public synchronized void method() {
    // 锁住的是该类的实例对象
}

静态方法

public static synchronized void method() {
    // 锁住的是类对象
}

实例对象代码块

synchronized (this) {
    // 锁住的是该类的实例对象
}

类对象代码块

synchronized (Test.class) {
    // 锁住的是类对象
}

任意实例对象代码块

Object obj = new Object();

synchronized (obj) {
    // 锁住的是配置的实例对象
}

多线程的三个特性

• 可见性：如果一个线程对于某个共享变量进行更新之后，后续访问该变量的线程可以读取到该更改的结果，那么我们就说这个线程对于共享变量的更新是可见的。
• 原子性：访问某个共享变量的操作从其执行线程之外的线程来看，该操作要么已经执行完毕，要么尚未发生，其他线程不会看到执行操作的中间结果。非原子操作存在线程安全问题，需要我们使用同步，比如使用 sychronized 让它变成一个原子操作。一个操作是原子操作，那么称它具有原子性。
• 有序性：程序在执行的时候，程序的代码执行顺序和语句顺序是一致的。

volatile，synchronized 和 Lock

• volatile：可以保证线程对变量的修改对其他线程可见，其作用是强制将修改后的值立即写入主存，并通知其他线程刷新缓存。volatile 可以保证变量在线程之间的可见性，但并不能保证线程安全，因为不具备原子性，当多个线程同时进行读写操作时，仍然可能出现数据不一致的情况。
• synchronized：可以保证在同一时间只有一个线程访问一个共享资源，其他线程需要等待该线程访问结束才能继续执行，既具有原子性又具有可见性，可以保证多个线程访问共享资源时数据的一致性和正确性，但使用 synchronized 可能会使其他线程阻塞，导致性能下降。
• Lock：是一个接口，提供了一种比 synchronized 更加灵活的方式来实现同步，允许多个线程同时访问同一个共享资源，在使用 Lock 机制时，必须手动加锁和释放锁。

public class LockTest {

    public static ReentrantLock reentrantLock = new ReentrantLock();

    public static void main(String[] args) {
        new Thread(() -> {
            testSync();
        }, "t1").start();

        new Thread(() -> {
            testSync();
        }, "t2").start();

    }

    public static void testSync() {
        reentrantLock.lock();
        try {
            System.out.println(Thread.currentThread().getName());
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            reentrantLock.unlock();
        }
    }
}

volatile 可用于提供线程安全，但是只能应用于非常有限的一组用例：多个变量之间或某个变量的当前值与修改后的值之间没有约束。

Atomic 包

Atomic 包（java.util.concurrent.atomic）提供了一系列用于处理原子操作的类和方法，以确保多线程环境下的线程安全和数据一致性，如 AtomicInteger，AtomicBoolean，AtomicLong 等。

public class AtomicTest {

    private static AtomicInteger count = new AtomicInteger(1);

    public static void main(String[] args) {

        new Thread(() -> {
            // 以原子方式将输入的数值与实例中的值相加，并返回结果。
            count.addAndGet(2);
        }).start();

        new Thread(() -> {
            System.out.println(count.get());
        }).start();
    }
}

线程池

• 核心线程：有新任务提交时，先检查核心线程数，如果核心线程都在工作，而且数量也已经达到最大核心线程数，则不会继续新建核心线程，而会将任务放入等待队列。
• 等待队列 ：等待队列用于存储当核心线程都在忙时，继续新增的任务，核心线程在执行完当前任务后，会去等待队列拉取任务继续执行，这个队列一般是一个线程安全的阻塞队列，它的容量也可由开发者根据业务来定制。
• 非核心线程：当等待队列满了，如果当前线程数没有超过最大线程数，则会新建线程执行任务，其实，核心线程和非核心线程本质上没有什么区别。
• 饱和策略：当等待队列已满，线程数也达到最大线程数时，线程池会根据饱和策略来执行后续操作，默认的策略是抛弃要加入的任务。
• 线程活动保持时间：线程空闲下来之后，保持存活的持续时间，超过这个时间还没有任务执行，该工作线程结束。

线程池的好处：

1. 降低资源消耗，通过重复利用已创建的线程来降低线程创建和销毁造成的消耗。
2. 提高响应速度，当任务到达时，任务可以不需要等到线程创建就能立即执行。
3. 提高线程的可管理性，使用线程池可以进行统一分配和监控。

线程池的构造

public ThreadPoolExecutor(int corePoolSize, //核心线程数量
                          int maximumPoolSize, //允许创建的最大线程数
                          long keepAliveTime, //工作线程空闲后保持存活的时间
                          TimeUnit unit, //保持存活的时间单位
                          BlockingQueue<Runnable> workQueue, //任务队列
                          //拒绝策略
                          RejectedExecutionHandler handler) { ... }

任务队列有几个可供选择：

• ArrayBlockingQueue：一个基于数组结构的阻塞队列，按照先进先出的原则对元素进行排序。
• LinkedBlockingQueue：一个基于链表结构的阻塞队列，按照先进先出的原则对元素进行排序，newFixedThreadPool 就是使用这个队列。
• SynchronousQueue：一个不存储元素的阻塞队列，每插入操作必须等到另一个线程调用移除操作，否则插入操作一直处于阻塞状态，newCachedThreadPool 就是使用这个队列。
• PriorityBlockingQueue：一个具有优先级的无限阻塞队列。

public class Task implements Runnable {
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
            System.out.println("Perform Tasks");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

ArrayBlockingQueue<Runnable> blockingQueue = new ArrayBlockingQueue<>(1);
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 20, 1, TimeUnit.MINUTES, blockingQueue);
for (int i = 0; i < 10; i++) {
    threadPoolExecutor.submit(new Task());
}

提交任务有两种方式：submit 和 execute。submit 会返回一个 Future 类型的对象，通过这个对象可以判断任务是否执行成功，并且可以通过 get 方法来获取返回值，而 execute 用于提交不需要返回值的任务。

关闭线程池有两种方式：shutdown 和 shutdownNow。shutdown 只是将线程池的状态设置为 SHUTWDOWN 状态，正在执行的任务会继续执行下去，没有被执行的则中断。而 shutdownNow 则是将线程池的状态设置为 STOP，正在执行的任务则被停止，没被执行任务的则返回。

线程池的种类：

newSingleThreadExecutor：创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序执行。

ExecutorService executorService = Executors.newSingleThreadExecutor();
executorService.execute(() -> {
    try {
        Thread.sleep(1000);
        System.out.println(" CurrentThread: " + Thread.currentThread().getName());
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});
executorService.shutdown();

newFixedThreadPool：创建一个定长的线程池，可控制最大并发数，超出的线程进行队列等待。

ExecutorService executorService = Executors.newFixedThreadPool(5);
for (int i = 0; i < 5; i++) {
    executorService.execute(() -> {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Current Thread: " + Thread.currentThread().getName());
    });
}
executorService.shutdown();

newCacheTreadPool：创建一个可以缓存的线程池，如果线程池长度超过处理需要，可以灵活回收空闲线程，没回收的话就新建线程。该线程池的最大核心线程为无限大，当执行第二个任务时第一个任务已经完成，则会复用执行第一个任务的线程，否则会新建一个线程。

ExecutorService executor = Executors.newCachedThreadPool();
executor.execute(() -> {
    for (int i = 0; i < 5; i++) {
        try {
            Thread.sleep(1000);
            System.out.println("Current Thread: " + Thread.currentThread().getName());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
});

newScheduledThreadPool：创建一个定长的线程池，支持定时或周期任务执行。

ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(1);
scheduledThreadPool.scheduleAtFixedRate(() -> {
    System.out.println("Current Thread: " + Thread.currentThread().getName());
}, 2, 1, TimeUnit.SECONDS); // 周期任务：延迟2秒钟后每隔1秒执行一次任务