class MyThread extends Thread{
 @Override
 public void run() {
  System.out.println("我是子線程");
 }
}

new MyThread().start();

public class ManyThread {
 public static void main(String[] args) {
  new Thread(){
   public void run() {
    System.out.println("我是子線程");
   };
  }.start();
 }
}

class MyRunnable implements Runnable{
 @Override
 public void run() {
  System.out.println("我是子線程");
 }
}
Thread thread = new Thread(new MyRunnable());
thread.start();

public class FutureTask<V> implements RunnableFuture<V> {
    ...
}

public interface RunnableFuture<V> extends Runnable, Future<V> {
    /**
     * Sets this Future to the result of its computation
     * unless it has been cancelled.
     */
    void run();
}

//自定義CallAble并實(shí)現(xiàn)call()方法
class MyCallable implements Callable<Integer>{

 @Override
 public Integer call() throws Exception {
  
  int a = 1;
  for (int i = 0; i <100000; i++) {
   a++;
  }
  Thread.sleep(2000);
  return a;
 }
 
}

public static void main(String[] args) {
  
                //新建CallAble
  MyCallable callable = new MyCallable();
                
                //新建FutureTask任務(wù)
  FutureTask<Integer> futureTask = new FutureTask<Integer>(callable);
                
                //新建Thread并與FutureTask關(guān)聯(lián)
  Thread thread = new Thread(futureTask, "A");
  thread.start();
  int sum;
  try {
                        //拿到callable的結(jié)果
   sum = futureTask.get();
   System.out.println(sum);
  } catch (InterruptedException e) {
   e.printStackTrace();
  } catch (ExecutionException e) {
   e.printStackTrace();
  }
 }

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 2, 1, TimeUnit.SECONDS, new LinkedBlockingDeque<Runnable>());
//使用execute提交任務(wù)
threadPoolExecutor.execute(new Runnable() {
    @Override
    public void run() {
 System.out.println("我是線程池");
    }
});

//之前說(shuō)的callable
MyCallable callable = new MyCallable();
//使用submit提交任務(wù) 返回一個(gè)future
Future<Integer> future = threadPoolExecutor.submit(callable);
try {
    //通過(guò)future拿到執(zhí)行callable的結(jié)果
    int x = future.get();
    System.out.println(x);
} catch (InterruptedException e) {
    //中斷異常
    e.printStackTrace();
} catch (ExecutionException e) {
    //無(wú)法執(zhí)行任務(wù)異常
    e.printStackTrace();
}finally {
    //關(guān)閉線程池
    threadPoolExecutor.shutdown();
}

//會(huì)根據(jù)需要?jiǎng)?chuàng)建新線程的線程池
ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
//核心線程數(shù)設(shè)置為0，最大線程數(shù)則是無(wú)界，的也就是說(shuō)某些情況下會(huì)有無(wú)限多的線程被創(chuàng)建，從而導(dǎo)致一些問(wèn)題，空閑線程最大等待時(shí)長(zhǎng)是60秒
public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
}

//使用單個(gè)worker線程
ExecutorService newSingleThreadExecutor = Executors.newSingleThreadExecutor();
//核心線程數(shù)和最大線程數(shù)都設(shè)置為1，并使用無(wú)界隊(duì)列作為線程池的工作隊(duì)列，其容量為無(wú)限大，某些情況下會(huì)導(dǎo)致隊(duì)列中有太多的任務(wù)而出錯(cuò)
public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
}

//可重用固定線程數(shù)的線程池
ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(10);
//核心線程數(shù)和最大線程數(shù)都設(shè)置為創(chuàng)建時(shí)傳入的數(shù)量，空閑等待時(shí)長(zhǎng)為0，說(shuō)明空閑線程會(huì)立即終止，而任務(wù)隊(duì)列容量也是無(wú)限大，可能會(huì)導(dǎo)致同樣的問(wèn)題
public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
}

