关于JAVA多线程并发synchronized的测试与合理使用

在项目开发中, 或许会碰到JAVA的多线程处理, 为保证业务数据的正常, 必须加上锁机制,  常用的处理方法一般是加上synchronized关键字, 目前JDK版本对synchronized已经做了很好的优化,  我们不用再考虑其性能,  但在实际使用中,  往往由于处理不当,  导致系统性能的严重下降, 那么该如何合理的使用synchronized,  必须对其使用方式有个全面了解, 在网上搜寻的资料, 给出的是四种使用方式, 其实可总结为两种, 一个是同步代码块, 一个是同步方法体, 那么该如何使用, 请看下面的测试

  准备两个方法,  对同一个变量做加法, 再对每个方法, 分别开十个线程执行:

  [java]

  public class ThreadUnit

  {

  private int i = 0;

  private Object obj1 = new Object();

  private Object obj2 = new Object();

  public synchronized Integer doAdd1(Long start) throws Exception

  {

  Thread.sleep(100);

  ++i;

  Thread.sleep(100);

  return i;

  }

  public Integer doAdd2(Long start) throws Exception

  {

  Thread.sleep(100);

  ++i;

  Thread.sleep(100);

  return i;

  }

  }

  相关代码:

  [java]

  // 十个线程同时执行方法2

  for (int i = 0; i < 10; i++)

  {

  new Thread(new MessageThread(1, threadUnit))。start();

  }

  // 十个线程同时执行方法2

  for (int j = 0; j < 10; j++)

  {

  new Thread(new MessageThread(2, threadUnit))。start();

  }

  线程处理:

  [java]

  public void run()

  {

  try

  {

  if (operate == 2)

  {

  long start = System.currentTimeMillis();

  int i = threadUnit.doAdd2(start);

  long takeTime = System.currentTimeMillis() - start;

  System.out.println("doAdd2() => i=" + i + ", spendTime=" + takeTime + "ms");

  spendTime += takeTime;

  }

  else

  {

  long start = System.currentTimeMillis();

  int i = threadUnit.doAdd1(start);

  long takeTime = System.currentTimeMillis() - start;

  System.out.println("doAdd1() => i=" + i + ", spendTime=" + takeTime + "ms");

  spendTime += takeTime;

  }

  }

  catch (Exception e)

  {

  e.printStackTrace();

  }

  }

  运行结果:

  1. 在两个方法体上都加上synchronized

  [java]

  public synchronized Integer doAdd1(Long start) throws Exception

  [java]

  public synchronized Integer doAdd2(Long start) throws Exception

  执行结果:

  [html]

  doAdd1() => i=1, spendTime=203ms

  doAdd2() => i=2, spendTime=406ms

  doAdd2() => i=3, spendTime=609ms

  doAdd2() => i=4, spendTime=796ms

  doAdd2() => i=5, spendTime=1000ms

  doAdd2() => i=6, spendTime=1203ms

  doAdd2() => i=7, spendTime=1406ms

  doAdd2() => i=8, spendTime=1609ms

  doAdd2() => i=9, spendTime=1812ms

  doAdd2() => i=10, spendTime=2015ms

  doAdd2() => i=11, spendTime=2218ms

  doAdd1() => i=12, spendTime=2406ms

  doAdd1() => i=13, spendTime=2609ms

  doAdd1() => i=14, spendTime=2812ms

  doAdd1() => i=15, spendTime=3015ms

  doAdd1() => i=16, spendTime=3218ms

  doAdd1() => i=17, spendTime=3421ms

  doAdd1() => i=18, spendTime=3625ms

  doAdd1() => i=19, spendTime=3828ms

  doAdd1() => i=20, spendTime=4015ms

  花费时间:42226ms

  都是有序执行, 变量值没有产生错乱, 但花费时间42226ms

  2.在doAdd1方法上加上synchronized, doAdd2不加。

  [java]

  public synchronized Integer doAdd1(Long start) throws Exception

  执行结果:

  [java]

  doAdd1方法加上synchronized:

  doAdd1() => i=9, spendTime=204ms

  doAdd2() => i=9, spendTime=188ms

  doAdd2() => i=9, spendTime=188ms

  doAdd2() => i=9, spendTime=188ms

  doAdd2() => i=9, spendTime=188ms

  doAdd2() => i=9, spendTime=188ms

  doAdd2() => i=9, spendTime=188ms

  doAdd2() => i=9, spendTime=188ms

  doAdd2() => i=9, spendTime=188ms

  doAdd2() => i=9, spendTime=188ms

  doAdd2() => i=9, spendTime=188ms

  doAdd1() => i=10, spendTime=391ms

  doAdd1() => i=11, spendTime=610ms

  doAdd1() => i=12, spendTime=813ms

  doAdd1() => i=13, spendTime=1016ms

  doAdd1() => i=14, spendTime=1219ms

  doAdd1() => i=15, spendTime=1422ms

  doAdd1() => i=16, spendTime=1610ms

  doAdd1() => i=17, spendTime=1813ms

  doAdd1() => i=18, spendTime=2016ms

  花费时间:12994ms

  doAdd2方法瞬间执行完成, 之后doAdd1方法则是串行有序执行。 这时doAdd2方法获取的变量值已经错乱,  doAdd1获取的正常。  花费时间:12994ms

  3. 两个方法在都没使用synchronized前的情况:

  执行结果:

  [java]

  doAdd1() => i=16, spendTime=203ms

  doAdd1() => i=16, spendTime=203ms

  doAdd1() => i=16, spendTime=203ms

  doAdd1() => i=16, spendTime=203ms

  doAdd1() => i=16, spendTime=203ms

  doAdd1() => i=16, spendTime=203ms

  doAdd1() => i=16, spendTime=203ms

  doAdd1() => i=16, spendTime=203ms

  doAdd1() => i=16, spendTime=203ms

  doAdd2() => i=16, spendTime=203ms

  doAdd2() => i=16, spendTime=203ms

  doAdd2() => i=16, spendTime=203ms

  doAdd1() => i=16, spendTime=203ms

  doAdd2() => i=16, spendTime=203ms

  doAdd2() => i=16, spendTime=203ms

  doAdd2() => i=16, spendTime=203ms

  doAdd2() => i=16, spendTime=203ms

  doAdd2() => i=16, spendTime=203ms

  doAdd2() => i=16, spendTime=203ms

  doAdd2() => i=16, spendTime=203ms

