博客
关于我
强烈建议你试试无所不能的chatGPT,快点击我
Retrofit+RxJava联网工具类
阅读量:5231 次
发布时间:2019-06-14

本文共 5890 字,大约阅读时间需要 19 分钟。

  在python 进程、线程 (一)中简单的说过,CPython中的GIL使得同一时刻只能有一个线程运行,即并发执行。并且即使是多核CPU,GIL使得同一个进程中的多个线程也无法映射到多个CPU上运行,这么做最初是为了安全着想,慢慢的也成为了限制CPython性能的问题。

  
  就像是一个线程想要执行,就必须得到GIL,否则就不能拿到CPU资源。但是也不是说一个线程在拿到CPU资源后就一劳永逸,在执行的过程中GIL可能会释放并被其他线程获取,所以说其它的线程会与本线程竞争CPU资源。
  
  在understand GIL:http://www.dabeaz.com/python/UnderstandingGIL.pdf中有关于GIL释放和GIL的概要。
  
  多线程在python2中:当一个线程进行I/O的时候会释放锁,另外当ticks计数达到100(ticks可以看作是Python自身的一个计数器,也可对比着字节码指令理解,专门做用于GIL,每次释放后归零,这个计数可以通过 sys.setcheckinterval 来调整)。锁释放之后,就涉及到线程的调度,线程的锁进行,线程的切换。这是会消耗CPU资源,因此会造成程序性能问题和等待时延。特别是在CPU密集型代码时。
  
  但是对于多进程,GIL就无法限制,多个进程可以再多个CPU上运行,充分利用多核优势。事情往往是相对的,虽然可以充分利用多核优势,但是进程之间的切换却比线程的切换代价更高。
  
  所以选择多线程还是多进程,主要还是看怎样权衡代价,什么样的情况。
  
  1、CPU密集代码
  
  下面来利用斐波那契数列模拟CPU密集运算。
  
  def fib(n):
  
  # 求斐波那契数列的第n个值
  
  if n<=2:
  
  return 1
  
  return fib(n-1)+fib(n-2)
  
  <1>、多进程
  
  打印第25到35个斐波那契数,并计算程序运行时间
  
  import time
  
  from concurrent.futures import ThreadPoolExecutor, as_completed
  
  from concurrent.futures import ProcessPoolExecutor
  
  def fib(n):
  
  if n<=2:
  
  return 1
  
  return fib(n-1)+fib(n-2)
  
  if __name__ == "__main__":
  
  with ProcessPoolExecutor(3) as executor: # 使用进程池控制 每次执行3个进程
  
  all_task = [executor.submit(fib, (num)) for num in range(25,35)]
  
  start_time = time.time()
  
  for future in as_completed(all_task):
  
  data = future.result()
  
  print("exe result: {}".format(data))
  
  print("last time is: {}".format(time.time()-start_time))
  
  # 输出
  
  exe result: 75025
  
  exe result: 121393
  
  exe result: 196418
  
  exe result: 317811
  
  exe result: 514229
  
  exe result: 832040
  
  exe result: 1346269
  
  exe result: 2178309
  
  exe result: 3524578
  
  exe result: 5702887
  
  last time is: 4.457437038421631
  
  输出结果,每次打印三个exe result,总重打印十个结果,多进程运行时间为4.45秒
  
  <2>、多线程
  
  import time
  
  from concurrent.futures import ThreadPoolExecutor, as_completed
  
  from concurrent.futures import ProcessPoolExecutor
  
  def fib(n):
  
  if n<=2:
  
  return 1
  
  return fib(n-1)+fib(n-2)
  
  if __name__ == "__main__":
  
  with ThreadPoolExecutor(3) as executor: # 使用线程池控制 每次执行3个线程
  
  all_task = [executor.submit(fib, (num)) for num in range(25,35)]
  
  start_time = time.time()
  
  for future in as_completed(all_task):
  
  data = future.result()
  
  print("exe result: {www.gcyl152.com/ }".format(data))
  
  print("last time is: {}".format(time.time()-start_time))
  
  # 输出
  
  exe result: 121393
  
  exe result: 75025
  
  exe result: 196418
  
  exe result: 317811
  
  exe result: 514229
  
  exe result: 832040
  
  exe result: 1346269
  
  exe result: 2178309
  
  exe result: 3524578
  
  exe result: 5702887
  
  last time is: 7.3467772006988525
  
  最终程序运行时间为7.34秒
  
  程序的执行之间与计算机的性能有关,每天计算机的执行时间都会有差异。从上述结果中看显然多线程比多进程要耗费时间。这就是因为对于密集代码(密集运算,循环语句等),tick计数很快达到100,GIL来回的释放竞争,线程之间频繁切换,所以对于密集代码的执行中,多线程性能不如对进程。
  
  第一步导入依赖
  
  implementation 'com.squareup.retrofit2:adapter-rxjava2:2.4.0'
  
  implementation 'com.squareup.retrofit2:converter-gson:2.4.0'
  
  implementation 'io.reactivex.rxjava2:rxandroid:2.1.0'
  
  implementation 'cn.bingoogolapple:bga-banner:2.2.4@aar'
  
  创建BaseService
  
  import java.util.Map;
  
  import io.reactivex.Observable;
  
  import okhttp3.ResponseBody;
  
  import retrofit2.http.GET;
  
  import retrofit2.http.POST;
  
  import retrofit2.http.QueryMap;
  
  import retrofit2.http.Url;
  
  public interface BaseService {
  
  @GET
  
  Observable<ResponseBody> get(@Url String url, @QueryMap Map<String, String> map);
  
  @POST
  
  Observable<ResponseBody>www.gcyL157.com post(@Url www.michenggw.com String url, @QueryMap Map<String, String> map);
  
  工具类
  
  import java.io.IOException;
  
  import java.util.HashMap;
  
  import java.util.Map;
  
  import io.reactivex.Observer;
  
  import io.reactivex.www.yigouyule2.cn android.schedulers.AndroidSchedulers;
  
  import io.reactivex.disposables.Disposable;
  
  import io.reactivex.schedulers.Schedulers;
  
  import okhttp3.ResponseBody;
  
  import retrofit2.Retrofit;
  
  import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory;
  
  public class HttpHelper11 www.mhylpt.com{
  
  private BaseService mBaseService;
  
  public HttpHelper11(){
  
  Retrofit retrofit=new Retrofit.Builder()
  
  .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
  
  .baseUrl("http://www.zhaoapi.cn/")
  
  .build();
  
  mBaseService=retrofit.create(BaseService.class);
  
  }
  
  //get请求
  
  public HttpHelper11 get(String url, Map<String,String> map){
  
  if(map==null){
  
  map=new HashMap<>();
  
  }
  
  mBaseService.get(url,map)
  
  .subscribeOn(Schedulers.io(www.mcyllpt.com/))
  
  .observeOn(AndroidSchedulers.mainThread())
  
  .subscribe(observer);
  
  return this;
  
  }
  
  //post请求
  
  public HttpHelper11 post(String url, Map<String,String> map){
  
  if(map==null){
  
  map=new HashMap<www.dfgjyl.cn>();
  
  }
  
  mBaseService.post(url,map)
  
  .subscribeOn(Schedulers.io())
  
  .observeOn(AndroidSchedulers.mainThread())
  
  .subscribe(observer);
  
  return this;
  
  }
  
  private Observer observer=new Observer<ResponseBody>() {
  
  @Override
  
  public void onSubscribe(Disposable d) {
  
  }
  
  @Override
  
  public void onNext(ResponseBody responseBody) {
  
  try {
  
  String data= responseBody.string();
  
  listener.success(data);
  
  } catch (IOException e) {
  
  e.printStackTrace(www.365soke.com);
  
  }
  
  }
  
  @Override
  
  public void onError(Throwable e) {
  
  String error= e.getMessage();
  
  listener.fail(error);
  
  }
  
  @Override
  
  public void onComplete() {
  
  }
  
  };
  
  private HttpListener listener;
  
  public void result(HttpListener listener){
  
  this.listener=listener;
  
  }
  
  public interface HttpListener {
  
  void success(String data);
  
  void fail(String error);
  
  }
  
  }

转载于:https://www.cnblogs.com/qwangxiao/p/10003438.html

你可能感兴趣的文章