`
caiwb1990
  • 浏览: 316304 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Android多线程:预读实现

阅读更多
上一篇博文我们可以知道,使用AsyncTask有导致应用FC的风险,而且AsyncTask并不能满足我们一些特定的需求。下面我们介绍一种通过模仿AsyncTask的封装方式,实现一个后台预读数据的线程。

描述:在空闲时对获取成本较高的数据(如要读取本地或网络资源)进行预读是提高性能的有效手段。为了给用户带来更好的交互体验,提高响应性,很多网络应用(如新闻阅读类应用)都在启动的时候进行预读,把网络数据缓存到sdcard或者内存中。

下面介绍一个实现预读的例子,打开应用之后会有一个欢迎界面,在打开欢迎界面的同时我们在后台启动预读线程,预读下一个Activity需要显示的数据,预读数据保存到一个静态的Hashmap中。

首先要编写我们的后台预读线程,遵循不重复造轮子的原则,我们对AsyncTask稍作修改就可以满足需求。下面是我们自定义的PreReadTask类代码:

PreReadTask.java 实现预读线程
package cn.caiwb;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.CancellationException;
import java.util.concurrent.atomic.AtomicInteger;

import android.content.SyncResult;
import android.os.Process;
import android.os.Handler;
import android.os.Message;
public abstract class PreReadTask<Params, Progress, Result> {
    private static final String LOG_TAG = "FifoAsyncTask";

//    private static final int CORE_POOL_SIZE = 5;
//    private static final int MAXIMUM_POOL_SIZE = 5;
//    private static final int KEEP_ALIVE = 1;

//    private static final BlockingQueue<Runnable> sWorkQueue =
//            new LinkedBlockingQueue<Runnable>();
//
    private static final ThreadFactory sThreadFactory = new ThreadFactory() {
        private final AtomicInteger mCount = new AtomicInteger(1);

        public Thread newThread(Runnable r) {
            return new Thread(r, "PreReadTask #" + mCount.getAndIncrement());
        }
    };

    private static final ExecutorService sExecutor = Executors.newSingleThreadExecutor(sThreadFactory);//只有一个工作线程的线程池

    private static final int MESSAGE_POST_RESULT = 0x1;
    private static final int MESSAGE_POST_PROGRESS = 0x2;
    private static final int MESSAGE_POST_CANCEL = 0x3;

    private static final InternalHandler sHandler = new InternalHandler();

    private final WorkerRunnable<Params, Result> mWorker;
    private final FutureTask<Result> mFuture;

    private volatile Status mStatus = Status.PENDING;

    /**
     * Indicates the current status of the task. Each status will be set only once
     * during the lifetime of a task.
     */
    public enum Status {
        /**
         * Indicates that the task has not been executed yet.
         */
        PENDING,
        /**
         * Indicates that the task is running.
         */
        RUNNING,
        /**
         * Indicates that {@link FifoAsyncTask#onPostExecute} has finished.
         */
        FINISHED,
    }

    /**
     * Creates a new asynchronous task. This constructor must be invoked on the UI thread.
     */
    public PreReadTask() {
        mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                return doInBackground(mParams);
            }
        };

        mFuture = new FutureTask<Result>(mWorker) {
            @Override
            protected void done() {
                Message message;
                Result result = null;

                try {
                    result = get();
                } catch (InterruptedException e) {
                    android.util.Log.w(LOG_TAG, e);
                } catch (ExecutionException e) {
                    throw new RuntimeException("An error occured while executing doInBackground()",
                            e.getCause());
                } catch (CancellationException e) {
                    message = sHandler.obtainMessage(MESSAGE_POST_CANCEL,
                            new PreReadTaskResult<Result>(PreReadTask.this, (Result[]) null));
                    message.sendToTarget();
                    return;
                } catch (Throwable t) {
                    throw new RuntimeException("An error occured while executing "
                            + "doInBackground()", t);
                }

                message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
                        new PreReadTaskResult<Result>(PreReadTask.this, result));
                message.sendToTarget();
            }
        };
    }

    /**
     * Returns the current status of this task.
     *
     * @return The current status.
     */
    public final Status getStatus() {
        return mStatus;
    }

    /**
     * Override this method to perform a computation on a background thread. The
     * specified parameters are the parameters passed to {@link #execute}
     * by the caller of this task.
     *
     * This method can call {@link #publishProgress} to publish updates
     * on the UI thread.
     *
     * @param params The parameters of the task.
     *
     * @return A result, defined by the subclass of this task.
     *
     * @see #onPreExecute()
     * @see #onPostExecute
     * @see #publishProgress
     */
    protected abstract Result doInBackground(Params... params);

    /**
     * Runs on the UI thread before {@link #doInBackground}.
     *
     * @see #onPostExecute
     * @see #doInBackground
     */
    protected void onPreExecute() {
    }

    /**
     * Runs on the UI thread after {@link #doInBackground}. The
     * specified result is the value returned by {@link #doInBackground}
     * or null if the task was cancelled or an exception occured.
     *
     * @param result The result of the operation computed by {@link #doInBackground}.
     *
     * @see #onPreExecute
     * @see #doInBackground
     */
    @SuppressWarnings({"UnusedDeclaration"})
    protected void onPostExecute(Result result) {
    }

    /**
     * Runs on the UI thread after {@link #publishProgress} is invoked.
     * The specified values are the values passed to {@link #publishProgress}.
     *
     * @param values The values indicating progress.
     *
     * @see #publishProgress
     * @see #doInBackground
     */
    @SuppressWarnings({"UnusedDeclaration"})
    protected void onProgressUpdate(Progress... values) {
    }

    /**
     * Runs on the UI thread after {@link #cancel(boolean)} is invoked.
     *
     * @see #cancel(boolean)
     * @see #isCancelled()
     */
    protected void onCancelled() {
    }

    /**
     * Returns <tt>true</tt> if this task was cancelled before it completed
     * normally.
     *
     * @return <tt>true</tt> if task was cancelled before it completed
     *
     * @see #cancel(boolean)
     */
    public final boolean isCancelled() {
        return mFuture.isCancelled();
    }

    /**
     * Attempts to cancel execution of this task.  This attempt will
     * fail if the task has already completed, already been cancelled,
     * or could not be cancelled for some other reason. If successful,
     * and this task has not started when <tt>cancel</tt> is called,
     * this task should never run.  If the task has already started,
     * then the <tt>mayInterruptIfRunning</tt> parameter determines
     * whether the thread executing this task should be interrupted in
     * an attempt to stop the task.
     *
     * @param mayInterruptIfRunning <tt>true</tt> if the thread executing this
     *        task should be interrupted; otherwise, in-progress tasks are allowed
     *        to complete.
     *
     * @return <tt>false</tt> if the task could not be cancelled,
     *         typically because it has already completed normally;
     *         <tt>true</tt> otherwise
     *
     * @see #isCancelled()
     * @see #onCancelled()
     */
    public final boolean cancel(boolean mayInterruptIfRunning) {
        return mFuture.cancel(mayInterruptIfRunning);
    }

    /**
     * Waits if necessary for the computation to complete, and then
     * retrieves its result.
     *
     * @return The computed result.
     *
     * @throws CancellationException If the computation was cancelled.
     * @throws ExecutionException If the computation threw an exception.
     * @throws InterruptedException If the current thread was interrupted
     *         while waiting.
     */
    public final Result get() throws InterruptedException, ExecutionException {
        return mFuture.get();
    }

    /**
     * Waits if necessary for at most the given time for the computation
     * to complete, and then retrieves its result.
     *
     * @param timeout Time to wait before cancelling the operation.
     * @param unit The time unit for the timeout.
     *
     * @return The computed result.
     *
     * @throws CancellationException If the computation was cancelled.
     * @throws ExecutionException If the computation threw an exception.
     * @throws InterruptedException If the current thread was interrupted
     *         while waiting.
     * @throws TimeoutException If the wait timed out.
     */
    public final Result get(long timeout, TimeUnit unit) throws InterruptedException,
            ExecutionException, TimeoutException {
        return mFuture.get(timeout, unit);
    }

    /**
     * Executes the task with the specified parameters. The task returns
     * itself (this) so that the caller can keep a reference to it.
     *
     * This method must be invoked on the UI thread.
     *
     * @param params The parameters of the task.
     *
     * @return This instance of AsyncTask.
     *
     * @throws IllegalStateException If {@link #getStatus()} returns either
     *         {@link FifoAsyncTask.Status#RUNNING} or {@link FifoAsyncTask.Status#FINISHED}.
     */
    public final PreReadTask<Params, Progress, Result> execute(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;
        sExecutor.execute(mFuture);

        return this;
    }

    /**
     * This method can be invoked from {@link #doInBackground} to
     * publish updates on the UI thread while the background computation is
     * still running. Each call to this method will trigger the execution of
     * {@link #onProgressUpdate} on the UI thread.
     *
     * @param values The progress values to update the UI with.
     *
     * @see #onProgressUpdate
     * @see #doInBackground
     */
    protected final void publishProgress(Progress... values) {
        sHandler.obtainMessage(MESSAGE_POST_PROGRESS,
                new PreReadTaskResult<Progress>(this, values)).sendToTarget();
    }

    private void finish(Result result) {
        if (isCancelled()) result = null;
        onPostExecute(result);
        mStatus = Status.FINISHED;
    }

    private static class InternalHandler extends Handler {
        @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
        @Override
        public void handleMessage(Message msg) {
        	PreReadTaskResult result = (PreReadTaskResult) msg.obj;
            switch (msg.what) {
                case MESSAGE_POST_RESULT:
                    // There is only one result
                    result.mTask.finish(result.mData[0]);
                    break;
                case MESSAGE_POST_PROGRESS:
                    result.mTask.onProgressUpdate(result.mData);
                    break;
                case MESSAGE_POST_CANCEL:
                    result.mTask.onCancelled();
                    break;
            }
        }
    }

    private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
        Params[] mParams;
    }

    @SuppressWarnings({"RawUseOfParameterizedType"})
    private static class PreReadTaskResult<Data> {
        final PreReadTask mTask;
        final Data[] mData;

        PreReadTaskResult(PreReadTask task, Data... data) {
            mTask = task;
            mData = data;
        }
    }
}



对比AsyncTask我们实际只修改了一个地方

private static final ExecutorService sExecutor = Executors.newSingleThreadExecutor(sThreadFactory);//只有一个工作线程的线程池


通过Executors.newSingleThreadExecutor,我们把PreReadTask的的线程池设置成只有一个工作线程,并且带有一个无边界的缓冲队列,这一个工作线程以先进先出的顺序不断从缓冲队列中取出并执行任务。

创建完后台预读的线程。我们通过一个例子介绍如何使用这个后台预读线程。

这个例子由两个Activity组成,WelcomeActivity是欢迎界面,在欢迎界面中会停留三秒,在此时我们对数据进行预读,预读成功后保存到一个全局的静态hashmap中。MainActivity是主界面,在主界面中显示一个listview,listview中的图片是模拟从网络获取的,当静态hashmap中存在数据(也就是已经成功预读的数据)的时,从hashmap中取,如果不存在,才从网络获取。


WelcomeActivity.java 欢迎界面,停留三秒,预读数据
package cn.caiwb;
import android.app.Activity;
import android.content.Intent;
import android.graphics.BitmapFactory;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.Handler;
import android.widget.Toast;

public class WelcomeActivity extends Activity {
	
	private Handler handler = new Handler();
	
	@Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.welcome);
        for(int i = 0; i < 15; i++) {//预读15张图片
			ReadImgTask task = new ReadImgTask();
			task.execute(String.valueOf(i));
		}
        Toast.makeText(getApplicationContext(), "PreReading...", Toast.LENGTH_LONG).show();
        handler.postDelayed(new Runnable() {
			
			@Override
			public void run() {
				startActivity(new Intent(WelcomeActivity.this, MainActivity.class));//启动MainActivity
				
				finish();
			}
		}, 3000);//显示三秒钟的欢迎界面
    }
	
	class ReadImgTask extends PreReadTask<String, Void, Void> {

		@Override
		protected Void doInBackground(String... arg0) {
			try {
				Thread.sleep(200);//模拟网络延时
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			Data.putData(arg0[0], BitmapFactory.decodeResource(getResources(), R.drawable.icon));//把预读的数据放到hashmap中
			return null;
		}
		
	}
	
}


MainActivity.java 主界面,有一个listview,listview中显示图片和文字,模拟图片从网络异步获取
package cn.caiwb
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.Dialog;
import android.app.ListActivity;
import android.app.ProgressDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.AsyncTask;
import android.os.Bundle;
import android.provider.ContactsContract;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AbsListView;
import android.widget.AbsListView.OnScrollListener;
import android.widget.Adapter;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.BaseAdapter;
import android.widget.GridView;
import android.widget.ImageView;
import android.widget.ListAdapter;
import android.widget.ListView;
import android.widget.SimpleAdapter;
import android.widget.TextView;
import android.widget.Toast;

public class MainActivity extends Activity {
    
    
	private ListView mListView;
	private List<HashMap<String, Object>> mData;
	
	private BaseAdapter mAdapter;
	
	
	@Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        mListView = (ListView) findViewById(R.id.listview);
        mData = new ArrayList<HashMap<String,Object>>();
        mAdapter = new CustomAdapter();
        
        mListView.setAdapter(mAdapter);
        for(int i = 0; i < 100; i++) {//初始化100项数据
        	HashMap data = new HashMap<String, Object>();
        	data.put("title", "title" + i);
        	mData.add(data);
        }
    }
	
	


	class CustomAdapter extends BaseAdapter {

		
		CustomAdapter() {
			
		}
		
		@Override
		public int getCount() {
			return mData.size();
		}

		@Override
		public Object getItem(int position) {
			return mData.get(position);
		}

		@Override
		public long getItemId(int position) {
			return 0;
		}

		@Override
		public View getView(int position, View convertView, ViewGroup parent) {
			View view = convertView;
			ViewHolder vh;
			if(view == null) {
				view = LayoutInflater.from(MainActivity.this).inflate(R.layout.list_item, null);
				vh = new ViewHolder();
				vh.tv = (TextView) view.findViewById(R.id.textView);
				vh.iv = (ImageView) view.findViewById(R.id.imageView);
				view.setTag(vh);
			}
			vh = (ViewHolder) view.getTag();
			vh.tv.setText((String) mData.get(position).get("title"));
			Bitmap bitmap = (Bitmap) mData.get(position).get("pic");
			if(bitmap != null) {
				vh.iv.setImageBitmap(bitmap);
			}
			else {
				vh.iv.setImageBitmap(null);
			}
			
			AsyncTask task = (AsyncTask) mData.get(position).get("task");
			if(task == null || task.isCancelled()) {
				mData.get(position).put("task", new GetItemImageTask(position).execute(null));//启动线程异步获取图片
			}
			
			return view;
		}

		
		
	}
	
	static class ViewHolder {
		TextView tv;
		ImageView iv;
	}
	
	
	class GetItemImageTask extends AsyncTask<Void, Void, Void> {//获取图片仍采用AsyncTask,这里的优化放到下篇再讨论
		
		int id;
		
		GetItemImageTask(int id) {
			this.id = id;
		}

		@Override
		protected Void doInBackground(Void... params) {
			
			Bitmap bm = (Bitmap) Data.getData(String.valueOf(id));
			if(bm != null) {//如果hashmap中已经有数据,
				mData.get(id).put("pic", bm);
			}
			else {//模拟从网络获取
				try {
					Thread.sleep(200);//模拟网络延时
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				mData.get(id).put("pic", BitmapFactory.decodeResource(getResources(), R.drawable.icon));
			}
			return null;
		}
		
		protected void onPostExecute (Void result) {
			mAdapter.notifyDataSetChanged();
		}
		
	}
	


Data.java 静态的Hashmap保存预读数据

package cn.caiwb;

import java.util.AbstractMap;
import java.util.HashMap;
import java.util.concurrent.ConcurrentHashMap;

public class Data {
	private static AbstractMap<String, Object> mData = new ConcurrentHashMap<String, Object>();
	
	private Data() {
		
	}
	
	public static void putData(String key,Object obj) {
		mData.put(key, obj);
	}
	
	public static Object getData(String key) {
		return mData.get(key);
	}
}




运行结果:





从执行结果可以看到,当进入MainActivity时,listview中的第一屏的图片已经加载好了。

这个简单例子中还不能很好地体现预读带来的用户体验的优势,不过一些应用(如前面提到过的新闻阅读类应用),实现了预读机制,使响应性大大提高,增强了用户体验。

总结:

1、通过实现自定义的AsyncTask来避免AsyncTask引起的FC风险和满足特定的后台异步任务需求

2、实现后台预读可以提高应用的响应性。

3、使用Executors.newSingleThreadExecutor()创建只有一个工作队列的线程池来实现预读需求。

注意:

1、预读队列的工作线程可以不止一个,请根据需求配置自己的线程池。

2、adapter的getview()方法中,我们仍然采用了AsyncTask实现异步获取图片,以后我们将探讨更好的解决办法,在提高响应性的同时,避免了AyncTask带来的FC风险

3、预读也要控制成本,存储空间、耗电和流量都是要考虑的因素。


OK,睡了,明天早上还得早起~~
  • 大小: 25.3 KB
  • 大小: 23 KB
1
1
分享到:
评论
1 楼 进退取舍 2012-08-27  
楼主,把布局文件也贴出来吧!多谢!!

相关推荐

    Android多线程任务优化2:实现后台预读线程

    本篇文章将深入探讨如何通过实现后台预读线程来优化多线程任务,提高用户界面的响应速度和整体应用体验。 首先,了解什么是预读。预读是一种策略,它在用户实际需要数据之前就开始加载,旨在减少等待时间,提高流畅...

    Android H265软解码

    - 使用多线程:通过将解码任务分配到多个线程,可以充分利用多核CPU资源。 - 数据预加载:预读取一部分视频数据,减少解码过程中的等待时间。 - 动态调整解码速度:根据设备性能和电池状态,动态调整解码速度,平衡...

    Android TXT阅读器 源代码

    通过分析和学习这个Android TXT阅读器的源代码,开发者可以深入了解Android系统的文件操作、UI设计、多线程编程等关键技能,同时也能掌握编码转换的实践方法,提升自己的Android开发能力。在实践中不断探索和改进,...

    android上实现mp4文件的高效率切割

    此外,可以采用多线程处理,将数据读取和写入分开,提升整体速度。 5. **JNI/Native库**:如果Java层性能不足,可以考虑使用C/C++的FFmpeg库,它提供了更底层的MP4处理能力,可以进行更精确的控制和优化。但这也...

    Android RockPlayer源码.rar

    2. 多线程处理:为了实现流畅的播放体验,RockPlayer使用多线程技术,将任务分解到不同的线程中执行,如主线程负责UI更新,解码线程处理媒体数据,确保播放过程不受用户交互的影响。 二、解码技术 1. 自适应解码:...

    基于Android的多媒体播放器的设计与实现.pdf

    Android操作系统提供了一套丰富的API,使得开发者可以方便地实现多媒体播放功能。以下是对基于Android的多媒体播放器设计与实现的关键知识点的详细说明: 1. **多媒体播放器界面设计**:设计一个多媒体播放器界面,...

    百度tts语音合成demo Android APP

    3. **UI线程与多线程**:官方Demo中通常会建议在后台线程执行耗时操作,以避免阻塞UI线程导致应用无响应。然而,此APP选择在UI线程内执行语音合成,这可能会使主线程负载加重,影响用户界面的响应速度。如果合成过程...

    Android图片声音显示

    - **动画效果**: Android支持帧动画(AnimationDrawable)和属性动画(Property Animation),可实现图片的动态效果,如旋转、淡入淡出等。 2. **声音播放** - **MediaPlayer**: 是Android提供的一个音频播放...

    android音乐播放器源码

    在Android平台上开发一款音乐播放器是一项复杂而有趣的任务,它涉及到多媒体处理、用户界面设计以及系统服务等多个领域的技术。这个"android音乐播放器源码"项目涵盖了以下关键知识点: 1. **多媒体框架...

    android ffmpeg audiotrack

    4. 控制解码速度:确保解码速度与播放速度同步,可以通过预读取一定量的数据来实现。 在实际编码过程中,需要注意FFmpeg的版本兼容性和Android API级别。不同的FFmpeg版本可能支持的特性不同,而低版本的Android...

    Android应用源码之边下载边播music.zip

    - **缓冲和预读**:为了保证流畅播放,应用可能需要实现缓冲区管理和预读机制,预先加载一部分即将播放的数据,防止播放中断。 - **文件流操作**:在下载过程中,文件流操作(如FileOutputStream)用于将接收到的...

    android-socket-nio-master.zip

    在Android开发中,Socket通信是应用层与传输层之间的接口,用于实现设备间的网络通信。传统的Socket通信通常基于BIO(Blocking I/O)模型,但随着高性能和高并发需求的增加,开发者开始转向NIO(Non-blocking I/O)...

    安卓Android源码——RockPlayer源码.zip

    6. **性能优化**:为了实现流畅的播放体验,RockPlayer在源码中进行了多方面的性能优化,如预读机制、内存管理、线程调度等。通过分析这些代码,开发者可以学习到如何在Android平台上进行高效的资源管理和优化。 ...

    Android jni 高斯模糊效果

    1. **并行计算**:利用多线程或者OpenMP等库,将高斯模糊的计算任务分解,实现并行处理,进一步提升效率。 2. **内存管理**:优化内存分配和释放,减少不必要的拷贝操作,以降低内存访问开销。 3. **缓存优化**:...

    libevent-2.1.8-stable-android

    5. **内存管理和线程安全**:libevent库本身是线程安全的,但在多线程环境中使用时,需要正确管理事件基础结构(事件基和事件对象)的生命周期,避免并发访问导致的问题。 6. **性能优化**:libevent提供了多种优化...

    基于Android的rockplayer_ffmpeg.zip

    5. **多线程与异步处理**:为了保证流畅的播放体验,RockPlayer通常会采用多线程技术进行音视频数据的处理和渲染,同时利用异步加载和预读机制,确保播放过程中的无缝切换。 6. **用户界面与交互设计**:除了底层的...

    安卓Android源码——SeeJoPlayer(播放器).zip

    9. **性能优化**:为了提供流畅的播放体验,SeeJoPlayer可能会采用预读取、缓冲区管理、多线程处理等技术来提高性能。 通过对SeeJoPlayer源码的阅读和学习,开发者不仅可以掌握Android多媒体开发的基础,还能深入...

    缓冲池实现

    缓冲池是一种在计算机科学中用于优化数据处理效率的技术,特别是在多线程环境和I/O密集型操作中。标题“缓冲池实现”指的是一种设计策略,它利用内存中的固定大小的数据结构来存储待处理的数据,以便多个线程可以...

    纯底层实现缓冲区算法

    5. **线程安全**:在多线程环境中,如何保证缓冲区的并发访问安全,可能涉及到锁机制、条件变量、原子操作等并发控制技术。 6. **I/O操作优化**:阐述如何通过批量读写、预读取、延迟写入等策略,优化缓冲区的I/O...

    Android-VolleyHttp网络访问框架

    VolleyHttp是一个基于Android平台的网络访问框架,它是由Google为Android应用开发设计的,旨在提供高效的、易于使用的网络通信库。Volley以其快速响应、内存管理优化和强大的请求队列处理而闻名,使得开发者可以更...

Global site tag (gtag.js) - Google Analytics