多线程基础

线程是一个程序内部的顺序控制流。


线程和进程的区别:
  每个进程都有独立的代码和数据空间(进程上下文),进程间的切换会有较大的开销。
  线程可以看成是轻量级的进程,同一类线程共享代码和数据空间,每个线程有独立的运行栈和程序计数器(PC),线程切换的开销小。
  多进程:在操作系统中能同时运行多个任务(程序)
  多线程:在同一应用程序中有多个顺序流同时执行

 


当多线程sleep时,如何停止呢?
1、interrupt()方法,这个方法很粗暴不建议使用,这个相当于睡觉的时候一盆凉水泼下来,会抛出interruptedException。
2、stop()方法,已经废弃了,这个比interrupt更粗暴,直接停止线程。不建议使用。
3、用标量在外部控制。


join方法:合并某个线程。把处于并行运行状态的线程合并到当前线程中。


yield()方法:让出CPU,给其他线程执行的机会。


setPriority():设置优先级,优先级越高,cpu分得时间片就越多,越容易得到执行。


线程同步:在Java语言中,引入了对象互斥锁的概念,保证共享数据操作的完整性。每个对象都对应于一个可称为“互斥锁”的标记。这个标记保证在任何一个时刻,只能有一个线程访问该对象。
关键字synchronized来与对象的互斥锁联系。当某个对象synchronized修饰时,表明该对象在任一时刻只能由一个线程访问。synchronized可以作为关键字设在方法上,也可以使用synchronized(this){}中表明锁定该对象的内容。


尽量只锁定一个对象,避免死锁。


当一个线程锁定了一个方法的时候,其他线程可以通过其他方法修改值,所以,一定要保证所有有关这个变量的方法都要加锁。


同步实例:

[html] view plain copy  print?多线程基础多线程基础
  1. <span style="font-family:Microsoft YaHei;"><span style="font-size:12px;">package thread;  
  2.   
  3. public class TT implements Runnable{  
  4.   
  5.     int b = 100 ;  
  6.       
  7.     @Override  
  8.     public void run() {  
  9.         m1() ;  
  10.     }  
  11.       
  12.     //只会锁定m1方法内的内容,不会锁定b  
  13.     public synchronized void m1() {  
  14.         b = 1000 ;  
  15.         try {  
  16.             Thread.sleep(5000);  
  17.         } catch (InterruptedException e) {  
  18.             e.printStackTrace();  
  19.         }  
  20.         System.out.println("b = " + b);  
  21.     }  
  22.   
  23.     public void m2() {  
  24.         System.out.println(b);  
  25.     }  
  26.       
  27.     public static void main(String[] args) {  
  28.         TT t = new TT() ;  
  29.         Thread thread = new Thread(t) ;  
  30.         thread.start() ;  
  31.         try {  
  32.             Thread.sleep(1000);  
  33.         } catch (InterruptedException e) {  
  34.             e.printStackTrace();  
  35.         }  
  36.         t.m2();  
  37.     }  
  38. }  
  39. </span></span>  




生产者与消费者实例:

[html] view plain copy  print?多线程基础多线程基础
  1. <span style="font-family:Microsoft YaHei;">package thread;  
  2.   
  3. public class ProducerConsumer {  
  4.   
  5.     public static void main(String[] args) {  
  6.         SyncStack ss = new SyncStack() ;  
  7.         Producer p = new Producer(ss) ;  
  8.         Consumer c = new Consumer(ss) ;  
  9.         new Thread(p).start();  
  10.         new Thread(c).start();  
  11.     }  
  12. }  
  13.   
  14. class WoTou {  
  15.     int id ;  
  16.     WoTou(int id) {  
  17.         this.id = id ;  
  18.     }  
  19.     public String toString() {  
  20.         return "id = " + this.id ;  
  21.     }  
  22. }  
  23.   
  24. class SyncStack {  
  25.     int index = 0 ;  
  26.     WoTou[] arrWt = new WoTou[6] ;  
  27.       
  28.     public synchronized void push(WoTou wt) {  
  29.         while(index == arrWt.length) {  
  30.             try {  
  31.                 this.wait();  
  32.             } catch (InterruptedException e) {  
  33.                 // TODO Auto-generated catch block  
  34.                 e.printStackTrace();  
  35.             }  
  36.         }  
  37.         this.notify();  
  38.         arrWt[index] = wt ;  
  39.         index ++ ;  
  40.     }  
  41.       
  42.     public synchronized WoTou pop() {  
  43.         while(index == 0) {  
  44.             try {  
  45.                 this.wait();  
  46.             } catch (InterruptedException e) {  
  47.                 e.printStackTrace();  
  48.             }  
  49.         }  
  50.         this.notify();  
  51.         index -- ;  
  52.         return arrWt[index] ;  
  53.     }  
  54. }  
  55.   
  56. class Producer implements Runnable {  
  57.       
  58.     SyncStack s = null ;  
  59.       
  60.     public Producer(SyncStack s) {  
  61.         this.s = s ;  
  62.     }  
  63.   
  64.     @Override  
  65.     public void run() {  
  66.         for(int i=0; i<20; i++) {  
  67.             WoTou wt = new WoTou(i) ;  
  68.             System.out.println("push : " + wt);  
  69.             s.push(wt);  
  70.         }  
  71.     }  
  72. }  
  73.   
  74. class Consumer implements Runnable {  
  75.       
  76.     SyncStack s = null ;  
  77.       
  78.     public Consumer(SyncStack s) {  
  79.         this.s = s ;  
  80.     }  
  81.   
  82.     @Override  
  83.     public void run() {  
  84.         for(int i=0; i<20; i++) {  
  85.             WoTou wt = s.pop() ;  
  86.             System.out.println("pop : " + wt);  
  87.         }  
  88.     }  
  89. }</span>  


wait和sleep的区别
wait时别的线程可以访问锁定对象,调用wait方法的时候必须锁定该对象。sleep时别的线程也不可以访问锁定对象。
上一篇:Android 多线程基础


下一篇:android PackageInstaller那点事儿