多进程

简单延迟

// 并不创建新的消息循环，代码仍然在 主线程/调用线程 中执行
new Handler().postDelayed(new Runnable() {
    @Override
    public void run() {
        // ...
    }
}, 2000);

new Handler(app.getMainLooper()).post(new Runnable() {
    @Override
    public void run() {
        app.findViewById(R.id.screen).setVisibility(View.GONE);
    }
});

多进程

多线程

• run(): 线程运行时所执行的代码
• start(): 启动线程
• sleep()/sleep(long millis): 线程休眠，进入阻塞状态，sleep方法不会释放锁
• yield(): 线程交出CPU，但是不会阻塞而是重置为就绪状态，不会释放锁
• join()/join(long millis)/join(long millis,int nanoseconds)
  • 线程插队，当该子线程执行完毕后接着执行其它
• wait(): 进入阻塞状态，释放锁
• interrupt(): 中断线程，注意只能中断阻塞状态的线程
• getId(): 获取当前线程的id
• getName()/setName(): 获取和设置线程的name
• getPriority()/setPriority(): 获取和设置线程的优先级，范围1-10，默认是5
• setDaemon()/isDaemo(): 设置和获取是否守护线程
• currentThread(): 静态函数获取当前线程

new Thread(new Runnable() {
    @Override
    public void run() {
        // ...
    }
}).start();

// Thread 类
class MyThread extends Thread{
    @Override
    public void run() {
        super.run();
        // do something
    }
}
new MyThread().start();

// Runnable 类
class MyRunnable implements Runnable{
    @Override
    public void run() {
        // do something
    }
}
new Thread(new MyRunnable()).start();

线程终止

// volatile 标记
public class ThreadStopTest extends Thread {
    public volatile boolean stop = false;
    @Override
    public void run() {
        super.run();
        while (!stop){
            // thread runing
        }
    }
}

// interrupt 中断
myThread = new MyThread();
myThread.start();       // 启动
myThread.interrupt();   // 中断: 方法只是中断线程而不是结束线程
public class MyThread extends Thread{
    @Override
    public void run() {
        super.run();
        // 判断状态，如果被打断则跳出并将线程置空
        while (!isInterrupted()){
            // ...
        }
    }
}

// stop: 强制终止，不建议使用

线程同步

// synchronized 关键字，保证同时刻只有一个线程进入该方法或者代码块
// java中有很多方式来实现线程同步，我们常用的synchronized是效率最低的, 但是它方便
synchronized void test() {
    // ...
}
void test() {
    synchronized (this) {
        // ...
    }
}

// volatile 修饰：告诉虚拟机该变量随时可能更新，因此使用时每次都会重新计算，而不是使用寄存器的值
// volatile不会提供任何原子操作, 它也不能用来修饰final类型的变量
// 不能完全保证线程安全
private volatile int test = 0;

// 重入锁
ReentrantLock lock = new ReentrantLock(); // 创建一个ReentrantLock实例
lock.lock();    //获得锁
lock.unlock();  // 释放锁

// ThreadLocal 管理
// 每一个使用该变量的线程都会获得该变量的副本，副本之间相互独立
static ThreadLocal<Integer> number = new ThreadLocal<Integer>(){
    // 重写方法，设置默认值
    @Override
    protected Integer initialValue() {
        return 1;
    }
    // 自定义方法操作变量值
    public void saveNumber(int newNumber){
        number.set(number.get() + newNumber);
    }
};

线程池

// Runnable队列
LinkedBlockingQueue<Runnable> queue = new LinkedBlockingQueue<Runnable>(1000);
// 10：核心线程数(至少保持运行线程数)，1000：线程池大小(添加线程数量超过该值会抛异常)
ThreadPoolExecutor executor = new ThreadPoolExecutor(10, 1000, 0, TimeUnit.MILLISECONDS, queue);

class SearchRunnable implements Runnable {
    print String name;
    public SearchRunnable(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        // 函数体 ...
    }
}
// 添加：需检查线程池状态
while (queue.remainingCapacity() == 0) {
    // 线程池跑满，等待
    try {
        Thread.sleep(1);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}
executor.execute(new SearchRunnable(card, feature, model));
// 等待执行完成
try {
    executor.shutdown();
    while (!executor.awaitTermination(1, TimeUnit.MILLISECONDS)) {
        Log.i(TAG, "线程池没有关闭");
    }
} catch (InterruptedException e) {
    e.printStackTrace();
}
queue.clear();

进程通信

• EventBus
  • 本地组件间通信框架
• RxAndroid
  • Eventbus是用来取代组件间繁琐的interface，RxAndroid是用来取代AnsyTask的