并发编程把我整的是服服气气的了

 阿粉因为原来的编程习惯，已经很久没有去考虑并发的问题了，结果之前在面试的问题就回答的不是很完善，而阿粉也用心学习了并发编程这一块的所有内容，一起来分享给大家。

成都做网站、网站制作,成都做网站公司-成都创新互联已向上千家企业提供了,网站设计,网站制作,网络营销等服务!设计与技术结合,多年网站推广经验,合理的价格为您打造企业品质网站。

为什么需要并发编程因为现在的CPU我们大家也都知道，什么几核几线程，各种各样，而我们并发编程的目的是为了让程序运行得更快，这里的更快说的并不是让我们无限制启动更多的线程就能让程序进行最大可能的并发操作，但是我们在进行并发编程的时候，很容易遇到很多的问题，比如说死锁问题，再比如说上下文的切换的问题，这都是问题所在。

实现多线程的几种方式，面试中最简单的题目

说起来这个面试题，很多回答都一样，

  • 继承Thread类
  • 实现Runnable接口
  • 使用线程池

这是很多面试者回答的时候总是回答这三个，但是实际上，实现多线程的方式也不限于这几种方式，还有比如说带返回值的线程实现，定时器实现，内部类实现，这些方式都是可以实现多线程的。那我们今天就先来把这些不常用的方式来梳理一下。

使用匿名内部类的方式实现多线程

其实说实话，这匿名内部类的方式也不能算是一种新的实现方式，只不过是把这个实现方式放到了匿名类里面了，实现的总体内部还是使用的继承 Thread和实现Runnable接口。

案例实现：

 
 
 
 
    
  
  
  
  
  1. public class TestClass { 
    2. 
  
  
  
  
  2.     public static void main(String[] args) { 
    3. 
  
  
  
  
  3.         // 基于子类的方式 
    4. 
  
  
  
  
  4.         new Thread() { 
    5. 
  
  
  
  
  5.             @Override 
    6. 
  
  
  
  
  6.             public void run() { 
    7. 
  
  
  
  
  7.                 while (true) { 
    8. 
  
  
  
  
  8.                     printThreadInfo(); 
    9. 
  
  
  
  
  9.                 } 
    10. 
  
  
  
  
  10.             } 
    11. 
  
  
  
  
  11.         }.start(); 
    12. 
  
  
  
  
  12.  
    13. 
  
  
  
  
  13.         // 基于接口的实现 
    14. 
  
  
  
  
  14.         new Thread(new Runnable() { 
    15. 
  
  
  
  
  15.             @Override 
    16. 
  
  
  
  
  16.             public void run() { 
    17. 
  
  
  
  
  17.                 while (true) { 
    18. 
  
  
  
  
  18.                     printThreadInfo(); 
    19. 
  
  
  
  
  19.                 } 
    20. 
  
  
  
  
  20.             } 
    21. 
  
  
  
  
  21.         }).start(); 
    22. 
  
  
  
  
  22.     } 
    23. 
  
  
  
  
  23.     private static void printThreadInfo() { 
    24. 
  
  
  
  
  24.         System.out.println("当前运行的线程名为： " + Thread.currentThread().getName()); 
    25. 
  
  
  
  
  25.         try { 
    26. 
  
  
  
  
  26.             Thread.sleep(1000); 
    27. 
  
  
  
  
  27.         } catch (Exception e) { 
    28. 
  
  
  
  
  28.             throw new RuntimeException(e); 
    29. 
  
  
  
  
  29.         } 
    30. 
  
  
  
  
  30.     } 
    31. 
  
  
  
  
  31. } 
    32. 
  
  
  
  
  32.  
    33. 
  
  
  
  
  33. 实现结果： 
    34. 
  
  
  
  
  34.  
    35. 
  
  
  
  
  35. 当前运行的线程名为：Thread-1 
    36. 
  
  
  
  
  36. 当前运行的线程名为：Thread-0 
    37. 
  
  
  
  
  37. 当前运行的线程名为：Thread-1 
    38. 
  
  
  
  
  38. 当前运行的线程名为：Thread-0 
    39. 
  
  
  
  
  39. 当前运行的线程名为：Thread-1 
    40. 
  
  
  
  
  40. 当前运行的线程名为：Thread-0 
    41. 
  
  
  
  
  41. 当前运行的线程名为：Thread-0 
    42. 
  
  
  
  
  42. 当前运行的线程名为：Thread-1 
    43. 
  
  
  
  
  43. 当前运行的线程名为：Thread-1 
    44. 
  
  
  
  
  44. 当前运行的线程名为：Thread-0 
    45. 
  
  
  
  
  45. 当前运行的线程名为：Thread-0 
    46. 
  
  
  
  
  46. 当前运行的线程名为：Thread-1 
    47.

