使用ScheduledExecutorService实现闪烁功能

 除了可以改变TextView的Visible属性实现闪烁外，还可以改变TextView的颜色来实现，直接调用开启闪烁定时器即可。

package com.coagent.framelayout;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.view.View;
import android.widget.TextView;

import com.coagent.ievactivity.R;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Twinkle extends Activity {

    private static final String TAG = "Twinkle";

    /**
     * 剩余电量值
     */
    private TextView surplus_electricity;
    /**
     * 续航里程值
     */
    private TextView recharge_mileage;
    /**
     * 续航里程闪烁状态
     */
    private boolean isRechargeTwinkle = false;
    /**
     * 剩余电量闪烁状态
     */
    private boolean isSurplusTwinkle = false;
    /**
     * 续航里程闪烁定时器
     */
    private ScheduledExecutorService mRechargeScheduledService;
    /**
     * 剩余电量闪烁定时器
     */
    private ScheduledExecutorService mSurplusScheduledService;
    /**
     * 闪烁-显示续航里程
     */
    private int SHOW_RECHARGE = 1;
    /**
     * 闪烁-隐藏续航里程
     */
    private int HIDE_RECHARGE = 2;
    /**
     * 闪烁-显示剩余电量
     */
    private int SHOW_SURPLUS = 3;
    /**
     * 闪烁-隐藏剩余电量
     */
    private int HIDE_SURPLUS = 4;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        initView();
    }

    private void initView(){
        surplus_electricity = (TextView) findViewById(R.id.surplus_electricity);
        recharge_mileage = (TextView) findViewById(R.id.recharge_mileage);
    }

    /**
     * 开启续航里程闪烁定时器
     */
    private void startRechargeExecutorService() {
        stopRechargeExecutorService();
        mRechargeScheduledService = Executors.newSingleThreadScheduledExecutor();
        if (mRechargeScheduledService != null) {
            Log.d(TAG, "mRechargeScheduledService定时器启动");
            mRechargeScheduledService.scheduleWithFixedDelay(twinkleRechargeRunnable, 0, 555, TimeUnit.MILLISECONDS);
        }
    }


    /**
     * 结束续航里程闪烁定时器
     */
    private void stopRechargeExecutorService() {
        if (mRechargeScheduledService != null) {
            mRechargeScheduledService.shutdownNow();
        }
        mRechargeScheduledService = null;
    }

    /**
     * 开启剩余电量闪烁定时器
     */
    private void startSurplusExecutorService() {
        stopSurplusExecutorService();
        mSurplusScheduledService = Executors.newSingleThreadScheduledExecutor();
        if (mSurplusScheduledService != null) {
            Log.d(TAG, "mSurplusScheduledService定时器启动");
            mSurplusScheduledService.scheduleWithFixedDelay(twinkleSurplusRunnable, 0, 555, TimeUnit.MILLISECONDS);
        }
    }


    /**
     * 结束剩余电量闪烁定时器
     */
    private void stopSurplusExecutorService() {
        if (mSurplusScheduledService != null) {
            mSurplusScheduledService.shutdownNow();
        }
        mSurplusScheduledService = null;
    }

    /**闪烁逻辑*/
    private Handler mhandler = new Handler(new Handler.Callback() {
        @Override
        public boolean handleMessage(Message msg) {
            if (mRechargeScheduledService != null || mSurplusScheduledService != null) {
                if (msg.what == SHOW_RECHARGE) {
                    recharge_mileage.setVisibility(View.VISIBLE);
                }
                if (msg.what == HIDE_RECHARGE) {
                    recharge_mileage.setVisibility(View.INVISIBLE);
                }
                if (msg.what == SHOW_SURPLUS) {
                    surplus_electricity.setVisibility(View.VISIBLE);
                }
                if (msg.what == HIDE_SURPLUS) {
                    surplus_electricity.setVisibility(View.INVISIBLE);
                }
            }
            return false;
        }
    });

    /**
     * 闪烁线程，用于续航里程闪烁显示
     */
    private Runnable twinkleRechargeRunnable = new Runnable() {
        @Override
        public void run() {
            if (isRechargeTwinkle) {
                Message msg = new Message();
                msg.what = SHOW_RECHARGE;
                mhandler.sendMessage(msg);
                isRechargeTwinkle = false;
            } else {
                Message msg = new Message();
                msg.what = HIDE_RECHARGE;
                mhandler.sendMessage(msg);
                isRechargeTwinkle = true;
            }
        }
    };

    /**
     * 闪烁线程，用于剩余电量闪烁显示
     */
    private Runnable twinkleSurplusRunnable = new Runnable() {
        @Override
        public void run() {
            if (isSurplusTwinkle) {
                Message msg = new Message();
                msg.what = SHOW_SURPLUS;
                mhandler.sendMessage(msg);
                isSurplusTwinkle = false;
            } else {
                Message msg = new Message();
                msg.what = HIDE_SURPLUS;
                mhandler.sendMessage(msg);
                isSurplusTwinkle = true;
            }
        }
    };

}