- 浏览: 2203870 次
- 性别:
- 来自: 北京
文章分类
- 全部博客 (1240)
- mac/IOS (287)
- flutter (1)
- J2EE (115)
- android基础知识 (582)
- android中级知识 (55)
- android组件(Widget)开发 (18)
- android 错误 (21)
- javascript (18)
- linux (70)
- 树莓派 (18)
- gwt/gxt (1)
- 工具(IDE)/包(jar) (18)
- web前端 (17)
- java 算法 (8)
- 其它 (5)
- chrome (7)
- 数据库 (8)
- 经济/金融 (0)
- english (2)
- HTML5 (7)
- 网络安全 (14)
- 设计欣赏/设计窗 (8)
- 汇编/C (8)
- 工具类 (4)
- 游戏 (5)
- 开发频道 (5)
- Android OpenGL (1)
- 科学 (4)
- 运维 (0)
- 好东西 (6)
- 美食 (1)
最新评论
-
liangzai_cool:
请教一下,文中,shell、C、Python三种方式控制led ...
树莓派 - MAX7219 -
jiazimo:
...
Kafka源码分析-序列5 -Producer -RecordAccumulator队列分析 -
hp321:
Windows该命令是不是需要安装什么软件才可以?我试过不行( ...
ImageIO读jpg的时候出现javax.imageio.IIOException: Unsupported Image Type -
hp321:
Chenzh_758 写道其实直接用一下代码就可以解决了:JP ...
ImageIO读jpg的时候出现javax.imageio.IIOException: Unsupported Image Type -
huanghonhpeng:
大哥你真强什么都会,研究研究。。。。小弟在这里学到了很多知识。 ...
android 浏览器
一:无大小限制的线程池执行效果如下
二:限制按顺序来执行任务的线程池效果如下
三:一个一个任务的执行线程池效果如下(与按顺序执行效果是一样的,只是内部实现稍有不同)
四:按指定个数来执行任务的线程池效果如下
五:创建一个可在指定时间里执行任务的线程池,亦可重复执行,不常用,效果与四相同
六:按指定工厂模式来执行的线程池,效果与四、五一样,但用方式六创建的线程池都有在工厂中指定的线程属性,
比如:线程名字、是否为用户线程等等属性
七:线程池中任务执行时可暂停效果图如下
八:用Runnable、ConcurrentLinkedQueue、ConcurrentMap、Future、ExecutorService关联实现的效果图如下
哦的了,效果看完了,现在就请大家自行修改AndroidManifest.xml中主Activity的入口来看两种不同方式实现的代码效果吧,首先,先贴一下Main.java类的代码,希望大家详细看里面的注释,一定要详细看,你不会吃亏的,相信我!
方式一(纯ExecutorService、AsyncTask、Runnable关联实现相关文件如下):
1.1:主类文件(Main.java)
1.2:布局文件
方式二(Runnable、ConcurrentLinkedQueue、ConcurrentMap、Future、ExecutorService关联实现的相关文件如 下):
2.1:主类文件(MyRunnableActivity.java)
2.2:辅助类(MyRunnable.java)
2.3:布局文件
方式一、方式二的全局配置文件AndroidManifest.xml文件的配置如下:
二:限制按顺序来执行任务的线程池效果如下
三:一个一个任务的执行线程池效果如下(与按顺序执行效果是一样的,只是内部实现稍有不同)
四:按指定个数来执行任务的线程池效果如下
五:创建一个可在指定时间里执行任务的线程池,亦可重复执行,不常用,效果与四相同
六:按指定工厂模式来执行的线程池,效果与四、五一样,但用方式六创建的线程池都有在工厂中指定的线程属性,
比如:线程名字、是否为用户线程等等属性
七:线程池中任务执行时可暂停效果图如下
八:用Runnable、ConcurrentLinkedQueue、ConcurrentMap、Future、ExecutorService关联实现的效果图如下
哦的了,效果看完了,现在就请大家自行修改AndroidManifest.xml中主Activity的入口来看两种不同方式实现的代码效果吧,首先,先贴一下Main.java类的代码,希望大家详细看里面的注释,一定要详细看,你不会吃亏的,相信我!
方式一(纯ExecutorService、AsyncTask、Runnable关联实现相关文件如下):
1.1:主类文件(Main.java)
/* * FileName: Main.java * CopyRight: Belong to <XiaoMaGuo Technologies > own * Description: <description> * Modify By : XiaoMaGuo ^_^ * Modify Date: 2013-10-15 * Follow Order No.: <Follow Order No.> * Modify Order No.: <Modify Order No.> * Modify Content: <modify content > */ package com.xiaoma.threadpooltest; import java.util.ArrayList; import java.util.List; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.ThreadFactory; import android.annotation.TargetApi; import android.app.Activity; import android.content.Context; import android.os.AsyncTask; import android.os.Build; import android.os.Bundle; import android.os.SystemClock; import android.util.AttributeSet; import android.util.Log; import android.view.LayoutInflater; import android.view.View; import android.view.ViewGroup; import android.widget.AdapterView; import android.widget.AdapterView.OnItemClickListener; import android.widget.BaseAdapter; import android.widget.LinearLayout; import android.widget.ListView; import android.widget.ProgressBar; import android.widget.TextView; import android.widget.Toast; /** * @TODO [The Class File Description] * @author XiaoMaGuo ^_^ * @version [version-code, 2013-10-15] * @since [Product/module] */ @TargetApi(Build.VERSION_CODES.HONEYCOMB) public class Main extends Activity { private static int order = 0; /** 总共多少任务(根据CPU个数决定创建活动线程的个数,这样取的好处就是可以让手机承受得住) */ // private static final int count = Runtime.getRuntime().availableProcessors() * 3 + 2; /** 总共多少任务(我是在模拟器里面跑的,为了效果明显,所以写死了为10个,如果在手机上的话,推荐使用上面的那个count) */ private static final int count = 10; /** 每次只执行一个任务的线程池 */ private static ExecutorService singleTaskExecutor = null; /** 每次执行限定个数个任务的线程池 */ private static ExecutorService limitedTaskExecutor = null; /** 所有任务都一次性开始的线程池 */ private static ExecutorService allTaskExecutor = null; /** 创建一个可在指定时间里执行任务的线程池,亦可重复执行 */ private static ExecutorService scheduledTaskExecutor = null; /** 创建一个可在指定时间里执行任务的线程池,亦可重复执行(不同之处:使用工程模式) */ private static ExecutorService scheduledTaskFactoryExecutor = null; private List<AsyncTaskTest> mTaskList = null; /** 任务是否被取消 */ private boolean isCancled = false; /** 是否点击并取消任务标示符 */ private boolean isClick = false; /** 线程工厂初始化方式一 */ ThreadFactory tf = Executors.defaultThreadFactory(); /** 线程工厂初始化方式二 */ private static class ThreadFactoryTest implements ThreadFactory { @Override public Thread newThread(Runnable r) { Thread thread = new Thread(r); thread.setName("XiaoMaGuo_ThreadFactory"); thread.setDaemon(true); // 将用户线程变成守护线程,默认false return thread; } } static { singleTaskExecutor = Executors.newSingleThreadExecutor();// 每次只执行一个线程任务的线程池 limitedTaskExecutor = Executors.newFixedThreadPool(3);// 限制线程池大小为7的线程池 allTaskExecutor = Executors.newCachedThreadPool(); // 一个没有限制最大线程数的线程池 scheduledTaskExecutor = Executors.newScheduledThreadPool(3);// 一个可以按指定时间可周期性的执行的线程池 scheduledTaskFactoryExecutor = Executors.newFixedThreadPool(3, new ThreadFactoryTest());// 按指定工厂模式来执行的线程池 scheduledTaskFactoryExecutor.submit(new Runnable() { @Override public void run() { Log.i("KKK", "This is the ThreadFactory Test submit Run! ! ! "); } }); }; @Override public void onCreate(Bundle icicle) { super.onCreate(icicle); setContentView(R.layout.demo); final ListView taskList = (ListView)findViewById(R.id.task_list); taskList.setAdapter(new AsyncTaskAdapter(getApplication(), count)); taskList.setOnItemClickListener(new OnItemClickListener() { @Override public void onItemClick(AdapterView<?> parent, View view, int position, long id) { if (position == 0) // 以第一项为例,来测试关闭线程池 { /** * 会关闭线程池方式一:但不接收新的Task,关闭后,正在等待 执行的任务不受任何影响,会正常执行,无返回值! */ // allTaskExecutor.shutdown(); /** * 会关闭线程池方式二:也不接收新的Task,并停止正等待执行的Task(也就是说, 执行到一半的任务将正常执行下去),最终还会给你返回一个正在等待执行但线程池关闭却没有被执行的Task集合! */ List<Runnable> unExecRunn = allTaskExecutor.shutdownNow(); for (Runnable r : unExecRunn) { Log.i("KKK", "未执行的任务信息:=" + unExecRunn.toString()); } Log.i("KKK", "Is shutdown ? = " + String.valueOf(allTaskExecutor.isShutdown())); allTaskExecutor = null; } // 以第二项为例来测试是否取消执行的任务 AsyncTaskTest sat = mTaskList.get(1); if (position == 1) { if (!isClick) { sat.cancel(true); isCancled = true; isClick = !isClick; } else { sat.cancel(false); isCancled = false; // isClick = false; isClick = !isClick; if (null != sat && sat.getStatus() == AsyncTask.Status.RUNNING) { if (sat.isCancelled()) { sat = new AsyncTaskTest(sat.mTaskItem); } else { Toast.makeText(Main.this, "A task is already running, try later", Toast.LENGTH_SHORT) .show(); } } /** * 由于上面测试关闭,在不重新生成allTaskExecutor的同时,会报异常(没有可以使用的线程池,故此处重新生成线程池对象) */ if (allTaskExecutor == null) { allTaskExecutor = Executors.newCachedThreadPool(); } sat.executeOnExecutor(allTaskExecutor); // The task is already running(这也是个异常哦,小心使用! ) } } else { sat.cancel(false); isCancled = false; // sat.execute(sat.mTaskItem); // sat.executeOnExecutor(allTaskExecutor); } } }); } /** * @TODO [ListView Item的条目适配器] * @author XiaoMaGuo ^_^ * @version [version-code, 2013-10-22] * @since [Product/module] */ private class AsyncTaskAdapter extends BaseAdapter { private Context mContext; private LayoutInflater mFactory; private int mTaskCount; public AsyncTaskAdapter(Context context, int taskCount) { mContext = context; mFactory = LayoutInflater.from(mContext); mTaskCount = taskCount; mTaskList = new ArrayList<AsyncTaskTest>(taskCount); } @Override public int getCount() { return mTaskCount; } @Override public Object getItem(int position) { return mTaskList.get(position); } @Override public long getItemId(int position) { return position; } @Override public View getView(int position, View convertView, ViewGroup parent) { if (convertView == null) { convertView = mFactory.inflate(R.layout.list_view_item, null); AsyncTaskTest task = new AsyncTaskTest((MyListItem)convertView); /** * 下面两种任务执行效果都一样,形变质不变 * */ // task.execute(); // task.executeOnExecutor(AsyncTask.SERIAL_EXECUTOR); /** * 下面的方式在小于API 11级时效果是一样的,但在高版本中的稍微有点不同,可以看以下AsyncTask核心变量的定义就知道了使用如下 * 方式时,系统会默认的采用五个一组,五个一组的方式来执行我们的任务,定义在:AsyncTask.class中,private static final int CORE_POOL_SIZE = 5; * */ // use AsyncTask#THREAD_POOL_EXECUTOR is the same to older version #execute() (less than API 11) // but different from newer version of #execute() // task.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR); /** * 一个一个执行我们的任务,效果与按顺序执行是一样的(AsyncTask.SERIAL_EXECUTOR) * */ // task.executeOnExecutor(singleTaskExecutor); /** * 按我们指定的个数来执行任务的线程池 * */ // task.executeOnExecutor(limitedTaskExecutor); /** * 不限定指定个数的线程池,也就是说:你往里面放了几个任务,他全部同一时间开始执行, 不管你手机受得了受不了 * */ task.executeOnExecutor(allTaskExecutor); /** * 创建一个可在指定时间里执行任务的线程池,亦可重复执行 * */ // task.executeOnExecutor(scheduledTaskExecutor); /** * 创建一个按指定工厂模式来执行任务的线程池,可能比较正规,但也不常用 */ // task.executeOnExecutor(scheduledTaskFactoryExecutor); mTaskList.add(task); } return convertView; } } class AsyncTaskTest extends AsyncTask<Void, Integer, Void> { private MyListItem mTaskItem; private String id; private AsyncTaskTest(MyListItem item) { mTaskItem = item; if (order < count || order == count) { id = "执行:" + String.valueOf(++order); } else { order = 0; id = "执行:" + String.valueOf(++order); } } @Override protected void onPreExecute() { mTaskItem.setTitle(id); } /** * Overriding methods */ @Override protected void onCancelled() { super.onCancelled(); } @Override protected Void doInBackground(Void... params) { if (!isCancelled() && isCancled == false) // 这个地方很关键,如果不设置标志位的话,直接setCancel(true)是无效的 { int prog = 0; /** * 下面的while中,小马写了个分支用来做个假象(任务东西刚开始下载的时候,速度快,快下载完成的时候就突然间慢了下来的效果, 大家可以想象一下,类似 * :PP手机助手、91手机助手中或其它手机应用中,几乎都有这个假象,开始快,结束时就下载变慢了,讲白了 就是开发的人不想让你在下载到大于一半的时候,也就是快下载完的时候去点取消,你那样得多浪费 * !所以造个假象,让你不想去取消而已) */ while (prog < 101) { if ((prog > 0 || prog == 0) && prog < 70) // 小于70%时,加快进度条更新 { SystemClock.sleep(100); } else // 大于70%时,减慢进度条更新 { SystemClock.sleep(300); } publishProgress(prog); // 更新进度条 prog++; } } return null; } @Override protected void onPostExecute(Void result) { } @Override protected void onProgressUpdate(Integer... values) { mTaskItem.setProgress(values[0]); // 设置进度 } } } /** * @TODO [一个简单的自定义 ListView Item] * @author XiaoMaGuo ^_^ * @version [version-code, 2013-10-22] * @since [Product/module] */ class MyListItem extends LinearLayout { private TextView mTitle; private ProgressBar mProgress; public MyListItem(Context context, AttributeSet attrs) { super(context, attrs); } public MyListItem(Context context) { super(context); } public void setTitle(String title) { if (mTitle == null) { mTitle = (TextView)findViewById(R.id.task_name); } mTitle.setText(title); } public void setProgress(int prog) { if (mProgress == null) { mProgress = (ProgressBar)findViewById(R.id.task_progress); } mProgress.setProgress(prog); } }
1.2:布局文件
<?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" android:layout_height="match_parent" android:paddingLeft="10dip" android:paddingRight="10dip" android:orientation="vertical" > <ListView android:id="@+id/task_list" android:layout_width="fill_parent" android:layout_height="wrap_content" android:divider="#cccccc" android:dividerHeight="0.6dip" android:footerDividersEnabled="true" android:headerDividersEnabled="true" /> </LinearLayout>
方式二(Runnable、ConcurrentLinkedQueue、ConcurrentMap、Future、ExecutorService关联实现的相关文件如 下):
2.1:主类文件(MyRunnableActivity.java)
/* * FileName: MyRunnableActivity.java * CopyRight: Belong to <XiaoMaGuo Technologies > own * Description: <description> * Modify By : XiaoMaGuo ^_^ * Modify Date: 2013-10-21 * Follow Order No.: <Follow Order No.> * Modify Order No.: <Modify Order No.> * Modify Content: <modify content > */ package com.xiaoma.threadpooltest; import java.util.Iterator; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentLinkedQueue; import java.util.concurrent.ConcurrentMap; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.Future; 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.view.View.OnClickListener; import android.widget.ProgressBar; import android.widget.Toast; /** * @TODO [线程池控制 ] * @author XiaoMaGuo ^_^ * @version [version-code, 2013-10-22] * @since [Product/module] */ public class MyRunnableActivity extends Activity implements OnClickListener { /** 任务执行队列 */ private ConcurrentLinkedQueue<MyRunnable> taskQueue = null; /** * 正在等待执行或已经完成的任务队列 * * 备注:Future类,一个用于存储异步任务执行的结果,比如:判断是否取消、是否可以取消、是否正在执行、是否已经完成等 * * */ private ConcurrentMap<Future, MyRunnable> taskMap = null; /** * 创建一个不限制大小的线程池 此类主要有以下好处 1,以共享的无界队列方式来运行这些线程. 2,执行效率高。 3,在任意点,在大多数 nThreads 线程会处于处理任务的活动状态 * 4,如果在关闭前的执行期间由于失败而导致任何线程终止,那么一个新线程将代替它执行后续的任务(如果需要)。 * * */ private ExecutorService mES = null; /** 在此类中使用同步锁时使用如下lock对象即可,官方推荐的,不推荐直接使用MyRunnableActivity.this类型的,可以详细读一下/framework/app下面的随便一个项目 */ private Object lock = new Object(); /** 唤醒标志,是否唤醒线程池工作 */ private boolean isNotify = true; /** 线程池是否处于运行状态(即:是否被释放!) */ private boolean isRuning = true; /** 任务进度 */ private ProgressBar pb = null; /** 用此Handler来更新我们的UI */ private Handler mHandler = null; /** * Overriding methods * * @param savedInstanceState */ @Override protected void onCreate(Bundle savedInstanceState) { // TODO Auto-generated method stub super.onCreate(savedInstanceState); setContentView(R.layout.my_runnable_main); init(); } public void init() { pb = (ProgressBar)findViewById(R.id.progressBar1); findViewById(R.id.button1).setOnClickListener(this); findViewById(R.id.button2).setOnClickListener(this); findViewById(R.id.button3).setOnClickListener(this); findViewById(R.id.button4).setOnClickListener(this); findViewById(R.id.button5).setOnClickListener(this); taskQueue = new ConcurrentLinkedQueue<MyRunnable>(); taskMap = new ConcurrentHashMap<Future, MyRunnable>(); if (mES == null) { mES = Executors.newCachedThreadPool(); } // 用于更新ProgressBar进度条 mHandler = new Handler() { /** * Overriding methods * * @param msg */ @Override public void handleMessage(Message msg) { super.handleMessage(msg); pb.setProgress(msg.what); } }; } /** * Overriding methods * * @param v */ @Override public void onClick(View v) { switch (v.getId()) { case R.id.button1: start(); break; case R.id.button2: stop(); break; case R.id.button3: reload(new MyRunnable(mHandler)); break; case R.id.button4: release(); break; case R.id.button5: addTask(new MyRunnable(mHandler)); break; default: break; } } /** * <Summary Description> */ private void addTask(final MyRunnable mr) { mHandler.sendEmptyMessage(0); if (mES == null) { mES = Executors.newCachedThreadPool(); notifyWork(); } if (taskQueue == null) { taskQueue = new ConcurrentLinkedQueue<MyRunnable>(); } if (taskMap == null) { taskMap = new ConcurrentHashMap<Future, MyRunnable>(); } mES.execute(new Runnable() { @Override public void run() { /** * 插入一个Runnable到任务队列中 这个地方解释一下,offer跟add方法,试了下,效果都一样,没区别,官方的解释如下: 1 offer : Inserts the specified * element at the tail of this queue. As the queue is unbounded, this method will never return * {@code false}. 2 add: Inserts the specified element at the tail of this queue. As the queue is * unbounded, this method will never throw {@link IllegalStateException} or return {@code false}. * * * */ taskQueue.offer(mr); // taskQueue.add(mr); notifyWork(); } }); Toast.makeText(MyRunnableActivity.this, "已添加一个新任务到线程池中 !", 0).show(); } /** * <Summary Description> */ private void release() { Toast.makeText(MyRunnableActivity.this, "释放所有占用的资源!", 0).show(); /** 将ProgressBar进度置为0 */ mHandler.sendEmptyMessage(0); isRuning = false; Iterator iter = taskMap.entrySet().iterator(); while (iter.hasNext()) { Map.Entry<Future, MyRunnable> entry = (Map.Entry<Future, MyRunnable>)iter.next(); Future result = entry.getKey(); if (result == null) { continue; } result.cancel(true); taskMap.remove(result); } if (null != mES) { mES.shutdown(); } mES = null; taskMap = null; taskQueue = null; } /** * <Summary Description> */ private void reload(final MyRunnable mr) { mHandler.sendEmptyMessage(0); if (mES == null) { mES = Executors.newCachedThreadPool(); notifyWork(); } if (taskQueue == null) { taskQueue = new ConcurrentLinkedQueue<MyRunnable>(); } if (taskMap == null) { taskMap = new ConcurrentHashMap<Future, MyRunnable>(); } mES.execute(new Runnable() { @Override public void run() { /** 插入一个Runnable到任务队列中 */ taskQueue.offer(mr); // taskQueue.add(mr); notifyWork(); } }); mES.execute(new Runnable() { @Override public void run() { if (isRuning) { MyRunnable myRunnable = null; synchronized (lock) { myRunnable = taskQueue.poll(); // 从线程队列中取出一个Runnable对象来执行,如果此队列为空,则调用poll()方法会返回null if (myRunnable == null) { isNotify = true; } } if (myRunnable != null) { taskMap.put(mES.submit(myRunnable), myRunnable); } } } }); } /** * <Summary Description> */ private void stop() { Toast.makeText(MyRunnableActivity.this, "任务已被取消!", 0).show(); for (MyRunnable runnable : taskMap.values()) { runnable.setCancleTaskUnit(true); } } /** * <Summary Description> */ private void start() { if (mES == null || taskQueue == null || taskMap == null) { Log.i("KKK", "某资源是不是已经被释放了?"); return; } mES.execute(new Runnable() { @Override public void run() { if (isRuning) { MyRunnable myRunnable = null; synchronized (lock) { myRunnable = taskQueue.poll(); // 从线程队列中取出一个Runnable对象来执行,如果此队列为空,则调用poll()方法会返回null if (myRunnable == null) { isNotify = true; // try // { // myRunnable.wait(500); // } // catch (InterruptedException e) // { // e.printStackTrace(); // } } } if (myRunnable != null) { taskMap.put(mES.submit(myRunnable), myRunnable); } } } }); } private void notifyWork() { synchronized (lock) { if (isNotify) { lock.notifyAll(); isNotify = !isNotify; } } } }
2.2:辅助类(MyRunnable.java)
/* * FileName: MyRunnable.java * CopyRight: Belong to <XiaoMaGuo Technologies > own * Description: <description> * Modify By : XiaoMaGuo ^_^ * Modify Date: 2013-10-21 * Follow Order No.: <Follow Order No.> * Modify Order No.: <Modify Order No.> * Modify Content: <modify content > */ package com.xiaoma.threadpooltest; import android.os.Handler; import android.os.SystemClock; import android.util.Log; /** * @TODO [The Class File Description] * @author XiaoMaGuo ^_^ * @version [version-code, 2013-10-21] * @since [Product/module] */ public class MyRunnable implements Runnable { private boolean cancleTask = false; private boolean cancleException = false; private Handler mHandler = null; public MyRunnable(Handler handler) { mHandler = handler; } /** * Overriding methods */ @Override public void run() { Log.i("KKK", "MyRunnable run() is executed!!! "); runBefore(); if (cancleTask == false) { running(); Log.i("KKK", "调用MyRunnable run()方法"); } runAfter(); } /** * <Summary Description> */ private void runAfter() { Log.i("KKK", "runAfter()"); } /** * <Summary Description> */ private void running() { Log.i("KKK", "running()"); try { // 做点有可能会出异常的事情!!! int prog = 0; if (cancleTask == false && cancleException == false) { while (prog < 101) { if ((prog > 0 || prog == 0) && prog < 70) { SystemClock.sleep(100); } else { SystemClock.sleep(300); } if (cancleTask == false) { mHandler.sendEmptyMessage(prog++); Log.i("KKK", "调用 prog++ = " + (prog)); } } } } catch (Exception e) { cancleException = true; } } /** * <Summary Description> */ private void runBefore() { // TODO Auto-generated method stub Log.i("KKK", "runBefore()"); } public void setCancleTaskUnit(boolean cancleTask) { this.cancleTask = cancleTask; Log.i("KKK", "点击了取消任务按钮 !!!"); // mHandler.sendEmptyMessage(0); } }
2.3:布局文件
<?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" android:layout_height="match_parent" android:orientation="vertical" > <LinearLayout android:layout_width="match_parent" android:layout_height="wrap_content" android:orientation="horizontal" > <Button android:id="@+id/button5" android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:text="添加任务" /> <Button android:id="@+id/button1" android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:text="开始任务" /> <Button android:id="@+id/button2" android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:text="取消任务" /> <Button android:id="@+id/button3" android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:text="重新加载" /> <Button android:id="@+id/button4" android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="1" android:text="释放资源" /> </LinearLayout> <include layout="@layout/my_runnable_merge"/> </LinearLayout>
方式一、方式二的全局配置文件AndroidManifest.xml文件的配置如下:
<?xml version="1.0" encoding="utf-8"?> <manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.xiaoma.threadpooltest" android:versionCode="1" android:versionName="1.0" > <uses-sdk android:minSdkVersion="8" android:targetSdkVersion="15" /> <application android:allowBackup="true" android:icon="@drawable/ic_launcher" android:label="@string/app_name" android:theme="@style/AppTheme" > <activity android:name="Main" android:label="@string/app_name" > <!-- <intent-filter> --> <!-- <action android:name="android.intent.action.MAIN" /> --> <!-- <category android:name="android.intent.category.LAUNCHER" /> --> <!-- </intent-filter> --> </activity> <activity android:name="MyRunnableActivity" android:label="@string/app_name" > <intent-filter> <action android:name="android.intent.action.MAIN" /> <category android:name="android.intent.category.LAUNCHER" /> </intent-filter> </activity> </application> </manifest>
发表评论
-
带你深入理解 FLUTTER 中的字体“冷”知识
2020-08-10 23:40 635本篇将带你深入理解 Flutter 开发过程中关于字体和文 ... -
Flutter -自定义日历组件
2020-03-01 17:56 1111颜色文件和屏幕适配的文件 可以自己给定 import ... -
Dart高级(一)——泛型与Json To Bean
2020-02-23 19:13 1005从 Flutter 发布到现在, 越来越多人开始尝试使用 Da ... -
flutter loading、Progress进度条
2020-02-21 17:03 1181Flutter Progress 1 条形无固定值进度条 ... -
Flutter使用Https加载图片
2020-02-21 01:39 1020Flutter使用Https加载图片 使用http加载图片出 ... -
flutter shared_preferences 异步变同步
2020-02-21 00:55 848前言 引用 在开发原生iOS或Native应用时,一般有判断上 ... -
Flutter TextField边框颜色
2020-02-19 21:31 937监听要销毁 myController.dispose(); T ... -
flutter Future的正确用法
2020-02-18 21:55 808在flutter中经常会用到异步任务,dart中异步任务异步处 ... -
记一次Flutter简单粗暴处理HTTPS证书检验方法
2020-02-18 14:13 979最近在做Flutter项目到了遇到一个无解的事情,当使用Ima ... -
flutter 获取屏幕宽度高度 通知栏高度等屏幕信息
2019-07-27 08:39 1344##MediaQuery MediaQuery.of(con ... -
关于flutter RefreshIndicator扩展listview下拉刷新的问题
2019-07-10 19:40 1141当条目过少时listview某些嵌套情况下可能不会滚动(条目 ... -
flutter listview 改变状态的时候一直无限添加
2019-07-10 16:01 790setstate的时候会一直无限的调用listview.bui ... -
Flutter Android端启动白屏问题的解决
2019-07-09 00:51 1525问题描述 Flutter 应用在 Android 端上启动时 ... -
Flutter中SnackBar使用
2019-07-08 23:43 781底部弹出,然后在指定时间后消失。 注意: build(Bui ... -
Flutter 之点击空白区域收起键盘
2019-07-08 18:43 1792点击空白处取消TextField焦点这个需求是非常简单的,在学 ... -
Flutter 弹窗 Dialog ,AlertDialog,IOS风格
2019-07-08 18:04 1383import 'package:flutter/mate ... -
flutter ---TextField 之 输入类型、长度限制
2019-07-08 14:30 2337TextField想要实现输入类型、长度限制需要先引入impo ... -
【flutter 溢出BUG】键盘上显示bottom overflowed by 104 PIXELS
2019-07-08 11:13 1567一开始直接使用Scaffold布局,body:new Colu ... -
解决Flutter项目卡在Initializing gradle...界面的问题
2019-07-07 12:53 880Flutter最近很火,我抽出了一点时间对Flutter进行了 ... -
关于android O 上 NotificationChannel 的一些注意事项
2019-07-04 11:47 941最近在适配android O,遇到个问题,应用中原本有设置界面 ...
相关推荐
在Android中,我们通常使用`java.util.concurrent`包下的`ExecutorService`和`ThreadPoolExecutor`来创建线程池。线程池可以避免频繁创建和销毁线程带来的性能开销,提高系统资源的利用率。通过合理配置线程池的参数...
android线程池管理工具类,用来管理线程的一些操作,避免重复new线程造成的资源浪费
本文将深入探讨`android线程池`的概念、工作原理以及如何在实际项目中实现一个简单的应用。 ### 线程池简介 线程池是由多个线程组成的集合,它预先创建了一定数量的线程,当有任务需要执行时,线程池会从已存在的...
在Android中,我们通常使用`java.util.concurrent`包下的`ExecutorService`接口和其相关的类来创建线程池。 线程池的核心概念包括: 1. 工作线程(Worker Threads):线程池中的线程,负责执行任务。 2. 任务队列...
本示例将详细介绍如何在Android中使用两种主要的线程池:ThreadPoolExecutor和ScheduledExecutorService。 ThreadPoolExecutor是Java并发库中提供的一个基础线程池实现,它允许开发者自定义核心线程数、最大线程数...
"android线程池案例"提供了这样的示例,用于演示如何在Android应用程序中有效地使用线程池,并结合进度条来显示任务的执行状态。 线程池的核心概念包括: 1. **ExecutorService**: Java的`ExecutorService`接口是...
总之,Android线程池下载是一种优化网络请求的方法,通过合理配置线程池和使用HTTP协议,可以实现高效、稳定的文件下载。这涉及到多线程编程、网络通信、文件IO等多个方面,对提升Android应用的性能和用户体验具有...
在Android应用开发中,线程池的使用是提高性能和优化资源管理的重要手段。线程池允许我们预先创建一定数量的线程,处理并发任务,而不是每次需要时都创建新线程,这样可以减少系统资源的消耗,提高响应速度。本示例...
ThreadPoolExecutor的使用和Android常见的4种线程池使用介绍
在Android中,我们经常使用`java.util.concurrent`包下的`ExecutorService`、`ThreadPoolExecutor`等类来创建和管理线程池。线程池允许我们预先配置一组工作线程,以便在需要时能够快速响应任务提交,避免频繁创建和...
总结,这个"Java/Android线程池演示Demo"旨在通过实例展示如何在Android和Java项目中使用线程池进行并发处理,帮助开发者理解线程池的工作原理和优势,以及如何根据应用需求配置和管理线程池。通过分析和实践这个...
在"android中线程池demo"中,我们将探讨如何在Android应用中使用线程池来实现异步加载图片,以提升用户体验。 线程池的概念源于Java的ExecutorService,Android中主要通过`java.util.concurrent`包下的`...
在Android应用中,正确地使用线程池可以显著提高应用程序的性能和响应性,避免因大量并发任务导致的系统资源过度消耗。 1. **线程池的概念** 线程池是一种多线程处理形式,处理过程中将任务添加到队列,然后在创建...
在Android开发中,线程池是一种管理线程的机制,它可以帮助我们更高效地调度并发任务,优化系统资源的使用,防止过多线程导致的系统性能下降或崩溃。本篇文章将深入探讨四种主要的线程池类型及其实现,旨在帮助...
在Android中,我们经常使用`ExecutorService`和`ThreadPoolExecutor`来实现线程池。线程池可以有效地控制运行的线程数量,避免过多线程导致系统资源的浪费,并且能对线程进行管理和监控,如设置最大线程数、核心线程...
Android线程池在图像加载中的应用总结
Android Handler模拟线程池并发下载网络图片实现照片墙
本项目旨在通过实践让你快速掌握Android中的线程池使用和原理。 首先,我们来了解一下什么是线程池。线程池是一种多线程处理形式,处理过程中将任务添加到队列,然后在创建线程后自动启动这些任务。相较于为每个...
本篇文章将探讨四个核心概念:线程池、信号量、Looper以及缓存,它们在构建高性能、响应迅速的Android应用程序中扮演着重要角色。 首先,让我们来了解线程池。线程池是一种线程管理机制,它允许多个任务在有限的...
2. **ExecutorService**:在Android中,我们可以使用`java.util.concurrent.ExecutorService`接口来创建和管理线程池。`ExecutorService`提供了调度和执行任务的能力,包括控制并发级别、处理线程异常等。 3. **...