Java多线程学习总结（二）

一、interrupt方法一种让线程退出的方式。

我们提供的服务有：成都网站设计、做网站、微信公众号开发、网站优化、网站认证、盐山ssl等。为上千余家企事业单位解决了网站和推广的问题。提供周到的售前咨询和贴心的售后服务，是有科学管理、有技术的盐山网站制作公司

 
 
 
    
  
  
  
  1. import java.util.*; 
    2. 
  
  
  
  2. public class TestInterrupt{ 
    3. 
  
  
  
  3.     public static void main(String[] args){ 
    4. 
  
  
  
  4.         MyThread t = new MyThread(); 
    5. 
  
  
  
  5.         t.start(); 
    6. 
  
  
  
  6.         try{Thread.sleep(10000);} 
    7. 
  
  
  
  7.         catch(InterruptedException i){} 
    8. 
  
  
  
  8.         t.interrupt(); 
    9. 
  
  
  
  9.     } 
    10. 
  
  
  
  10. } 
    11. 
  
  
  
  11. 
  
  
  
  12. class MyThread extends Thread{ 
    13. 
  
  
  
  13.     public void run(){ 
    14. 
  
  
  
  14.         while(true){ 
    15. 
  
  
  
  15.             try{ 
    16. 
  
  
  
  16.                 System.out.println("------"+new Date()+"-----"); 
    17. 
  
  
  
  17.                 Thread.sleep(1000); 
    18. 
  
  
  
  18.             }catch(InterruptedException i){ 
    19. 
  
  
  
  19.                 return; 
    20. 
  
  
  
  20.             } 
    21. 
  
  
  
  21.         } 
    22. 
  
  
  
  22.     } 
    23. 
  
  
  
  23. } 
    24. 
  
  
  
  24.

二、join和yield方法
 t.join(); //t的run()方法完才会继续执行当前线程方法体
             //也就是两个线程变成了一个线程
 t.yield(); //暂停当前正在执行的线程对象，并执行其他线程。方法为静态
              //哪个线程体执行此方法，哪个线程让步

 
 
 
    
  
  
  
  1. public class TestYield { 
    2. 
  
  
  
  2.   public static void main(String[] args) { 
    3. 
  
  
  
  3.     MyThread3 t1 = new MyThread3("t1"); 
    4. 
  
  
  
  4.     MyThread3 t2 = new MyThread3("t2"); 
    5. 
  
  
  
  5.     t1.start(); t2.start(); 
    6. 
  
  
  
  6.   } 
    7. 
  
  
  
  7. } 
    8. 
  
  
  
  8. class MyThread3 extends Thread { 
    9. 
  
  
  
  9.   MyThread3(String s){super(s);} 
    10. 
  
  
  
  10.   public void run(){ 
    11. 
  
  
  
  11.     for(int i =1;i<=100;i++){ 
    12. 
  
  
  
  12.       System.out.println(getName()+": "+i); 
    13. 
  
  
  
  13.       if(i%10==0){ 
    14. 
  
  
  
  14.         yield(); 
    15. 
  
  
  
  15.       } 
    16. 
  
  
  
  16.     } 
    17. 
  
  
  
  17.   } 
    18. 
  
  
  
  18. } 
    19.

三、线程优先级别
 线程的优先级用数字表示，范围从1到10，一个线程的缺省优先级为5.
 Thread.MAX_PRIORITY=1
 Thread.MIN_PRIORITY=10
 Thread.NORM_PRIORITY=5
 例：t.setPriority(Thread.NORM_PRIORITY+3);
 
