关于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关键字, 如果每个方法负责处理的是不同业务,  那么尽量采用第四种情形, 使用不同的对象锁处理, 而不是锁定整个对象.

转载地址：http://www.2cto.com/kf/201301/183773.html