其实对于上述手段，大家也肯定都会，那么我们就说说这个定时器实现方式，这个方式实际上是也是大家经常会使用的一种方式，因为我们很多时候都需要在我们不在的情况下进行一些操作，比如说，每天晚上对系统进行一下当天的统计操作什么的。

使用定时器实现

 
 
 
 
    
  
  
  
  
  1. public class TestClass { 
    2. 
  
  
  
  
  2.     private static final SimpleDateFormat dateFormat = 
    3. 
  
  
  
  
  3.             new SimpleDateFormat("yyyy-MM-dd hh:mm:ss"); 
    4. 
  
  
  
  
  4.  
    5. 
  
  
  
  
  5.     public static void main(String[] args) throws Exception { 
    6. 
  
  
  
  
  6.         // 创建定时器 
    7. 
  
  
  
  
  7.         Timer timer = new Timer(); 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9.         // 提交计划任务 
    10. 
  
  
  
  
  10.         timer.schedule(new TimerTask() { 
    11. 
  
  
  
  
  11.             @Override 
    12. 
  
  
  
  
  12.             public void run() { 
    13. 
  
  
  
  
  13.                 System.out.println("定时任务执行了..."); 
    14. 
  
  
  
  
  14.             } 
    15. 
  
  
  
  
  15.         }, dateFormat.parse("2020-12-08 20:30:00")); 
    16. 
  
  
  
  
  16.     } 
    17. 
  
  
  
  
  17. } 
    18. 
  
  
  
  
  18.  
    19. 
  
  
  
  
  19. 这段代码大家可以复制一下，在你设定好的时间内进行执行 
    20.

关于多线程的实现方式，阿粉就给大家讲述到这里，毕竟这个东西在你使用的时候，一定是活学活用的，不是一成不变的，需要你看自己的需求来弄。

接下来我们就先从并发编程的线程安全性开始入手，接下来阿粉也会继续给大家更新关于并发编程的各种技术内容，让大家能够尽快的掌握好这个线程安全的问题，

线程的安全性操作

其实对于一个对象来说，他是否是线程安全的，完全取决于他是否被多个线程去访问，而如果要让我们的对象是线程安全的话，那么我们一定要采取一些方式，而方式都有哪些呢?

  • 同步机制
  • 加锁机制

也就是大家所了解的同步 Synchronized 和加锁的机制。还有就是使用Volatile类型的变量。

也就是说，如果多个线程去访问同一个可变的状态的变量的时候，没有使用合适的同步，那么程序相对来说就会出现错误，而解决方式也有好几种，

  • 比如说不在线程之前共享这个变量
  • 将状态变量修改成为不可变的的变量
  • 在访问状态变量的时候使用同步

而阿粉之前也看过一个图片，就是说他从字节码的角度去分析了线程不安全的操作，看下图

 

用一个最简单的案例给大家讲解Synchronized，我们手动实现一个线程然后递减，每次输出这个变量，最终看效果图

 
 
 
 
    
  
  
  
  
  1. public class TestClass implements Runnable{ 
    2. 
  
  
  
  
  2.     int i = 100; 
    3. 
  
  
  
  
  3.  
    4. 
  
  
  
  
  4.     @Override 
    5. 
  
  
  
  
  5.     public void run() { 
    6. 
  
  
  
  
  6.         // TODO Auto-generated method stub 
    7. 
  
  
  
  
  7.         while(true) { 
    8. 
  
  
  
  
  8.             if(i>0) { 
    9. 
  
  
  
  
  9.                 try { 
    10. 
  
  
  
  
  10.                     Thread.sleep(10);//为了让安全问题明显，我们让线程执行的时间变长，故睡眠10毫秒 
    11. 
  
  
  
  
  11.                 } catch (InterruptedException e) { 
    12. 
  
  
  
  
  12.                     // TODO Auto-generated catch block 
    13. 
  
  
  
  
  13.                     e.printStackTrace(); 
    14. 
  
  
  
  
  14.                 } 
    15. 
  
  
  
  
  15.                 System.out.println(i); 
    16. 
  
  
  
  
  16.                 i--; 
    17. 
  
  
  
  
  17.             } 
    18. 
  
  
  
  
  18.         } 
    19. 
  
  
  
  
  19.     } 
    20. 
  
  
  
  
  20. } 
    21. 
  
  
  
  
  21.  
    22. 
  
  
  
  
  22. class Test{ 
    23. 
  
  
  
  
  23.     public static void main(String[] args) { 
    24. 
  
  
  
  
  24.         TestClass testClass = new TestClass(); 
    25. 
  
  
  
  
  25.         Thread t1 = new Thread(testClass); 
    26. 
  
  
  
  
  26.         Thread t2 = new Thread(testClass); 
    27. 
  
  
  
  
  27.         Thread t3 = new Thread(testClass); 
    28. 
  
  
  
  
  28.         t1.start(); 
    29. 
  
  
  
  
  29.         t2.start(); 
    30. 
  
  
  
  
  30.         t3.start(); 
    31. 
  
  
  
  
  31.     } 
    32. 
  
  
  
  
  32.  
    33. 
  
  
  
  
  33. } 
    34.

