java synchronized

synchronized

    最近在研究juc(java.util.concurrent)的源码，想了解一下juc的实现，看了一些东西，也有一些体会，在此想把自己的学到的一些东西记录下来，也算是做个分享。

    接触java多线程的同学相比对这个synchronized关键字不陌生了,通俗一点的将,synchronized用于方法上，表示任何时刻只有一个线程能执行这个方法，下面我会结合一些实例，讲讲synchronized。

• 设想一下一个最简单的场景，累加器(++操作)，一个简单的实现可能是下面这样子的:

public class Foo{
    private int count;
    public int countIncrement(){
        count++;
        return count;
    }
}

通常情况下我们认为上面的代码不是线程安全的版本,Foo的实例对象用于多线程情形，如果没有做同步操作，count值的正确性很难保证，一个简单容易联想到的实现是对countIncrement方法进行同步操作，对于java而言，只需把public int countIncrement() 方法的签名改成如下即可:

public synchronized int countIncrement()

上面的计数器对象这样一改以后就是线程安全的了，绝大多数学习java的同学第一次接触“同步”,可能都会是上面的形式，简单易懂，jdk原生提供这么一个关键字，加上了，我们的所有方法的操作都是线程安全的了。

---

以上是分割线，下面会以一些具体的实例讲解下synchronized较为复杂的用法以及带你正真弄明白synchronized关键字

• 我们来看以下场景,两个计数器,假设一个统计页面的pv,一个统计页面的uv,一个线程安全版本的计数器可以用以下对象表示:

public class SynchronizedClassWithLogic{
    // mCounter for pv,nCounter for uv
    protected int mCounter, nCounter;

    public SynchronizedClass() {
        this.mCounter = 0;
        this.nCounter = 0;
    }

    public SynchronizedClass(int mCounter, int nCounter) {
        this.mCounter = mCounter;
        this.nCounter = nCounter;
    }

    // only for single thread or outer synchronzied block
    public void mPlusPlus() {
        mCounter++;
        try {
            Thread.sleep(2);
        } catch (InterruptedException e) {
        }
    }

    // only for single thread or outer synchronzied block
    public void nPlusPlus() {
        nCounter++;
        try {
            Thread.sleep(2);
        } catch (InterruptedException e) {
        }
    }

    public synchronized void syncmPlusPlus() {
        mCounter++;
        try {
            Thread.sleep(2);
        } catch (InterruptedException e) {
        }
    }

    public synchronized void syncnPlusPlus() {
        nCounter++;
        try {
            Thread.sleep(2);
        } catch (InterruptedException e) {
        }
    }
}

从封装性来说，将pv uv的点击量放到一个class对象中，假定一个统计操作耗时2ms(通常情况下,这个数据可能需要做持久化，为了简便，此处假定耗时2ms，通过sleep来实现)，，然后通过synchronized关键字对mCounter nCounter两个对象做同步，保证线程安全。

看一个实例:

public class SynchronizedTest {

    protected static final long LOGIC_COUNT = 1000;

    @Test
    public void testSingleThreadLogicPlus() {
        SynchronizedClassWithLogic class1 = new SynchronizedClassWithLogic();
        long start = System.currentTimeMillis();
        for (int i = 0; i < LOGIC_COUNT; i++) {
            class1.mPlusPlus();
            class1.nPlusPlus();
        }
        long cost = System.currentTimeMillis() - start;
        printCost(class1.getMcounter(), class1.getNcounter(), cost);
    }

    protected void printCost(int m, int n, long cost) {
        System.out.println(String.format("(m,n) is (%d,%d)", m, n));
        System.out.println("cost is:" + cost);
    }
}

以上代码在我机器上运行结果如下:

(m,n) is (1000,1000)
cost is:4614

循环1000次,这段代码

             class1.mPlusPlus();
             class1.nPlusPlus();

耗时4ms,总耗时在4000ms,至于结果为什么多出600+ms是因为线程在调用sleep以后会挂起，挂起时间到达以后又会被重新调度执行，挂起与唤醒操作需要耗费一些cpu时间,所以总的时间应该会比4000ms多一点。

看看多线程版本的统计流程图:

pv/uv分别位于不同的线程，各自统计自己的数据

@Test
    public void testTwoThreadLogicPlus() throws InterruptedException {
        SynchronizedClassWithLogic class1 = new SynchronizedClassWithLogic();
        long start = System.currentTimeMillis();
        Runnable r1 = () -> {
            for (int i = 0; i < LOGIC_COUNT; i++) {
                class1.mPlusPlus();
            }
        };

        Runnable r2 = () -> {
            for (int i = 0; i < LOGIC_COUNT; i++) {
                class1.nPlusPlus();
            }
        };

        Thread t1 = new Thread(r1);
        t1.start();

        Thread t2 = new Thread(r2);
        t2.start();

        t1.join();
        t2.join();
        long cost = System.currentTimeMillis() - start;
        printCost(class1.getMcounter(), class1.getNcounter(), cost);
    }

结果如下:

(m,n) is (1000,1000)
cost is:2438

可以看到，多线程比示例一中的执行时间减少了近一半。

对于synchronized关键字，一个非常重要的一点需要搞清楚synchronized到底锁定的是什么，答案可以在java多线程程序设计这本书中找到，简而言之,以下两条规则是比较常见的:

• 对于实例对象的方法,synchronized的同步对象是当前对象例如:

class Foo{
    pulibc synchronized void m1(){
        // do something
    }
}

class Foo{
    public void m1(){
        synchronized(this){
            do something
        }   
    }
}

以上两种写法是等价的,synchronized同步的target是当前对象

• 对于静态方法，synchronized的对象是class对象

class Foo{
    public static synchronized m1(){
        // do some thiing
    }
}

class Foo{
    public static synchronized m1(){
        synchronized(Foo.class){
            // do some thing
        }   
    }
}

---

接下来，我们来说说锁,锁从概念上分两种,悲观锁,乐观锁(具体这两种锁的定义以及区别大家可自行google之)

• 悲观锁，对应于java中的synchronized实现，必须先持有之，然后才能执行同步快中的操作。
• 乐观锁，对应于juc中的基于cas实现的各种锁。

通常情况下乐观锁的效率(性能)是要比悲观锁好的，这也是为什么自jdk1.5发布之后juc大受追捧的原因。