多线程并发编程（三）：多线程同步互斥Synchronized

怼烎@ 2022-07-30 15:23 389阅读 0赞

前言

其实就是针对线程安全问题进行的，最经典的问题就是银行转账的问题，A向B转账的同时，A也在存钱，比如A有1000元，向B转200元，A自己存300元，按道理最后是1100元，如果没有同步机制，那么就可能发生问题，如果在A转账的时候，余额还没有开始减，然后A存钱的时候，拿到的余额是没有减去的，然后A的余额开始减去，但是存钱的线程拿到的余额是没有减去的，那么最后计算赋值可能变成了1000+300=1300了，同样，有可能在存钱的时候还没有计算赋值，另外一个转账线程进来，拿到的值是还没有加起来的，也就是1000元，那么转账线程执行完，1000-200=800，按道理是1100的，所以可能出现钱多了，或者钱少了的问题。

线程安全问题

  1. package test01;
  3. public class TraditionalThreadSychronized { 
  5.     class Outputer{
  7.         // 这里打印，采取一个字母一个字母的打印，打印完一个名字再换行
  8.         public void output(String name){
  9.             int len = name.length();
  10.             for (int i = 0; i < len; i++) {
  11.                 System.out.print(name.charAt(i));
  12.             }
  13.             System.out.println();
  14.         }
  15.     }
  17.     public void init(){
  18.         // 注意这里要申明为final
  19.         final Outputer out = new Outputer();
  21.         // 线程1：打印zhangsan
  22.         new Thread(new Runnable() {
  24.             @Override
  25.             public void run() {
  26.                 while(true){
  27.                     try {
  28.                         Thread.sleep(50);
  29.                     } catch (InterruptedException e) {
  30.                         e.printStackTrace();
  31.                     }
  32.                     out.output("zhangsan");
  33.                 }
  34.             }
  36.         }).start();
  38.         // 线程2：打印lisi
  39.         new Thread(new Runnable() {
  41.             @Override
  42.             public void run() {
  43.                 while(true){
  44.                     try {
  45.                         Thread.sleep(50);
  46.                     } catch (InterruptedException e) {
  47.                         e.printStackTrace();
  48.                     }
  49.                     out.output("lisi");
  50.                 }
  51.             }
  53.         }).start();
  54.     }
  56.     public static void main(String[] args) {
  57.         new TraditionalThreadSychronized().init();
  58.     }
  59. }

如果不考虑线程安全问题的话，理想结果应该是zhangsan，lisi 循环打印，但是这里没有使用同步机制，输出结果中可以发现，出现了原本不想要的结果：
这里写图片描述
可以发现，打印出来的数据有些有问题。

解决办法： 采用同步机制，使用synchronized

使用同步解决线程安全问题

1、使用当前对象锁

  1. class Outputer{
  3.         // 这里打印，采取一个字母一个字母的打印，打印完一个名字再换行
  4.         public void output(String name){
  6.             synchronized(this){
  7.                 int len = name.length();
  8.                 for (int i = 0; i < len; i++) {
  9.                     System.out.print(name.charAt(i));
  10.                 }
  11.                 System.out.println();
  12.             }
  14.         }
  15.     }

2、使用当前对象属性的对象锁

  1. class Outputer{
  2.         private String xxx = "";
  4.         // 这里打印，采取一个字母一个字母的打印，打印完一个名字再换行
  5.         public void output(String name){
  7.             synchronized(xxx){
  8.                 int len = name.length();
  9.                 for (int i = 0; i < len; i++) {
  10.                     System.out.print(name.charAt(i));
  11.                 }
  12.                 System.out.println();
  13.             }
  15.         }
  16.     }

3、使用同步方法

  1. class Outputer{
  2.         private String xxx = "";
  4.         // 这里打印，采取一个字母一个字母的打印，打印完一个名字再换行
  5.         public synchronized void output(String name){
  6.             int len = name.length();
  7.             for (int i = 0; i < len; i++) {
  8.                 System.out.print(name.charAt(i));
  9.             }
  10.             System.out.println();
  11.         }
  12.     }

其实，使用同步方法，就是使用的当前对象的对象锁

输出结果：

这里写图片描述

打印结果中不再出现之前的打印问题，zhangsan，lisi都完整打印出来了，当然如果要实现轮流依次打印那种，之后会给出实现方案的，这里只讨论线程安全机制。

同步之间的互斥问题