不用说大家都知道，结果肯定是乱的一塌糊涂，有来回跳跃的，也有分段执行的，反正就是不是从100到1的，结果大家可以把代码拿过去使用一下自己看看。

那么我们加上Synchronized关键字之后呢?

 
 
 
 
    
  
  
  
  
  1. public class TestClass implements Runnable{ 
    2. 
  
  
  
  
  2.     int i = 100; 
    3. 
  
  
  
  
  3.     @Override 
    4. 
  
  
  
  
  4.     public void run() { 
    5. 
  
  
  
  
  5.         while(true) { 
    6. 
  
  
  
  
  6.             synchronized (this){ 
    7. 
  
  
  
  
  7.                 if(i>0) { 
    8. 
  
  
  
  
  8.                     try { 
    9. 
  
  
  
  
  9.                         Thread.sleep(10);//为了让安全问题明显，我们让线程执行的时间变长，故睡眠10毫秒 
    10. 
  
  
  
  
  10.                     } catch (InterruptedException e) { 
    11. 
  
  
  
  
  11.                         e.printStackTrace(); 
    12. 
  
  
  
  
  12.                     } 
    13. 
  
  
  
  
  13.                     System.out.println(i); 
    14. 
  
  
  
  
  14.                     i--; 
    15. 
  
  
  
  
  15.                 } 
    16. 
  
  
  
  
  16.             } 
    17. 
  
  
  
  
  17.         } 
    18. 
  
  
  
  
  18.     } 
    19. 
  
  
  
  
  19. } 
    20. 
  
  
  
  
  20.  
    21. 
  
  
  
  
  21. class Test{ 
    22. 
  
  
  
  
  22.     public static void main(String[] args) { 
    23. 
  
  
  
  
  23.         TestClass testClass = new TestClass(); 
    24. 
  
  
  
  
  24.         Thread t1 = new Thread(testClass); 
    25. 
  
  
  
  
  25.         Thread t2 = new Thread(testClass); 
    26. 
  
  
  
  
  26.         Thread t3 = new Thread(testClass); 
    27. 
  
  
  
  
  27.         t1.start(); 
    28. 
  
  
  
  
  28.         t2.start(); 
    29. 
  
  
  
  
  29.         t3.start(); 
    30. 
  
  
  
  
  30.     } 
    31. 
  
  
  
  
  31. } 
    32.

大家可以去执行一下运行结果，顺带打印出执行结果，是不是这次就很舒服了，终于看到自己心心念念的从100-1的内容了，而实际上，我们只是通过加上了一个同步的关键字，来实现了线程的安全性操作，让线程同步执行，不再会出现那个不安全的行为，是不是很简单?你学会了么?

网站标题：并发编程把我整的是服服气气的了
标题URL：http://www.shufengxianlan.com/qtweb/news16/285266.html

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

广告

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

猜你还喜欢下面的内容

定制网站知识

分类信息网

成都网络营销　　 　网站建设费用　　 　成都关键词SEO优化　　 　企业网站建设公司　　 　草坪音箱　　 　重庆做网站　　 　成都网站建设　　 　网站搜索引擎优化　　 　店面门头广告　　 　香港服务器空间　　 　简阳服务器托管　　 　外贸营销网站建设　　 　B2C电商系统　　 　证企宝企业服务　　 　成都移动机房　　 　绵阳网站建设公司　　 　眉山做网站　　 　标志设计　　 　高端网站设计　　 　快照排名