【并发技术03】传统线程互斥技术—synchronized

在多个线程同时操作相同资源的技术技术时候，就会遇到并发的传统问题，如银行转账啊、线程售票系统啊等。互斥为了避免这些问题的技术技术出现，我们可以使用 synchronized 关键字来解决，传统下面针对 synchronized 常见的线程用法做一个总结。首先写一个存在并发问题的互斥程序，如下： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 public class TraditionalThreadSynchronized { public static void main(String[] args) { //在静态方法中不能new内部类的技术技术实例对象 //private Outputer outputer = new Outputer(); new TraditionalThreadSynchronized().init(); } private void init() { final Outputer outputer = new Outputer(); //线程1打印：duoxiancheng new Thread(new Runnable() {           @Override public void run() { while(true) { try { Thread.sleep(5); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } outputer.output1("duoxiancheng"); } } }).start();; //线程2打印：eson15 new Thread(new Runnable() {           @Override public void run() { while(true) { try { Thread.sleep(5); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } outputer.output1("eson15"); } } }).start();; } static class Outputer { //自定义一个字符串打印方法，一个个字符的传统打印 public void output1(String name) { int len = name.length(); for(int i = 0; i < len; i++) { System.out.print(name.charAt(i)); } System.out.println("");      }        } }

在内部类 Outputer 中定义了一个打印字符串的方法，一个字符一个字符的线程打印，这样比较容易直观的互斥看出并发问题，因为字符顺序打乱了就说明出现问题了。技术技术然后在 init 方法中开启两个线程，传统一个线程打印 “duoxiancheng” ，线程另一个线程打印 “eson15”。看一下运行结果：

eson15duoxianche

ng

eson15

duoxiancheng

duoxiancheng

eson15

esduoxiancheng

on15

duoxiancheng

从输出的结果中可以看到，已经出现问题了，为了解决这个问题，可以使用 synchronized 同步代码块来对公共部分进行同步操作，但是需要给它一把锁，这把锁是服务器托管一个对象，可以是任意一个对象，但是前提是，两个线程使用的必须是同一个对象锁才可以，这很好理解。那么下面在  output1 ()  方法中加入 synchronized 代码块：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 static class Outputer { private String token = ""; //定义一个锁 public void output1(String name) { synchronized(token) //任何一个对象都可以作为参数，但是该对象对于两个线程来说是同一个才行 //如果用name就不行了，因为不同的线程进来name是不一样的，不是同一个name { int len = name.length(); for(int i = 0; i < len; i++) { System.out.print(name.charAt(i)); } System.out.println("");      } } }

经过上面的改造，线程安全问题就基本解决了，但是还可以再往下引申，如果在方法上加 synchronized 关键字的话，那么这个同步锁是什么呢？我们在 Outputer 类中再写一个  output2 ()  方法：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 static class Outputer { private String token = ""; //定义一个锁 public void output1(String name) { synchronized(token) //任何一个对象都可以作为参数，但是该对象对于两个线程来说是同一个才行 { int len = name.length(); for(int i = 0; i < len; i++) { System.out.print(name.charAt(i)); } System.out.println("");      } }    public synchronized void output2(String name) { int len = name.length(); for(int i = 0; i < len; i++) { System.out.print(name.charAt(i)); } System.out.println("");      }    }

方法内部实现逻辑一模一样，唯一不同的就是香港云服务器 synchronized 加在了方法上，那么我们让  init ()  方法中的两个线程中，一个调用  output1 ( String name )  方法，另一个调用  output2 ( String name )

 方法，从结果中能看出，线程安全问题又出现了。产生问题的原因不难发现：现在两个方法都加了 synchronized，但是两个线程在调用两个不同的方法还是出现了问题，也就是说，还是各玩各的……那么问题就出在这个锁上，说明两者并没有使用同一把锁！

如果我们把  output1 ()  方法中 synchronized 中的 token 改成 this，再运行就没问题了，这说明一点： synchronized 关键字修饰方法的时候，同步锁是 this，即等效于代码块   synchronized ( this ) { ...}

。

再继续往下引申，现在在 Outputer 类中再写一个静态方法  output3 ( String name ) ，并且也让 synchronized 去修饰这个静态方法。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 static class Outputer { private String token = ""; //定义一个锁 public void output1(String name) { synchronized(token) //任何一个对象都可以作为参数，但是该对象对于两个线程来说是源码下载同一个才行 { int len = name.length(); for(int i = 0; i < len; i++) { System.out.print(name.charAt(i)); } System.out.println("");      } }    public static synchronized void output3(String name) { int len = name.length(); for(int i = 0; i < len; i++) { System.out.print(name.charAt(i)); } System.out.println("");      }    } }

然后在  init ()  方法中一个线程调用  output1 ()  方法，另一个线程调用  output3 ()  方法。毫无疑问，肯定又会出现线程安全问题。但是如何解决呢？因为 static 方法在类加载的时候就加载了，所以这个锁应该是类的字节码对象。那么将 token 改为  Outputer . class  就解决问题了，这说明一点： synchronized 关键字修饰 static 方法的时候，同步锁是该类的字节码对象，即等效于代码块   synchronized ( classname . class ) { ...}

。

最后再总结一下：

同步代码块的锁是任意对象 。只要不同的线程都执行同一个同步代码块的时候，这个锁随便设。

同步函数的锁是固定的 this 。当需要和同步函数中的逻辑实行同步的时候，代码块中的锁必须为 this。

静态同步函数的锁是该函数所属类的字节码文件对象 。该对象可以用  this . getClass ()  方法获取，也可以使用  当前类名. class  表示。

如果觉得对您有帮助，转发给更多人吧~