第一种情况：同步代码块与同步方法

  1. package test01;
  3. public class TraditionalThreadSychronized { 
  5.     class Outputer{
  7.         // 同步代码块形式
  8.         public void output(String name){
  9.             synchronized(this){
  10.                 int len = name.length();
  11.                 for (int i = 0; i < len; i++) {
  12.                     System.out.print(name.charAt(i));
  13.                 }
  14.                 System.out.println();
  15.             }
  16.         }
  18.         // 同步方法形式
  19.         public synchronized void output2(String name){
  20.             int len = name.length();
  21.             for (int i = 0; i < len; i++) {
  22.                 System.out.print(name.charAt(i));
  23.             }
  24.             System.out.println();
  25.         }
  26.     }
  28.     public void init(){
  29.         // 注意这里要申明为final
  30.         final Outputer out = new Outputer();
  32.         // 线程1：打印zhangsan
  33.         new Thread(new Runnable() {
  35.             @Override
  36.             public void run() {
  37.                 while(true){
  38.                     try {
  39.                         Thread.sleep(50);
  40.                     } catch (InterruptedException e) {
  41.                         e.printStackTrace();
  42.                     }
  43.                     // 调用的是同步代码块形式的方法output
  44.                     out.output("zhangsan");
  45.                 }
  46.             }
  48.         }).start();
  50.         // 线程2：打印lisi
  51.         new Thread(new Runnable() {
  53.             @Override
  54.             public void run() {
  55.                 while(true){
  56.                     try {
  57.                         Thread.sleep(50);
  58.                     } catch (InterruptedException e) {
  59.                         e.printStackTrace();
  60.                     }
  61.                     // 调用的是同步方法形式的方法output2
  62.                     out.output2("lisi");
  63.                 }
  64.             }
  66.         }).start();
  67.     }
  69.     public static void main(String[] args) {
  70.         new TraditionalThreadSychronized().init();
  71.     }
  72. }

结果：不会出现线程安全问题。

分析：第一个线程调用的是同步代码块的方法output，第二个线程调用的是同步方法形式的方法output2，那么结果会怎么样了，会出现线程安全问题吗？答案当然是不会，前面说到了，同步方法其实使用的就是当前对象的对象锁，而同步代码块中用的也是当前对象的对象锁，所以肯定是互斥的，即不能当一个线程拿到了这个对象的对象锁的时候，其他对象不能调用当前对象需要对象锁的方法，说的通俗点就是，线程1进入output方法的时候，拿到了当前对象的对象锁，线程2没有当前对象的对象锁，所以访问不了方法output2，同样线程2拿到之后，线程1也访问不了output方法。

特殊情况：当然如果同步代码块中使用的是其他对象锁，那么就会出现线程安全问题了，因为两个方法使用的不是同一个对象的对象锁。

第二种情况：同步代码块与静态同步方法

  1. package test01;
  3. public class TraditionalThreadSychronized { 
  5.     static class Outputer{
  7.         // 同步代码块形式
  8.         public void output(String name){
  9.             synchronized(this){
  10.                 int len = name.length();
  11.                 for (int i = 0; i < len; i++) {
  12.                     System.out.print(name.charAt(i));
  13.                 }
  14.                 System.out.println();
  15.             }
  16.         }
  18.         // 同步方法形式
  19.         public synchronized void output2(String name){
  20.             int len = name.length();
  21.             for (int i = 0; i < len; i++) {
  22.                 System.out.print(name.charAt(i));
  23.             }
  24.             System.out.println();
  25.         }
  27.         // 静态同步代码块
  28.         public static synchronized void output3(String name){
  29.             int len = name.length();
  30.             for (int i = 0; i < len; i++) {
  31.                 System.out.print(name.charAt(i));
  32.             }
  33.             System.out.println();
  34.         }
  36.     }
  38.     public void init(){
  39.         // 注意这里要申明为final
  40.         final Outputer out = new Outputer();
  42.         // 线程1：打印zhangsan
  43.         new Thread(new Runnable() {
  45.             @Override
  46.             public void run() {
  47.                 while(true){
  48.                     try {
  49.                         Thread.sleep(50);
  50.                     } catch (InterruptedException e) {
  51.                         e.printStackTrace();
  52.                     }
  53.                     // 调用的是同步代码块形式的方法output
  54.                     out.output("zhangsan");
  55.                 }
  56.             }
  58.         }).start();
  60.         // 线程2：打印lisi
  61.         new Thread(new Runnable() {
  63.             @Override
  64.             public void run() {
  65.                 while(true){
  66.                     try {
  67.                         Thread.sleep(50);
  68.                     } catch (InterruptedException e) {
  69.                         e.printStackTrace();
  70.                     }
  71.                     // 调用的是静态同步方法形式的方法output3
  72.                     out.output3("lisi");
  73.                 }
  74.             }
  76.         }).start();
  77.     }
  79.     public static void main(String[] args) {
  80.         new TraditionalThreadSychronized().init();
  81.     }
  82. }

这里写图片描述

结果：会出现线程安全问题。
分析：同步代码块使用的是当前对象的对象锁，而静态同步方法使用的是当前静态类class的对象锁。
解决办法：同步代码块中使用当前类class的锁，如下：

  1. public void output(String name){
  2.         synchronized(Outputer.class){
  3.             int len = name.length();
  4.             for (int i = 0; i < len; i++) {
  5.                 System.out.print(name.charAt(i));
  6.             }
  7.             System.out.println();
  8.         }
  9.     }

第三种情况：同步方法与静态同步方法

代码就省略了
结果：会出现线程安全问题
分析：同步方法使用的是当前类的对象的对象锁，而静态同步方法使用的是当前类的class对象的对象锁

发表评论

表情：
评论列表 （有 0 条评论，389人围观）

还没有评论，来说两句吧...

相关阅读

    相关 linux多线程编程——同步与互斥

    我们在前面文章中已经分析了多线程VS多进程，也分析了线程的使用，现在我们来讲解一下linux多线程编程之同步与互斥。 现在，我们不管究竟是多线程好还是多进程好，先讲解一下，为

    红太狼红太狼/ 0 赞/ 110 阅读