//可以用來(lái)在給定延時(shí)后執(zhí)行異步任務(wù)或者周期性執(zhí)行任務(wù)
ScheduledExecutorService newScheduledThreadPool = Executors.newScheduledThreadPool(2);
//核心線程的個(gè)數(shù)為指定的數(shù)量，允許的最大線程數(shù)是無(wú)限的
public ScheduledThreadPoolExecutor(int corePoolSize,
                                   ThreadFactory threadFactory,
                                   RejectedExecutionHandler handler) {
    super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
          new DelayedWorkQueue(), threadFactory, handler);
}

public class HandlerThread extends Thread {
    
    Looper mLooper;
    private @Nullable Handler mHandler;

    @Override
    public void run() {
        mTid = Process.myTid();
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
            notifyAll();
        }
        Process.setThreadPriority(mPriority);
        onLooperPrepared();
        Looper.loop();
        mTid = -1;
    }
    
    ...
}

        //創(chuàng)建handlerThread，標(biāo)記一個(gè)名字
        HandlerThread handlerThread = new HandlerThread("MyHandlerThread");
        //啟動(dòng)線程
        handlerThread.start();

        //創(chuàng)建工作線程的handler，關(guān)聯(lián)handlerThread的Looper對(duì)象。
        //復(fù)寫handleMessage處理消息
        Handler myHandler = new Handler(handlerThread.getLooper()) {
            @Override
            public void handleMessage(@NonNull Message msg) {

                Log.i(msg.what + msg.obj.toString());
                super.handleMessage(msg);
            }
        };

        //定義消息
        Message msg = new Message();
        msg.what = 1;
        msg.obj = "A";
        //發(fā)送消息到其綁定的消息隊(duì)列中
        myHandler.sendMessage(msg);
        //結(jié)束線程，停止線程的消息循環(huán)
        handlerThread.quit();

//繼承自service
public abstract class IntentService extends Service {
    private volatile Looper mServiceLooper;
    @UnsupportedAppUsage
    private volatile ServiceHandler mServiceHandler;

    private final class ServiceHandler extends Handler {
        public ServiceHandler(Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(Message msg) {
            //處理消息時(shí)調(diào)用onHandleIntent方法 我們需要重寫這個(gè)方法實(shí)現(xiàn)自己的處理邏輯
            onHandleIntent((Intent)msg.obj);
            stopSelf(msg.arg1);
        }
    }
    ...
    
    @Override
    public void onCreate() {
        super.onCreate();
        //創(chuàng)建handlerThread并啟動(dòng)
        HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
        thread.start();
        mServiceLooper = thread.getLooper();
        //初始化handler并綁定handlerThread的looper
        mServiceHandler = new ServiceHandler(mServiceLooper);
    }
    
    @Override
    public void onStart(@Nullable Intent intent, int startId) {
        Message msg = mServiceHandler.obtainMessage();
        msg.arg1 = startId;
        msg.obj = intent;
        //通過(guò)handler發(fā)送消息給HandlerThread處理
        mServiceHandler.sendMessage(msg);
    }
    ...

public class MyIntentService extends IntentService {

    public MyIntentService(String name) {
        super(name);
    }

    @Override
    protected void onHandleIntent(@Nullable Intent intent) {
        if(intent != null){
            String action = intent.getAction();
            if(action.equals("A")){
                doSomeThingA();
            }else if(action.equals("B")){
                doSomeThingB();
            }
        }
    }
}

public class SimpleJobIntentService extends JobIntentService {
    /**
     * 這個(gè)Service 唯一的id
     */
    static final int JOB_ID = 1000;

    /**
     * 將工作加入此服務(wù)的方法，使用中調(diào)用這個(gè)方法
     */
    static void enqueueWork(Context context, Intent work) {
        enqueueWork(context, SimpleJobIntentService.class, JOB_ID, work);
    }

