【Android面试】关于多线程，你必须知道的那些玩意儿

// 1
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("this is a Runnable");
    }
}
// 2
public class MyThread extends Thread {
    @Override
    public void run() {
        super.run();
        System.out.println("this is thread");
    }
}

// 具体使用
public class Main {
    public static void main(String[] args) {
        // 第一种
        Thread thread1 = new Thread(new MyRunnable());
        thread1.start();
        // 第二种
        MyThread thread2 = new MyThread();
        thread2.start();
    }
}

public class Main {
    public int i = 0;
    public void increase(){
        I++;
    }

    public static void main(String[] args) {
        final Main main = new Main();
        for(int i=0; i< 10; i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for(int j=0; j<1000; j++){
                        main.increase();
                    }
                }
            }).start();
        }
        while(Thread.activeCount() > 2){
            Thread.yield();
        }
        System.out.println(main.i);
    }
}

Lock lock = new ReentrantLock();
public void lockModel(){
    lock.lock();
    // 用于书写共同代码，比如说卖同一辆动车的车票等等。
    lock.unlock();
}

// 上述模版近似等价于下面的函数
public synchronized void lockModel(){}

public volatile int i = 0;

iconst_0  //把数值0 push到操作数栈
istore_1 // 把操作数栈写回到本地变量第2个位置
iinc 1,1  // 把本地变量表第2个位置加1     
iload_1 // 把本地变量第2个位置的值push到操作数栈
istore_1 // 把操作数据栈写回本地变量第2个位置

偏向锁   --------->   轻量锁（栈帧）   --------->   重量锁（Monitor）
       （存在线程争夺）         （自旋一定次数还是拿不到锁）

public class SyncDemo {
    // 对同一个实例加锁
    private synchronized void fun(){}
    // 对同一个类加锁
    private synchronized static void fun_static(){}
    // 视情况而定
    // 1\. this：实例加锁
    // 2\. SyncDemo.class：类加锁
    private void fun_inner(){
        synchronized(this){

        }
        synchronized(SyncDemo.class){

        }
    }
}

public static class CallerRunsPolicy implements RejectedExecutionHandler {
        // 如果线程池还没关闭，就在调用者线程中直接执行Runnable
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                r.run();
            }
        }
    }

public static class AbortPolicy implements RejectedExecutionHandler {
        // 拒绝任务，并且抛出RejectedExecutionException异常
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            throw new RejectedExecutionException("Task " + r.toString() +
                                                 " rejected from " +
                                                 e.toString());
        }
    }

 public static class DiscardPolicy implements RejectedExecutionHandler {
        // 拒绝任务，但是啥也不干
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
        }
    }

public static class DiscardOldestPolicy implements RejectedExecutionHandler {
        // 如果线程池还没有关闭，就把队列中最早的任务抛弃，把当前的线程插入
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            if (!e.isShutdown()) {
                e.getQueue().poll();
                e.execute(r);
            }
        }
    }

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
}

public ScheduledThreadPoolExecutor(int corePoolSize,
                                       ThreadFactory threadFactory) {
        // 最后对应的还是 ThreadPoolExecutor                                   
        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
              new DelayedWorkQueue(), threadFactory);
}

public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
}

public static ExecutorService newWorkStealingPool() {
        return new ForkJoinPool
            (Runtime.getRuntime().availableProcessors(), // 可用的处理器数
             ForkJoinPool.defaultForkJoinWorkerThreadFactory,
             null, true);
    }

implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.2.1"

public fun CoroutineScope.launch(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> Unit
)

// 当然还有async、runBlocking等用法
GlobalScope.launch(Dispatchers.Default,
            CoroutineStart.ATOMIC,
            { Log.e("Main", "run") }
        )