private void setIcon(int useCode){
    try {
        //要跟manifest的activity-alias 的name保持一致
        String icon_1 = "com.mz.sanfen.appicon.icon_1";
        String icon_2 = "com.mz.sanfen.appicon.icon_2";
        if (useCode != 3) {
            PackageManager pm = getPackageManager();
            ComponentName normalComponentName = new ComponentName(getBaseContext(), icon_1);
            //正常图标新状态
            int normalNewState = useCode == 1 ? PackageManager.COMPONENT_ENABLED_STATE_ENABLED
                    : PackageManager.COMPONENT_ENABLED_STATE_DISABLED;
            if (pm.getComponentEnabledSetting(normalComponentName) != normalNewState) {//新状态跟当前状态不一样才执行
                pm.setComponentEnabledSetting(
                        normalComponentName,
                        normalNewState,
                        PackageManager.DONT_KILL_APP);
            }
            ComponentName actComponentName = new ComponentName(getBaseContext(), icon_2);
            //正常图标新状态
            int actNewState = useCode == 2 ? PackageManager.COMPONENT_ENABLED_STATE_ENABLED
                    : PackageManager.COMPONENT_ENABLED_STATE_DISABLED;
            if (pm.getComponentEnabledSetting(actComponentName) != actNewState) {//新状态跟当前状态不一样才执行
                pm.setComponentEnabledSetting(
                        actComponentName,
                        actNewState,
                        PackageManager.DONT_KILL_APP);
            }
        }
    } catch (Exception e) {
    }
}

Intent intent = new Intent(Intent.ACTION_MAIN);
intent.addCategory(Intent.CATEGORY_HOME);
intent.addCategory(Intent.CATEGORY_DEFAULT);
List<ResolveInfo> resolves = getPackageManager().queryIntentActivities(intent, 0);
for (ResolveInfo res : resolves) {
    if (res.activityInfo != null) {
        ActivityManager am = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
        am.killBackgroundProcesses(res.activityInfo.packageName);
    }
}

<uses-permission android:name="android.permission.KILL_BACKGROUND_PROCESSES"/>

public class BlockingQueue {
    private List<Object> queue = new LinkedList<>();
    private int limit = 10;
    public BlockingQueue(int limit){
        this.limit = limit;
    }
    /**
     * 当队列满了的时候阻塞线程
     *
     * @param item
     * @throws InterruptedException
     */
    public synchronized void enqueue(Object item) throws InterruptedException {
        while (this.queue.size() == this.limit) {
            wait();
        }
        if (this.queue.size() < this.limit) {
            notifyAll();
        }
        this.queue.add(item);
    }
    /**
     * 当队列为空的时候阻塞线程
     * @return
     * @throws InterruptedException
     */
    public synchronized Object dequeue() throws InterruptedException {
        while (this.queue.size() == 0) {
            wait();
        }
        if (this.queue.size() > 1) {
            notifyAll();
        }
        return this.queue.remove(0);
    }
}