    //在這里執(zhí)行耗時(shí)任務(wù)
    @Override
    protected void onHandleWork(Intent intent) {
        Log.i("SimpleJobIntentService", "Executing work: " + intent);
        String label = intent.getStringExtra("label");
        if (label == null) {
            label = intent.toString();
        }
        toast("Executing: " + label);
        for (int i = 0; i < 5; i++) {
            Log.i("SimpleJobIntentService", "Running service " + (i + 1)
                    + "/5 @ " + SystemClock.elapsedRealtime());
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
        }
        Log.i("SimpleJobIntentService", "Completed service @ " + SystemClock.elapsedRealtime());
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        toast("All work complete");
    }

    final Handler mHandler = new Handler();

    // Helper for showing tests
    void toast(final CharSequence text) {
        mHandler.post(new Runnable() {
            @Override public void run() {
                Toast.makeText(SimpleJobIntentService.this, text, Toast.LENGTH_SHORT).show();
            }
        });
    }
}

    Intent workIntent = new Intent();
    num++;
    Log.d("houson", "onClick: "+num);
    workIntent.putExtra("work","work num:"+num);
    //調(diào)用enqueueWork方法
    MyJobIntentService.enqueueWork(getApplicationContext(),workIntent);

dependencies {
    def versions = "2.2.0"
    implementation "androidx.work:work-runtime:$versions"
}

//繼承worker，自定義worker
class MyWork extends Worker{

    public MyWork(@NonNull Context context, @NonNull WorkerParameters workerParams) {
        super(context, workerParams);
    }

    //執(zhí)行耗時(shí)任務(wù)
    @NonNull
    @Override
    public Result doWork() {
        //拿到傳進(jìn)來(lái)的數(shù)據(jù)
        String input_data = getInputData().getString("input_data");
        // 任務(wù)執(zhí)行完成后返回?cái)?shù)據(jù)
        Data outputData = new Data.Builder().putString("output_data", "Success!").build();
//        執(zhí)行成功返回Result.success()
//        執(zhí)行失敗返回Result.failure()
//        需要重新執(zhí)行返回Result.retry()
        return Result.success(outputData);
    }
}

       //設(shè)置任務(wù)的觸發(fā)條件
        Constraints constraints = new Constraints.Builder()
                .setRequiresCharging(true) // 在充電時(shí)執(zhí)行
                .setRequiresStorageNotLow(true) // 不在存儲(chǔ)容量不足時(shí)執(zhí)行  
                
                // 網(wǎng)絡(luò)狀態(tài)
                //NOT_REQUIRED--沒(méi)有要求
                //CONNECTED--網(wǎng)絡(luò)連接
                //UNMETERED--連接無(wú)限流量的網(wǎng)絡(luò)
                //METERED--連接按流量計(jì)費(fèi)的網(wǎng)絡(luò)
                //NOT_ROAMING--連接非漫游網(wǎng)絡(luò)
                .setRequiredNetworkType(NetworkType.CONNECTED)
                .setRequiresDeviceIdle(true) // 在待機(jī)狀態(tài)下執(zhí)行，需要 API 23
                .setRequiresBatteryNotLow(true)// 不在電量不足時(shí)執(zhí)行
                .build();
        //然后將該Constraints設(shè)置到WorkRequest。WorkRequest是一個(gè)抽象類，
        //它有兩種實(shí)現(xiàn)OneTimeWorkRequest和PeriodicWorkRequest，分別對(duì)應(yīng)的是一次性任務(wù)和周期性任務(wù)。
        //定義要傳遞的數(shù)據(jù)
        Data inputData = new Data.Builder().putString("input_data", "Hello").build();
        OneTimeWorkRequest oneTimeWorkRequest = new OneTimeWorkRequest.Builder(MyWork.class)
                .setConstraints(constraints)
                .setInputData(inputData)
                .build();

WorkManager.getInstance(this).enqueue(oneTimeWorkRequest);

WorkManager.getInstance(this).getWorkInfoByIdLiveData(oneTimeWorkRequest.getId()).observe(
                MainActivity.this, new Observer<WorkInfo>() {
                    @Override
                    public void onChanged(WorkInfo workInfo) {
                        Log.d("onChanged()->", "workInfo:"+workInfo);
                        if (workInfo != null && workInfo.getState() == WorkInfo.State.SUCCEEDED) {
                            String outputData = workInfo.getOutputData().getString("output_data");
                            Log.d("onChanged()->", "outputData:"+outputData);
                        }
                    }
                }
        );

WorkManager.getInstance(MainActivity.this).cancelAllWork();

dependencies {
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.9")
}

