多线程基础

简介:

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


线程和进程的区别:
  每个进程都有独立的代码和数据空间(进程上下文),进程间的切换会有较大的开销。
  线程可以看成是轻量级的进程,同一类线程共享代码和数据空间,每个线程有独立的运行栈和程序计数器(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 ? 在CODE上查看代码片 派生到我的代码片
  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 ? 在CODE上查看代码片 派生到我的代码片
  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时别的线程也不可以访问锁定对象。
目录
相关文章
|
6月前
|
存储 安全 Java
10分钟巩固多线程基础
10分钟巩固多线程基础
|
Java API 调度
并发编程系列教程(01) - 多线程基础
并发编程系列教程(01) - 多线程基础
69 0
|
6月前
|
Java API 调度
[Java并发基础]多进程编程
[Java并发基础]多进程编程
127 0
|
Java 程序员 调度
多线程(初阶)——多线程基础
多线程(初阶)——多线程基础
88 0
|
Java API 调度
并发编程之多线程基础
每个正在系统上运行的程序都是一个进程。每个进程包含一到多个线程。线程是一组指令的集合,或者是程序的特殊段,它可以在程序里独立执行。也可以把它理解为代码运行的上下文。所以线程基本上是轻量级的进程,它负责在单个程序里执行多任务。通常由操作系统负责多个线程的调度和执行。
并发编程之多线程基础
|
缓存 安全 Java
6. 多线程基础
对一个程序的运行状态, 以及在运行中所占用的资源(内存, CPU)的描述; 一个进程可以理解为一个程序; 但是反之, 一个程序就是一个进程, 这句话是错的。
92 0
6. 多线程基础
|
安全 Java 编译器
多线程基础(上)
多线程基础(上)
67 0
多线程基础(上)
|
Java 编译器 程序员
多线程基础(下)
多线程基础(下)
102 0
多线程基础(下)
|
SpringCloudAlibaba 安全 前端开发
JUC系列(一) 多线程基础复习
问:如何学习JUC? 答: 源码 + Java帮助文档 面试高频, juc 其实就是 Java.util 包下的线程分类的工具
JUC系列(一) 多线程基础复习
|
安全 Java 调度
第8章 多线程基础
建立多线程基础,了解基本知识。
109 0