public class ProducerConsumerPattern {
    public static void main(String[] args) {
        BlockingQueue shareQueue = new LinkedBlockingQueue<>();
        Thread prodThread = new Thread(new Producer(shareQueue));
        Thread consThread = new Thread(new Consumer(shareQueue));
        prodThread.start();
        consThread.start();
    }
    /**
     * 生产者
     */
    static class Producer implements Runnable {
        private final BlockingQueue shareQueue;
        public Producer(BlockingQueue shareQueue) {
            this.shareQueue = shareQueue;
        }
        @Override
        public void run() {
            for (int i = 0; i < 10; i++){
                System.out.println("Produced: " + i);
                try {
                    shareQueue.put(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    /**
     * 消费者
     */
    static class Consumer implements Runnable {
        private final java.util.concurrent.BlockingQueue shareQueue;
        public Consumer(BlockingQueue shareQueue) {
            this.shareQueue = shareQueue;
        }
        @Override
        public void run() {
            while (true) {
                try {
                    System.out.println("Consumer: " + shareQueue.take());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

public class BoundedBuffer {
    final Lock lock = new ReentrantLock();
    final Condition notFull = lock.newCondition();
    final Condition notEmpty = lock.newCondition();
    final Object[] items = new Object[100];
    int putptr, takeptr, count;
    public void put(Object x) throws InterruptedException {
        lock.lock();
        try {
            while (count == items.length)
                notFull.await();
            items[putptr] = x;
            if (++putptr == items.length)
                putptr = 0;
            ++count;
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }
    public Object take() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0)
                notEmpty.await();
            Object x = items[takeptr];
            if (++takeptr == items.length)
                takeptr = 0;
            --count;
            notFull.signal();
            return x;
        } finally {
            lock.unlock();
        }
    }
}

//构造函数
BitmapShader(Bitmap bitmap, Shader.TileMode tileX, Shader.TileMode tileY)

private Shader.TileMode mDefaultTileMode = Shader.TileMode.REPEAT;
public void drawBitmap(){
    bitmap = BitmapFactory.decodeResource(getResources(), R.mipmap.music_player);
    BitmapShader bitmapShader = new BitmapShader(bitmap,
            mDefaultTileMode,
            mDefaultTileMode
    );
    mPaint.setShader(bitmapShader);
}
@Override
protected void onDraw(Canvas canvas) {
    canvas.drawRect(0, 0,  canvas.getWidth(), canvas.getHeight(), mPaint);
}

LinearGradient(float x0, float y0, float x1, float y1, int color0, int color1, Shader.TileMode tile)
LinearGradient(float x0, float y0, float x1, float y1, int[] colors, float[] positions, Shader.TileMode tile)

private Shader.TileMode mDefaultTileMode = Shader.TileMode.REPEAT;
@Override
protected void onDraw(Canvas canvas) {
    canvas.drawRect(0, 0, getWidth() ,  getHeight(), mPaint);
}
public void drawLinear(){
    LinearGradient linearGradient = new LinearGradient(
            0, 0, getWidth() / 4, getHeight() / 4,
            Color.GREEN,
            Color.BLUE,
            mDefaultTileMode
    );
    mPaint.setShader(linearGradient);
}

RadialGradient(float centerX, float centerY, float radius, int centerColor, int edgeColor, Shader.TileMode tileMode)
RadialGradient(float centerX, float centerY, float radius, int[] colors, float[] stops, Shader.TileMode tileMode)

@Override
protected void onDraw(Canvas canvas) {
    canvas.drawRect(0 , 0, getWidth(), getHeight(), mPaint);
}
public void drawRadial(){
    RadialGradient radial = new RadialGradient(
            getWidth() / 2, getHeight() / 2, getWidth() / 4,
            Color.YELLOW, Color.RED,
            mDefaultTileMode
    );
    mPaint.setShader(radial);
}

SweepGradient(float cx, float cy, int color0, int color1)
SweepGradient(float cx, float cy, int[] colors, float[] positions)

@Override
protected void onDraw(Canvas canvas) {
    canvas.drawCircle(getWidth() / 2, getHeight() / 2, getWidth() / 4, mPaint);
}
public void drawSweep(){
    //SweepGradient sweep = new SweepGradient(getWidth() /2, getHeight() / 2, Color.GREEN, Color.BLUE);
    int[] colors = {Color.RED, Color.WHITE, Color.YELLOW};
    float[] positions = {0f, 0.75f, 0f};
    SweepGradient sweep = new SweepGradient(getWidth() / 2 , getHeight() / 2, colors, positions);
    mPaint.setShader(sweep);
}

public class Main {
    private static Executor executor = Executors.newFixedThreadPool(10);
    public static void main(String[] args){
        for(int i = 0; i < 20; i++){
            executor.execute(new Task());
        }
    }
    private static class Task implements Runnable{
        public void run(){
            System.out.println(Thread.currentThread().getName());
        }
    }
}

/**
 * Creates a new {@code ThreadPoolExecutor} with the given initial
 * parameters and default thread factory and rejected execution handler.
 * It may be more convenient to use one of the {@link Executors} factory
 * methods instead of this general purpose constructor.
 *
 * @param corePoolSize the number of threads to keep in the pool, even
 *        if they are idle, unless {@code allowCoreThreadTimeOut} is set
 * @param maximumPoolSize the maximum number of threads to allow in the
 *        pool
 * @param keepAliveTime when the number of threads is greater than
 *        the core, this is the maximum time that excess idle threads
 *        will wait for new tasks before terminating.
 * @param unit the time unit for the {@code keepAliveTime} argument
 * @param workQueue the queue to use for holding tasks before they are
 *        executed.  This queue will hold only the {@code Runnable}
 *        tasks submitted by the {@code execute} method.
 * @throws IllegalArgumentException if one of the following holds:<br>
 *         {@code corePoolSize < 0}<br>
 *         {@code keepAliveTime < 0}<br>
 *         {@code maximumPoolSize <= 0}<br>
 *         {@code maximumPoolSize < corePoolSize}
 * @throws NullPointerException if {@code workQueue} is null
 */
public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
         Executors.defaultThreadFactory(), defaultHandler);
}

DefaultThreadFactory() {
            SecurityManager s = System.getSecurityManager();
            group = (s != null) ? s.getThreadGroup() :
                                  Thread.currentThread().getThreadGroup();
            namePrefix = "pool-" +
                          poolNumber.getAndIncrement() +
                         "-thread-";
        }

/**
    * Creates a thread pool that reuses a fixed number of threads
    * operating off a shared unbounded queue.  At any point, at most
    * {@code nThreads} threads will be active processing tasks.
    * If additional tasks are submitted when all threads are active,
    * they will wait in the queue until a thread is available.
    * If any thread terminates due to a failure during execution
    * prior to shutdown, a new one will take its place if needed to
    * execute subsequent tasks.  The threads in the pool will exist
    * until it is explicitly {@link ExecutorService#shutdown shutdown}.
    *
    * @param nThreads the number of threads in the pool
    * @return the newly created thread pool
    * @throws IllegalArgumentException if {@code nThreads <= 0}
    */
   public static ExecutorService newFixedThreadPool(int nThreads) {
       return new ThreadPoolExecutor(nThreads, nThreads,
                                     0L, TimeUnit.MILLISECONDS,
                                     new LinkedBlockingQueue<Runnable>());
   }

/**
  * Creates a thread pool that creates new threads as needed, but
  * will reuse previously constructed threads when they are
  * available.  These pools will typically improve the performance
  * of programs that execute many short-lived asynchronous tasks.
  * Calls to {@code execute} will reuse previously constructed
  * threads if available. If no existing thread is available, a new
  * thread will be created and added to the pool. Threads that have
  * not been used for sixty seconds are terminated and removed from
  * the cache. Thus, a pool that remains idle for long enough will
  * not consume any resources. Note that pools with similar
  * properties but different details (for example, timeout parameters)
  * may be created using {@link ThreadPoolExecutor} constructors.
  *
  * @return the newly created thread pool
  */
 public static ExecutorService newCachedThreadPool() {
     return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                   60L, TimeUnit.SECONDS,
                                   new SynchronousQueue<Runnable>());
 }

void helloWorld(){
  print("%s", "helloWorld");
}

/** Class, interface (including annotation type), or enum declaration */
TYPE,
/** Field declaration (includes enum constants) */
FIELD,
/** Method declaration */
METHOD,
/** Formal parameter declaration */
PARAMETER,
/** Constructor declaration */
CONSTRUCTOR,
/** Local variable declaration */
LOCAL_VARIABLE,
/** Annotation type declaration */
ANNOTATION_TYPE,
/** Package declaration */
PACKAGE,
/**
 * Type parameter declaration
 *
 * @since 1.8
 */
TYPE_PARAMETER,
/**
 * Use of a type
 *
 * @since 1.8
 */
TYPE_USE

@Target(ElementType.TYPE)
public @interface Table {
    /**
     * 数据表名称注解，默认值为类名称
     * @return
     */
    public String tableName() default "className";
}