一.线程
1.1 线程相关概念
程序:为了完成特定任务,用某种语言编写的一组指令集合(一组静态代码)
进程:运行中的程序,系统调度与资源分配的一个独立单位,操作系统会 为每个进程
分配一段内存空间!程序的依次动态执行,经历代码的加载,执行, 执行完毕的完整
过程!
线程:比进程更小的执行单元,每个进程可能有多条线程,线程需要放在一个 进程中
才能执行,线程由程序负责管理,而进程则由系统进行调度!
多线程的理解:并行执行多个条指令,将CPU时间片按照调度算法分配给各个 线程,
实际上是分时执行的,只是这个切换的时间很短,用户感觉到"同时"而已!
1.2线程的生命周期
1.3创建线程的三种方法
1.继承Thread类
public class MyThread extends Thread { @Override public void run() { doSomething(); } public void doSomething() { System.out.println("我是线程中的一个方法"); } } ------------------------------------------ public class MythreadTest { public static void main(String[] args) { MyThread myThread = new MyThread(); myThread.start();//开启一个线程中的方法 //以下的方法可以与上边的线程并发执行 doSomething(); } private static void doSomething(){ } } |
2.实现Runable接口
public class RunableThread implements Runnable{ @Override public void run() { doSomething(); } private void doSomething(){ System.out.println("我是一个线程方法"); } } ------------------------------------------ public class MyRunableThreadTest { public static void main(String[] args) { Runnable runnable = new RunableThread(); Thread thread = new Thread(runnable); thread.start();//开启一个线程方法 //一下线程可与上面线程并发执行 doSomething(); } private static void doSomething(){ System.out.println("这是一个并行执行方法"); } } |
3.实现Callable接口和Future创建线程
public class CallableThread implements Callable<String> { @Override public String call() throws Exception { doSomething(); return "需要返回的值"; } private void doSomething(){ System.out.println("这是线程中的方法"); } } ------------------------------------------------------- public class CallableThreadTest { public static void main(String[] args) { Callable<String> callable = new CallableThread(); FutureTask<String> futureTask = new FutureTask<String>(callable); Thread thread = new Thread(futureTask); thread.start();//开启一个线程方法 //以下方法可以和上边线程并发执行 doSomething(); } private static void doSomething(){ System.out.println("这是另一个线程中方法"); } } |
1.4 Service与Thread线程的区别
其实他们两者并没有太大的关系,不过有很多朋友经常把这两个混淆了! Thread是线程,程
序执行的最小单元,分配CPU的基本单位! 而Service则是Android提供一个允许长时间留
驻后台的一个组件,最常见的 用法就是做轮询操作!或者想在后台做一些事情,比如后台下
载更新! 记得别把这两个概念混淆!
二、Service的生命周期
生命周期函数解析: 1)onCreate():当Service第一次被创建后立即回调该方法,该方法在整个生命周期 中只会调用一 次! 2)onDestory():当Service被关闭时会回调该方法,该方法只会回调一次! 3)onStartCommand(intent,flag,startId):早期版本是onStart(intent,startId), 当客 户端调用startService(Intent)方法时会回调,可多次调用StartService方法, 但不会再创建新 的Service对象,而是继续复用前面产生的Service对象,但会继续回调 onStartCommand()方法! IBinder onOnbind(intent):该方法是Service都必须实现的方法,该方法会返回一个 IBinder 对象,app通过该对象与Service组件进行通信! 4)onUnbind(intent):当该Service上绑定的所有客户端都断开时会回调该方法! |
2.1 service启动方式
1)StartService()启动Service
2)BindService()启动Service
PS:还有一种,就是启动Service后,绑定Service!
2.1.1 StartService启动Service
1首次启动会创建一个Service实例,依次调用onCreate()和onStartCommand()方法,此时
Service 进入运行状态,如果再次调用StartService启动Service,将不会再创建新的Service
对象, 系统会直接复用前面创建的Service对象,调用它的onStartCommand()方法!
2但这样的Service与它的调用者无必然的联系,就是说当调用者结束了自己的生命周期, 但是只要
不调用stopService,那么Service还是会继续运行的!
3无论启动了多少次Service,只需调用一次StopService即可停掉Service
public class MyService1 extends Service { private final String TAG = "service"; //必须要实现的方法 @Override public IBinder onBind(Intent intent) { Log.e(TAG, "onBind方法被调用!"); return null; } //Service被创建时调用 @Override public void onCreate() { Log.e(TAG, "onCreate方法被调用!"); super.onCreate(); } //Service被启动时调用 @Override public int onStartCommand(Intent intent, int flags, int startId) { Log.e(TAG, "onStartCommand方法被调用!"); return super.onStartCommand(intent, flags, startId); } //Service被关闭之前回调 @Override public void onDestroy() { Log.e(TAG, "onDestory方法被调用!"); super.onDestroy(); } } |
public class ServiceActivity extends AppCompatActivity { private Button start; private Button stop; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.service_layout); start = (Button) findViewById(R.id.btnstart); stop = (Button) findViewById(R.id.btnstop); final Intent intent = new Intent(ServiceActivity.this, MyService1.class); start.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { startService(intent); } }); stop.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { stopService(intent); } }); } } |
service_layout.xml
<?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"> <Button android:id="@+id/btnstart" android:layout_width="0dp" android:layout_weight="1" android:layout_height="wrap_content" android:text="开始服务"/> <Button android:id="@+id/btnstop" android:layout_width="0dp" android:layout_weight="1" android:layout_height="wrap_content" android:text="停止服务"/> </LinearLayout> |
2.1.2 BindService启动Service
1当首次使用bindService绑定一个Service时,系统会实例化一个Service实例,并调用其
onCreate()和onBind()方法,然后调用者就可以通过IBinder和Service进行交互了,此后如果
再次使用bindService绑定Service,系统不会创建新的Sevice实例,也不会再调用onBind()方
法,只会直接把IBinder对象传递给其他后来增加的客户端!
2如果我们解除与服务的绑定,只需调用unbindService(),此时onUnbind和onDestory方法将
会被调用!这是一个客户端的情况,假如是多个客户端绑定同一个Service的话,情况如下 当一个客
户完成和service之间的互动后,它调用 unbindService() 方法来解除绑定。当所有的客户端
都和service解除绑定后,系统会销毁service。(除非service也被startService()方法开
启
3另外,和上面那张情况不同,bindService模式下的Service是与调用者相互关联的,可以理解为
"一条绳子上的蚂蚱",要死一起死,在bindService后,一旦调用者销毁,那么Service也立即终
止!
通过BindService调用Service时调用的Context的bindService的解析
bindService(Intent Service,ServiceConnection conn,int flags)
service:通过该intent指定要启动的Service
conn:ServiceConnection对象,用户监听访问者与Service间的连接情况, 连接成功回调该对
象中的onServiceConnected(ComponentName,IBinder)方法; 如果Service所在的宿主由
于异常终止或者其他原因终止,导致Service与访问者间断开 连接时调用
onServiceDisconnected(CompanentName)方法,主动通过unBindService() 方法断开并
不会调用上述方法!
flags:指定绑定时是否自动创建Service(如果Service还未创建), 参数可以是0(不自动创
建),BIND_AUTO_CREATE(自动创建)
2.1.3StartService启动Service后bindService绑定
1 如果Service已经由某个客户端通过StartService()启动,接下来由其他客户端 再调用
bindService()绑定到该Service后调用unbindService()解除绑定最后在 调用
bindService()绑定到Service的话,此时所触发的生命周期方法如下:
2 onCreate( )->onStartCommand( )->onBind( )->onUnbind( )->onRebind( )
3 PS:前提是:onUnbind()方法返回true!!! 这里或许部分读者有疑惑了,调用了unbindService
后Service不是应该调用 onDistory()方法么!其实这是因为这个Service是由我们的
StartService来启动的 ,所以你调用onUnbind()方法取消绑定,Service也是不会终止的!
4 得出的结论: 假如我们使用bindService来绑定一个启动的Service,注意是已经启动的
Service!!! 系统只是将Service的内部IBinder对象传递给Activity,并不会将Service的生
命周期 与Activity绑定,因此调用unBindService( )方法取消绑定时,Service也不会被销
毁!
public class MyService2 extends Service { private final String TAG = "service"; private int count; private boolean quit; //定义onBinder方法所返回的对象 private MyBinder binder = new MyBinder(); public class MyBinder extends Binder { public int getCount() { return count; } } //必须实现的方法,绑定改Service时回调该方法 @Override public IBinder onBind(Intent intent) { Log.e(TAG, "onBind方法被调用!"); return binder; } //Service被创建时回调 @Override public void onCreate() { super.onCreate(); Log.e(TAG, "onCreate方法被调用!"); //创建一个线程动态地修改count的值 new Thread() { public void run() { while (!quit) { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } count++; Log.e(TAG, "count = " + count); } } }.start(); } //Service断开连接时回调 @Override public boolean onUnbind(Intent intent) { Log.e(TAG, "onUnbind方法被调用!"); return true; } //Service被关闭前回调 @Override public void onDestroy() { super.onDestroy(); this.quit = true; Log.e(TAG, "onDestroyed方法被调用!"); } @Override public void onRebind(Intent intent) { Log.e(TAG, "onRebind方法被调用!"); super.onRebind(intent); } } |
public class Service2Activity extends AppCompatActivity { private Button btnbind; private Button btncancel; private Button btnstatus; //保持所启动的Service的IBinder对象,同时定义一个ServiceConnection对象 private MyService2.MyBinder binder; private ServiceConnection conn = new ServiceConnection() { //Activity与Service断开连接时回调该方法 @Override public void onServiceDisconnected(ComponentName name) { Log.e("service", " ------Service DisConnected-------"); } //Activity与Service连接成功时回调该方法 @Override public void onServiceConnected(ComponentName name, IBinder service) { Log.e("service", " ------Service Connected------ - "); binder = (MyService2.MyBinder) service; } }; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.service2_layout); btnbind = (Button) findViewById(R.id.btnbind); btncancel = (Button) findViewById(R.id.btncancel); btnstatus = (Button) findViewById(R.id.btnstatus); final Intent intent = new Intent(Service2Activity.this, MyService2.class); btnbind.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { //绑定service bindService(intent, conn, Service.BIND_AUTO_CREATE); } }); btncancel.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { //解除service绑定 unbindService(conn); } }); btnstatus.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { Toast.makeText(getApplicationContext(), "Service的count的值为:" + binder.getCount(), Toast.LENGTH_SHORT).show(); } }); } @Override protected void onDestroy() { super.onDestroy(); unbindService(conn); // 销毁Activity时需要解绑Service } } |
<?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:paddingTop="15dp" android:orientation="vertical"> <Button android:id="@+id/btnbind" android:layout_width="match_parent" android:layout_height="wrap_content" android:text="绑定Service" /> <Button android:id="@+id/btncancel" android:layout_width="match_parent" android:layout_height="wrap_content" android:layout_marginTop="15dp" android:text="解绑Service" /> <Button android:id="@+id/btnstatus" android:layout_width="match_parent" android:layout_height="wrap_content" android:layout_marginTop="15dp" android:text="获取Service状态" /> </LinearLayout> |