四、线程同步
 1.同步代码块
 synchronized(this){  //在执行代码块过程中，不会被其他线程打断
  ... 
 }
 public sunchronized void method //执行此方法时，当前对象被锁定
 在Java语言中，引入了对象互斥锁的概念，保证共享数据操作的完整性，每个对象 都对应一个可称为"互斥锁"的标记，这个标记保证在任一时刻，只能有一个线程访 问该对象。
 2.线程死锁

 
 
 
    
  
  
  
  1. public class TestDeadLock implements Runnable { 
    2. 
  
  
  
  2.     public int flag = 1; 
    3. 
  
  
  
  3.     static Object o1 = new Object(), o2 = new Object(); 
    4. 
  
  
  
  4.     public void run() { 
    5. 
  
  
  
  5. System.out.println("flag=" + flag); 
    6. 
  
  
  
  6.         if(flag == 1) { 
    7. 
  
  
  
  7.             synchronized(o1) { 
    8. 
  
  
  
  8.                 try { 
    9. 
  
  
  
  9.                     Thread.sleep(500); 
    10. 
  
  
  
  10.                 } catch (Exception e) { 
    11. 
  
  
  
  11.                     e.printStackTrace(); 
    12. 
  
  
  
  12.                 } 
    13. 
  
  
  
  13.                 synchronized(o2) { 
    14. 
  
  
  
  14.                     System.out.println("1");     
    15. 
  
  
  
  15.                 } 
    16. 
  
  
  
  16.             } 
    17. 
  
  
  
  17.         } 
    18. 
  
  
  
  18.         if(flag == 0) { 
    19. 
  
  
  
  19.             synchronized(o2) { 
    20. 
  
  
  
  20.                 try { 
    21. 
  
  
  
  21.                     Thread.sleep(500); 
    22. 
  
  
  
  22.                 } catch (Exception e) { 
    23. 
  
  
  
  23.                     e.printStackTrace(); 
    24. 
  
  
  
  24.                 } 
    25. 
  
  
  
  25.                 synchronized(o1) { 
    26. 
  
  
  
  26.                     System.out.println("0"); 
    27. 
  
  
  
  27.                 } 
    28. 
  
  
  
  28.             } 
    29. 
  
  
  
  29.         } 
    30. 
  
  
  
  30.     }     
    31. 
  
  
  
  31.      
    32. 
  
  
  
  32.     public static void main(String[] args) { 
    33. 
  
  
  
  33.         TestDeadLock td1 = new TestDeadLock(); 
    34. 
  
  
  
  34.         TestDeadLock td2 = new TestDeadLock(); 
    35. 
  
  
  
  35.         td1.flag = 1; 
    36. 
  
  
  
  36.         td2.flag = 0; 
    37. 
  
  
  
  37.         Thread t1 = new Thread(td1); 
    38. 
  
  
  
  38.         Thread t2 = new Thread(td2); 
    39. 
  
  
  
  39.         t1.start(); 
    40. 
  
  
  
  40.         t2.start(); 
    41. 
  
  
  
  41.          
    42. 
  
  
  
  42.     } 
    43. 
  
  
  
  43. } 
    44.

