Estou participando do "Nuggets·Plano Inicial"
Simultaneidade é fazer várias coisas ao mesmo tempo, como aquisição de dados de rede, download de arquivos, leitura e gravação de banco de dados e outras lógicas de negócios demoradas, todos precisam usar sub-threads para processar, cada thread tem uma divisão clara de trabalho, o thread principal pode lidar melhor com outra coisa, evite ANR.
Na verdade, nosso aplicativo parece ter muitos threads, porque a velocidade de cálculo da CPU é muito rápida e pode criar e alternar rapidamente entre os threads. Olhando para o tempo, parece que há vários threads sendo executados ao mesmo tempo. No entanto, if Em termos de encurtar o tempo, ele ainda executa outro thread após a execução do thread.
A diferença entre processo e thread
- Um processo é a unidade básica de alocação de recursos do sistema operacional.Cada processo tem um espaço de endereço virtual diferente e é independente um do outro. Quando um aplicativo Android está em execução, é criado um processo para hospedar o aplicativo, que é alocado e gerenciado pelo sistema, incluindo recursos como a memória ocupada pelo processo. No Android, cada programa aplicativo será executado em um processo independente, o que pode garantir o isolamento entre os aplicativos e melhorar a estabilidade do sistema.
- Um thread é um único caminho de execução dentro de um processo, e um processo pode executar vários threads ao mesmo tempo. Os encadeamentos usam memória compartilhada para se comunicar, portanto, a segurança do encadeamento precisa ser considerada ao acessar dados compartilhados entre os encadeamentos. No Android, precisamos criar threads filhos para executar operações demoradas, para que o thread principal continue respondendo às operações do usuário sem problemas.
Threads são executados em uma ordem específica
usar juntar
join pode lidar com alguns cenários que precisam aguardar a conclusão da tarefa antes de continuar a execução.
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();
}
复制代码Usando um pool de threads de thread único
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);
复制代码Use wait/notify para aguardar o mecanismo de notificação
wait é um método de Object, sua função é fazer com que o thread atual entre no estado de espera, deixe o thread atual liberar o bloqueio que ele possui, até que outros threads chamem o método notify ou notifyAll deste objeto e o thread atual seja despertado.
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) dorme ou não
Depois que um thread libera recursos da CPU, o sistema operacional recalcula as prioridades de todos os threads para realocar os recursos da CPU; A CPU é redistribuída. Depois de terminar, se a prioridade não mudou, continue a executar, então o verdadeiro significado de sleep(0) é acionar a realocação dos recursos da 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();
}
}
复制代码线程池
- 核心线程：有新任务提交时，先检查核心线程数，如果核心线程都在工作，而且数量也已经达到最大核心线程数，则不会继续新建核心线程，而会将任务放入等待队列。
- 等待队列 ：等待队列用于存储当核心线程都在忙时，继续新增的任务，核心线程在执行完当前任务后，会去等待队列拉取任务继续执行，这个队列一般是一个线程安全的阻塞队列，它的容量也可由开发者根据业务来定制。
- 非核心线程：当等待队列满了，如果当前线程数没有超过最大线程数，则会新建线程执行任务，其实，核心线程和非核心线程本质上没有什么区别。
- 饱和策略：当等待队列已满，线程数也达到最大线程数时，线程池会根据饱和策略来执行后续操作，默认的策略是抛弃要加入的任务。
- 线程活动保持时间：线程空闲下来之后，保持存活的持续时间，超过这个时间还没有任务执行，该工作线程结束。
线程池的好处：
- 降低资源消耗，通过重复利用已创建的线程来降低线程创建和销毁造成的消耗。
- 提高响应速度，当任务到达时，任务可以不需要等到线程创建就能立即执行。
- 提高线程的可管理性，使用线程池可以进行统一分配和监控。
线程池的构造
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秒执行一次任务
复制代码