 fun main() = runBlocking {
    launch {
        delay(1000L)
        println("World!")
    }
    println("Hello") 
}

    @MainThread
    public final AsyncTask<Params, Progress, Result> execute(Params... params) {
        return executeOnExecutor(sDefaultExecutor, params);
    }
    
    
    @MainThread
    public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
            Params... params) {
        if (mStatus != Status.PENDING) {
            switch (mStatus) {
                case RUNNING:
                    throw new IllegalStateException("Cannot execute task:"
                            + " the task is already running.");
                case FINISHED:
                    throw new IllegalStateException("Cannot execute task:"
                            + " the task has already been executed "
                            + "(a task can be executed only once)");
            }
        }

        mStatus = Status.RUNNING;
       
        onPreExecute();

        mWorker.mParams = params;
        //線程池開(kāi)始執(zhí)行 封裝為Futuretask交個(gè)線程池處理
        exec.execute(mFuture);

        return this;
    }

    //串行線程池
    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
    //線程池用于真正執(zhí)行任務(wù)
    public static final Executor THREAD_POOL_EXECUTOR;
    //用于將執(zhí)行環(huán)境從線程池切換到主線程
    private static InternalHandler sHandler;
   
    //初始化執(zhí)行任務(wù)的線程池
    static {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
                sPoolWorkQueue, sThreadFactory);
        threadPoolExecutor.allowCoreThreadTimeOut(true);
        
        THREAD_POOL_EXECUTOR = threadPoolExecutor;
    }
    
    //用于調(diào)度任務(wù)的串行線程池
    private static class SerialExecutor implements Executor {
        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
        Runnable mActive;

        public synchronized void execute(final Runnable r) {
            mTasks.offer(new Runnable() {
                public void run() {
                    try {
                        r.run();
                    } finally {
                        scheduleNext();
                    }
                }
            });
            if (mActive == null) {
                scheduleNext();
            }
        }

        protected synchronized void scheduleNext() {
            
            //從隊(duì)列中取出任務(wù)交個(gè)THREAD_POOL_EXECUTOR線程池去真正執(zhí)行任務(wù)
            if ((mActive = mTasks.poll()) != null) {
                THREAD_POOL_EXECUTOR.execute(mActive);
            }
        }
    }

    private final WorkerRunnable<Params, Result> mWorker;
    private final FutureTask<Result> mFuture;
     mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
                mTaskInvoked.set(true);
                Result result = null;
                try {
                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                    //noinspection unchecked
                    result = doInBackground(mParams);
                    Binder.flushPendingCommands();
                } catch (Throwable tr) {
                    mCancelled.set(true);
                    throw tr;
                } finally {
                    postResult(result);
                }
                return result;
            }
        };

        mFuture = new FutureTask<Result>(mWorker) {
            @Override
            protected void done() {
                try {
                    postResultIfNotInvoked(get());
                } catch (InterruptedException e) {
                    android.util.Log.w(LOG_TAG, e);
                } catch (ExecutionException e) {
                    throw new RuntimeException("An error occurred while executing doInBackground()",
                            e.getCause());
                } catch (CancellationException e) {
                    postResultIfNotInvoked(null);
                }
            }
        };