五、生产者消费者问题

 
 
 
    
  
  
  
  1. public class ProducerConsumer { 
    2. 
  
  
  
  2.     public static void main(String[] args) { 
    3. 
  
  
  
  3.         SyncStack ss = new SyncStack(); 
    4. 
  
  
  
  4.         Producer p = new Producer(ss); 
    5. 
  
  
  
  5.         Consumer c = new Consumer(ss); 
    6. 
  
  
  
  6.         new Thread(p).start(); 
    7. 
  
  
  
  7.         new Thread(p).start(); 
    8. 
  
  
  
  8.         new Thread(p).start(); 
    9. 
  
  
  
  9.         new Thread(c).start(); 
    10. 
  
  
  
  10.     } 
    11. 
  
  
  
  11. } 
    12. 
  
  
  
  12. 
  
  
  
  13. class WoTou { 
    14. 
  
  
  
  14.     int id;  
    15. 
  
  
  
  15.     WoTou(int id) { 
    16. 
  
  
  
  16.         this.id = id; 
    17. 
  
  
  
  17.     } 
    18. 
  
  
  
  18.     public String toString() { 
    19. 
  
  
  
  19.         return "WoTou : " + id; 
    20. 
  
  
  
  20.     } 
    21. 
  
  
  
  21. } 
    22. 
  
  
  
  22. 
  
  
  
  23. class SyncStack {        //栈实现 
    24. 
  
  
  
  24.     int index = 0; 
    25. 
  
  
  
  25.     WoTou[] arrWT = new WoTou[6];    //相当于装物品的篮子 
    26. 
  
  
  
  26.      
    27. 
  
  
  
  27.     public synchronized void push(WoTou wt) {    //生产物品，线程安全 
    28. 
  
  
  
  28.         while(index == arrWT.length) {        //当篮子满了线程等待 
    29. 
  
  
  
  29.             try {             
    30. 
  
  
  
  30.                 this.wait();         
    31. 
  
  
  
  31.             } catch (InterruptedException e) { 
    32. 
  
  
  
  32.                 e.printStackTrace(); 
    33. 
  
  
  
  33.             } 
    34. 
  
  
  
  34.              
    35. 
  
  
  
  35.         } 
    36. 
  
  
  
  36.         this.notifyAll();    //开始生产时，叫醒等待的其他线程开始消费 
    37. 
  
  
  
  37.         arrWT[index] = wt;     
    38. 
  
  
  
  38.         index ++; 
    39. 
  
  
  
  39.     } 
    40. 
  
  
  
  40.      
    41. 
  
  
  
  41.     public synchronized WoTou pop() {        //消费物品，线程安全 
    42. 
  
  
  
  42.         while(index == 0) {            //如果篮子空了 
    43. 
  
  
  
  43.             try { 
    44. 
  
  
  
  44.                 this.wait();        //线程等待,等待生产者开始                          
    45. 
  
  
  
  45. //生产，叫醒此线程 
    46. 
  
  
  
  46.             } catch (InterruptedException e) { 
    47. 
  
  
  
  47.                 e.printStackTrace(); 
    48. 
  
  
  
  48.             } 
    49. 
  
  
  
  49.              
    50. 
  
  
  
  50.         } 
    51. 
  
  
  
  51.         this.notifyAll();            //消费时喊醒生产者生产 
    52. 
  
  
  
  52.         index--; 
    53. 
  
  
  
  53.         return arrWT[index]; 
    54. 
  
  
  
  54.     } 
    55. 
  
  
  
  55. } 
    56. 
  
  
  
  56. 
  
  
  
  57. class Producer implements Runnable {            //生产者类 
    58. 
  
  
  
  58.     SyncStack ss = null; 
    59. 
  
  
  
  59.     Producer(SyncStack ss) { 
    60. 
  
  
  
  60.         this.ss = ss; 
    61. 
  
  
  
  61.     } 
    62. 
  
  
  
  62.      
    63. 
  
  
  
  63.     public void run() { 
    64. 
  
  
  
  64.         for(int i=0; i<20; i++) {    //生产20个 
    65. 
  
  
  
  65.             WoTou wt = new WoTou(i); 
    66. 
  
  
  
  66.             ss.push(wt);             
    67. 
  
  
  
  67.             System.out.println("生产了：" + wt); 
    68. 
  
  
  
  68.             try { 
    69. 
  
  
  
  69.                 Thread.sleep((int)(Math.random() * 200)); 
    70. 
  
  
  
  70.             } catch (InterruptedException e) { 
    71. 
  
  
  
  71.                 e.printStackTrace(); 
    72. 
  
  
  
  72.             }             
    73. 
  
  
  
  73.         } 
    74. 
  
  
  
  74.     } 
    75. 
  
  
  
  75. } 
    76. 
  
  
  
  76. 
  
  
  
  77. class Consumer implements Runnable { 
    78. 
  
  
  
  78.     SyncStack ss = null; 
    79. 
  
  
  
  79.     Consumer(SyncStack ss) { 
    80. 
  
  
  
  80.         this.ss = ss; 
    81. 
  
  
  
  81.     } 
    82. 
  
  
  
  82.      
    83. 
  
  
  
  83.     public void run() { 
    84. 
  
  
  
  84.         for(int i=0; i<20; i++) {        //消费20个 
    85. 
  
  
  
  85.             WoTou wt = ss.pop(); 
    86. 
  
  
  
  86.             System.out.println("消费了: " + wt); 
    87. 
  
  
  
  87.             try { 
    88. 
  
  
  
  88.                 Thread.sleep((int)(Math.random() * 1000)); 
    89. 
  
  
  
  89.             } catch (InterruptedException e) { 
    90. 
  
  
  
  90.                 e.printStackTrace(); 
    91. 
  
  
  
  91.             }             
    92. 
  
  
  
  92.         } 
    93. 
  
  
  
  93.     } 
    94. 
  
  
  
  94. } 
    95.

文章名称：Java多线程学习总结（二）
链接URL：http://www.csdahua.cn/qtweb/news45/220545.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 快上网

成都快上网为您推荐相关内容

网站排名知识

同城分类信息

等级保护测评　　 　医药医疗网站建设方案　　 　成都建站　　 　高端定制网站建设　　 　成都app软件开发　　 　四川晃众门窗　　 　盐亭网站设计　　 　免备案空间　　 　雅安电信机房　　 　成都企业注册服务　　 　南充电信机房托管　　 　重庆花箱　　 　成都发电机维修　　 　成都二枢电信服务器托管　　 　网站改版　　 　成都移动服务器托管　　 　成都网站制作　　 　崇州做网站　　 　成都工装公司　　 　青羊总部基地