synchronized关键字知多少

synchronized可以根据锁的类型分为两种:

1.锁对象

用法为同步代码块中的参数为一个对象或者一个非静态方法,这种锁主要用于单例模式中保护实例属性

存在以下两种情况

synchronized(this){

//可以为当年对象this,也可以为其他对象如String Object等

// do something,

}

public synchronized String getCode(){

//do something

}

2.锁Class

用法为同步代码块中的参数为Class类或者静态方法,这种锁用于protoType中,主要解决不同对象对static属性的更改的情况

存在以下两种情况

synchronized(Account.class){

// do something,

}

public static synchronized String getCode(){

//do something

}

3.对于synchronized(object)这种情况有很多需要注意的地方,

观察如下代码,线程直接的静态条件为count,如果count相同,则同步代码块会有序执行,如果count不同,则count并不会起作用

public class SynchronizedThread extends Thread {
    private Integer count;

    public SynchronizedThread(Integer count) {
        this.count = count;
    }

    @Override
    public void run() {
        synchronized (count) {
            System.out.println(Thread.currentThread().getName()+ "线程开始了~");
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+ "线程结束了~");
        }

    }
}

我们进行如下测试

@RunWith(SpringJUnit4ClassRunner.class)
public class SynchronizedTest {
    @Test
    public void testSynchronized() throws InterruptedException {
        for (int i =0 ; i < 5; i++) {
            Thread thread = new SynchronizedThread(1);
            thread.start();

        }
        Thread.sleep(1000);
    }
}

执行结果如下

Thread-2线程开始了~
Thread-2线程结束了~
Thread-6线程开始了~
Thread-6线程结束了~
Thread-5线程开始了~
Thread-5线程结束了~
Thread-4线程开始了~
Thread-4线程结束了~
Thread-3线程开始了~
Thread-3线程结束了~

可以发现线程正常执行,则可证明count为同一个Integer对象

此时我们将测试用例用的参数1改为128

@RunWith(SpringJUnit4ClassRunner.class)
public class SynchronizedTest {
    @Test
    public void testSynchronized() throws InterruptedException {
        for (int i =0 ; i < 5; i++) {
            Thread thread = new SynchronizedThread(128);
            thread.start();

        }
        Thread.sleep(1000);
    }
}

执行结果如下:

Thread-2线程开始了~
Thread-3线程开始了~
Thread-4线程开始了~
Thread-5线程开始了~
Thread-6线程开始了~
Thread-2线程结束了~
Thread-6线程结束了~
Thread-4线程结束了~
Thread-3线程结束了~
Thread-5线程结束了~

线程同步并未起作用,说明count并不是同一个对象,于是我才想起来Integer中-128<i<127的时候会返回同一个对象

public static Integer valueOf(int i) {
    assert IntegerCache.high >= 127;
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

结论:其实不只是Integer才会发生这种情况,String也存在常量池,如果使用不当也会造成同样的后果,synchronized虽然相对于其他的锁机制来说最简单,但也存在一些容易忽略的地方.