Java多线程同步Synchronized使用分析

开发 后端
Synchronized 锁定的是 类变量 ,即static 变量(可能是属性,可能是方法)(锁定类对象)

由于servlet 是多线程单例的。

struts1 的前端控制器是单例的,线程不安全的;每次请求都会用同一actionServlet;

struts2 的action不是单例的,线程安全的;每次请求都会新new一个action来接收;

因此如果使用 servlet 或者strtus1 线程安全问题,不能不考虑,下面内容。

同步的概念:

同步分为 同步方法 和 同步块 两种方式。

锁定的内容分为 锁定类的某个特定实例 和 锁定类对象(类的所有实例)

变量分为 实例变量(不带static的变量) 和 类变量(带static的变量)

使用同步的原因

1. 在系统中对访类要使用多线程进行访问;

2. 在该类中有 类变量, 或者是 在类的方法中有访问 公共资源(如一个外部文件的读写)。

同步锁锁定的内容是什么?

无论你将Synchronized加在方法前还是加在一个变量前,其锁定的都是一个 类对象。 每一个对象都只有一个锁与之相关联。

下例中分情况的列举各种情况下的同步效果

1. Synchronized 加在方法上, (同步方法,锁定类实例)

Java代码

  1. public class Demo1 {     
  2.     
  3.     public synchronized void m1(){     
  4.         //...............     
  5.     }     
  6.     
  7.     public void m2(){     
  8.         //............     
  9.     
  10.         synchronized(this){     
  11.             //.........     
  12.         }     
  13.     
  14.         //........     
  15.     }     
  16. }    

 

这两种写法的效果是一样的,锁定的都是类实例对象。如果有一个 类实例对象: demo = new Demo1(),另外有两个线程: thread1,thread2,都调用了demo 对象,那么,在同一时间,如果 thread1调用了demo.m1(),则thread2在该时间内不能访问demo.m1() 和 demo.m2(); 因为thread1把demo这个对象的锁使用了,所以无法分给其它线程使用

但是,如果thread1调用 demo1.m1(), thread2调用 demo2.m1(), 则可以同时进行,因为它们调用的是不同的Demo1类对象实例。

2. Synchronized 加在变量上, (同步块,锁定类实例)

Java代码

  1. public class Demo2 {     
  2.     Object a = new Object();     
  3.     Object b = new Object();     
  4.     
  5.     public void m1(){     
  6.         //............     
  7.     
  8.         synchronized(a){     
  9.             //.........     
  10.         }     
  11.     
  12.         //........     
  13.     }     
  14.     
  15.     public void m2(){     
  16.         //............     
  17.     
  18.         synchronized(b){     
  19.             //.........     
  20.         }     
  21.     
  22.         //........     
  23.     }     
  24. }    

 

这种情况下,是实现代码块锁定,锁定的对象是 变量 a 或 b; (注意,a 、b 都是非static 的)如果有一个 类实例对象: demo = new Demo2(),另外有两个线程: thread1,thread2,都调用了demo 对象,那么,在同一时间,如果 thread1调用了demo.m1(),则thread2在该时间内可以访问demo.m2();但不能访问 demo.m1() 的同步块, 因为a被 thread1锁定了。

3. Synchronized 锁定的是 类变量 ,即static 变量(可能是属性,可能是方法)(锁定类对象)

Java代码

  1. public class Demo3 {     
  2.     static Object o = new Object();     
  3.     
  4.     public static synchronized void m1() {     
  5.         //....     
  6.     }     
  7.     
  8.     public static void m2() {     
  9.         //...     
  10.         synchronized (Demo3.class) {     
  11.             //.....     
  12.         }     
  13.         //.....     
  14.     }     
  15.     
  16.     public static void m3() {     
  17.         //..........     
  18.         try {     
  19.             synchronized (Class.forName("Demo3")) {     
  20.               //............     
  21.             }     
  22.         } catch (ClassNotFoundException ex) {     
  23.         }     
  24.         //.............     
  25.     }     
  26.     
  27.     public static void m4() {     
  28.         //............     
  29.        synchronized(o){     
  30.          //........     
  31.        }     
  32.         //..........     
  33.     }     
  34. }    

 

以上4个方法中实现的效果都是一样的,其锁定的对象都是类Demo3,而不是类实例对象 ,即在多线程中,其共享的资源是属于类的,而不是属于类对象的。在这种情况下,如果thread1 访问了这4个方法中的任何一个, 在同一时间内其它的线程都不能访问 这4个方法。

4. 类的方法中访问了多线程共同的资源, 且该资源是可变的,这种情况下也是需要进行同步的

Java代码

  1. public class Demo4 {     
  2.     static String path = "file path";     
  3.     
  4.     public void readConfiFile() {     
  5.         synchronized (path) {     
  6.            // 读取该path指定的文件。     
  7.         }     
  8.     
  9.     }     
  10.     
  11.     public void writeConfiFile() {     
  12.         synchronized (path) {     
  13.             //写信息到该path指定的文件。     
  14.         }     
  15.     }     
  16. }    

 

这种情况下,必须锁定为 类变量,而不能进行锁定类实例对象,因为这是变象的一种类资源共享,而不是类实例对象资源共享。

线程,成也其,败也其,用好了可以提升性能,用不好则会使系统后患无穷。

PS: 进行线程同步需要很大的系统开销, 所以,在使用时,如果不是必须的,则尽量不使用同步功能。

【编辑推荐】

Java多线程编程的常见陷阱

Java多线程编程实战精要

如何理解Java多线程编程的相关问题

带你走进Java多线程编程的神秘世界

实战Java多线程编程之不提倡的方法

责任编辑:金贺 来源: ITEYE博客
相关推荐

2009-06-29 18:44:28

Java多线程Synchronize同步变量

2009-06-29 18:32:52

Java多线程Synchronize

2009-06-29 18:26:11

Java多线程Synchronize同步类

2017-05-27 20:59:30

Java多线程synchronize

2010-03-15 19:37:00

Java多线程同步

2010-01-21 11:27:30

linux多线程机制线程同步

2015-07-22 09:39:38

IOS多线程同步

2015-07-22 09:51:51

iOS开发线程

2011-06-22 13:57:54

Java多线程

2016-11-10 16:30:22

Java多线程

2011-06-22 13:47:16

Java多线程

2009-03-24 08:56:23

数据同步多线程Java

2012-06-05 02:12:55

Java多线程

2015-09-10 09:30:54

Java多线程同步

2013-07-16 12:13:27

iOS多线程多线程概念GCD

2009-09-14 19:39:14

批量线程同步

2010-03-15 16:47:30

Java多线程同步

2010-01-21 11:22:35

Linux多线程同步

2010-01-21 11:23:49

Linux多线程同步消息队列

2010-03-15 16:31:34

Java多线程
点赞
收藏

51CTO技术栈公众号