synchronized的用法以及常见的使用错误

synchronized的作用是实现线程之间的同步，既能保证可见性，又能保证原子性。

用法也有很多种，如下所示

用一个线程类来演示下这三种:

指定加锁对象:

package com.bckj.Thread;

/**
 * Created by Admin on 2017/6/23.
 */
public class SynchronizedTest {
    static int x;
    static class AddThread implements Runnable{
        Object o = new Object();
        @Override
        public synchronized void run() {
            for(int i=1;i<=1000;i++){
                synchronized (o){
                    x++;
                }
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Runnable run = new AddThread();
        Thread addThread1 = new Thread(run);
        Thread addThread2 = new Thread(run);
        addThread1.start();
        addThread2.start();
        //让主线程等待上面两个线程执行完毕
        addThread1.join();
        addThread2.join();
        System.out.println(x);
    }
}

直接作用于实例方法:

package com.bckj.Thread;

/**
 * Created by Admin on 2017/6/23.
 */
public class SynchronizedTest {
    static int x;
    static class AddThread implements Runnable{
        public synchronized void increase(){
            x++;
        }
        @Override
        public synchronized void run() {
            for(int i=1;i<=1000;i++){
                increase();
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Runnable run = new AddThread();
        Thread addThread1 = new Thread(run);
        Thread addThread2 = new Thread(run);
        addThread1.start();
        addThread2.start();
        //让主线程等待上面两个线程执行完毕
        addThread1.join();
        addThread2.join();
        System.out.println(x);
    }
}

直接作用于静态方法:

package com.bckj.Thread;

/**
 * Created by Admin on 2017/6/23.
 */
public class SynchronizedTest {
    static int x;
    static class AddThread implements Runnable{
        public synchronized static void increase(){
            x++;
        }
        @Override
        public synchronized void run() {
            for(int i=1;i<=1000;i++){
                increase();
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Runnable run = new AddThread();
        Runnable run2 = new AddThread();
        Thread addThread1 = new Thread(run);
        Thread addThread2 = new Thread(run2);
        addThread1.start();
        addThread2.start();
        //让主线程等待上面两个线程执行完毕
        addThread1.join();
        addThread2.join();
        System.out.println(x);
    }
}

因为要体现静态方法，所以实例化了两个不同的AddThread对象。

新手使用synchronized的时候可能会犯下面的错误(不久前我也刚犯过)

1、

public class SynchronizedTest {
    static int x;
    static class AddThread implements Runnable{
        public synchronized void increase(){
            x++;
        }
        @Override
        public void run() {
            for(int i=1;i<=1000;i++){
                increase();
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Runnable run = new AddThread();
        Runnable run2 = new AddThread();
        Thread addThread1 = new Thread(run);
        Thread addThread2 = new Thread(run2);
        addThread1.start();
        addThread2.start();
        //让主线程等待上面两个线程执行完毕
        addThread1.join();
        addThread2.join();
        System.out.println(x);
    }
}

public class SynchronizedTest {
    static int x;
    static class AddThread implements Runnable{
        Object o = new Object();
        @Override
        public void run() {
            for(int i=1;i<=1000;i++){
                synchronized (o){
                    x++;
                }
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Thread addThread1 = new Thread(new AddThread());
        Thread addThread2 = new Thread(new AddThread());
        addThread1.start();
        addThread2.start();
        //让主线程等待上面两个线程执行完毕
        addThread1.join();
        addThread2.join();
        System.out.println(x);
    }
}

这两种都是对线程对象中的方法或局部变量进行加锁，但是又实例化了两个不同的Runnable实例，也就是说这两个线程使用的是两把不同的锁，因此不能保证线程安全，最后x的结果也会<=2000。

2、

第二种错误就比较隐晦

public class AddThread implements Runnable{
    static Integer x = 0;
    @Override
    public void run() {
        for(int i=1;i<=1000;i++){
            synchronized (x){
                x++;
            }
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Runnable run = new AddThread();
        Thread addThread1 = new Thread(run);
        Thread addThread2 = new Thread(run);
        addThread1.start();
        addThread2.start();
        //让主线程等待上面两个线程执行完毕
        addThread1.join();
        addThread2.join();
        System.out.println(x);
    }
}

这个程序看似没有错误，但是执行结果会得到比2000小的数值，主要是由于，Integer是不可变对象，对象一旦创建就不可能被修改。
通过javap反编译run方法可以看到：

可以看到i++在执行的时候变成了 i=Integer.valueOf(i.intValue()+1);

Integer.valueOf():

他会倾向于返回一个代表指定数值的Integer实例。因此，i++的本质是，创建一个新的Integer对象，并将它的引用赋值给i。

这样的话，就可以知道了，因为i这个对象可能一直在变，所以锁的对象一直在变，因此不能起到线程同步的作用，只要改成上面提到第一种用法的例子那样就可以解决。