花费时间:4060ms

  可以看到, 两个方法的变量值获取已经错乱,  但花费时间最少4060ms

  4. 使用同步块, 在两个方法内采用不同的对象锁:

  doAdd1:

  [java]

  synchronized (obj1)

  {

  Thread.sleep(100);

  ++i;

  Thread.sleep(100);

  return i;

  }

  doAdd2:

  [java]

  synchronized (obj2)

  {

  Thread.sleep(100);

  ++i;

  Thread.sleep(100);

  return i;

  }

  执行结果:

  [html]

  doAdd1() => i=2, spendTime=203ms

  doAdd2() => i=2, spendTime=203ms

  doAdd1() => i=4, spendTime=406ms

  doAdd2() => i=4, spendTime=406ms

  doAdd1() => i=6, spendTime=609ms

  doAdd2() => i=6, spendTime=609ms

  doAdd1() => i=8, spendTime=812ms

  doAdd2() => i=8, spendTime=812ms

  doAdd1() => i=10, spendTime=1000ms

  doAdd2() => i=10, spendTime=1015ms

  doAdd1() => i=12, spendTime=1203ms

  doAdd2() => i=12, spendTime=1203ms

  doAdd1() => i=14, spendTime=1406ms

  doAdd2() => i=14, spendTime=1406ms

  doAdd1() => i=16, spendTime=1609ms

  doAdd2() => i=16, spendTime=1609ms

  doAdd1() => i=18, spendTime=1812ms

  doAdd2() => i=18, spendTime=1812ms

  doAdd1() => i=20, spendTime=2015ms

  doAdd2() => i=20, spendTime=2015ms

  花费时间:22165ms

  两个方法有序交替执行, 互不影响,  花费时间:22165ms, 相对加锁同一对象执行的时间缩短。

  5. 使用同步块, 使用方法参数作为对象锁:

  [java]

  public Integer doAdd1(Long start) throws Exception

  {

  synchronized (start)

  {

  Thread.sleep(100);

  ++i;

  Thread.sleep(100);

  return i;

  }

  }

  执行结果:

  [java]

  doAdd1() => i=15, spendTime=203ms

  doAdd1() => i=15, spendTime=203ms

  doAdd1() => i=15, spendTime=203ms

  doAdd1() => i=15, spendTime=203ms

  doAdd1() => i=15, spendTime=203ms

  doAdd1() => i=15, spendTime=203ms

  doAdd1() => i=15, spendTime=203ms

  doAdd2() => i=15, spendTime=203ms

  doAdd2() => i=15, spendTime=203ms

  doAdd1() => i=15, spendTime=203ms

  doAdd1() => i=15, spendTime=203ms

  doAdd2() => i=15, spendTime=203ms

  doAdd2() => i=15, spendTime=203ms

  doAdd2() => i=15, spendTime=203ms

  doAdd2() => i=15, spendTime=203ms

  doAdd2() => i=15, spendTime=203ms

  doAdd2() => i=15, spendTime=203ms

  doAdd2() => i=15, spendTime=203ms

  doAdd1() => i=15, spendTime=203ms

  doAdd2() => i=15, spendTime=203ms

  花费时间:4060ms

  执行效果和第三种情况相同,  每个参数作为不同的对象, 即便加上synchronized也不能起到锁的效果。

  6. 把调用的类改为静态类, 只在一个方法上加锁:

  加锁doAdd1方法:

  [java]

  public static synchronized Integer doAdd1(Long start) throws Exception

  执行结果:

  [html]

  doAdd1() => i=9, spendTime=203ms

  doAdd2() => i=9, spendTime=203ms

  doAdd2() => i=9, spendTime=203ms

  doAdd2() => i=9, spendTime=203ms

  doAdd2() => i=9, spendTime=203ms

  doAdd2() => i=9, spendTime=203ms

  doAdd2() => i=9, spendTime=203ms

  doAdd2() => i=9, spendTime=203ms

  doAdd2() => i=9, spendTime=203ms

  doAdd2() => i=9, spendTime=203ms

  doAdd2() => i=9, spendTime=203ms

  doAdd1() => i=10, spendTime=406ms

  doAdd1() => i=11, spendTime=609ms

  doAdd1() => i=12, spendTime=812ms

  doAdd1() => i=13, spendTime=1015ms

  doAdd1() => i=14, spendTime=1218ms

  doAdd1() => i=15, spendTime=1406ms

  doAdd1() => i=16, spendTime=1609ms

  doAdd1() => i=17, spendTime=1812ms

  doAdd1() => i=18, spendTime=2015ms

  花费时间:13135ms

  和第二种情形类似,  没有加锁的doAdd2方法瞬间执行完成,  doAdd1方法则是串行有序执行。

  总结:

  1. synchronized关键在于锁定的对象, 如果是同一对象, 那么所有执行线程, 必须等待对象锁释放后才能执行,  如果是不同对象,  那么只对各对象所关联的线程生效。

  2. synchronized若加在方法体上,  默认锁定的是对象本身。 对于所有加锁的方法,  都是按照串行规则有序执行,  对于没有加锁的方法, 不受任何影响,  静态类同理。

  3. 合理使用synchronized, 既要保证稳定性, 又要保证性能, 需要在两者间作出权衡,  尽量把synchronized范围细度化, 合理控制业务处理流程;  对象操作原子化, 减少锁的使用;

  不要盲目在方法体上加synchronized关键字, 如果每个方法负责处理的是不同业务,  那么尽量采用第四种情形, 使用不同的对象锁处理, 而不是锁定整个对象。

上一篇:B-树和B+树


下一篇:HDU6038-Function-数学+思维-2017多校Team01