试着简单易懂记录synchronized this object Class的区别,模拟ConcurrentHashMap

修饰静态方法默认获取当前class的锁,同步方法没有释放的锁,不影响class其他非同步方法的调用,也不影响不同锁的同步方法,更不影响使用class的其他属性.

package thread.base.sync;

import java.util.concurrent.TimeUnit;

/**
*
* @author ZhenWeiLai
*
*/
public class A {

synchronized public static void saySomething() throws InterruptedException{
//前后可以写非同步代码
synchronized(A.class){
System.out.println("a");
TimeUnit.SECONDS.sleep(5);
}
//前后可以写非同步代码
}

//        /**
//         *     与上面相等(但是方法内没有非同步区域):可以这么理解,把synchronized当修饰符用总不能写成synchronized(A.claa) public static void saySomething()
//         *     这是静态方法啊,不需要实例就可以调用,那么我获取什么锁啊?只能获取本class的锁吖,你又不能给我传参
//         */
//        synchronized public static void saySomething() throws InterruptedException{
//                System.out.println("a");
//                TimeUnit.SECONDS.sleep(5);
//        }
}

修饰非静态方法,默认获取调用此方法的实例对象锁 Spring容器管理的bean默认都是单例的(当然可以注解为prototype),所以加上 synchronized 的方法,注解自动装配获取的实例,调用都会同步了

package thread.base.sync;

import java.util.concurrent.TimeUnit;

/**
*
* @author ZhenWeiLai
*
*/
public class A {

public void saySomething() throws InterruptedException {
//前面可以写非同步代码
synchronized (this) {
System.out.println("a");
TimeUnit.SECONDS.sleep(5);
}
//后面可以写非同步代码
}

//    /**
//     *     与上面相等,看了静态的,再看对象方法更好理解.
//     *  必须要有实例才能调用吧?太好办了那么我就获取当前实例对象的锁
//     */
//    synchronized public void saySomething() throws InterruptedException{
//            System.out.println("a");
//            TimeUnit.SECONDS.sleep(5);
//    }
}

synchronized (object)与synchronized (this)一样,获取实例对象的锁.因为synchronized (this)只能获取当前实例锁,那么synchronized (object)就是可以获取其他实例锁的意思

对于synchronized 最简单粗暴的理解就是,你要哪些线程方法同步,就跟他们获取一样的锁好了,A.class,就获取A.class, objectA 就获取 objectA(我说的不是对象名相同,而是真真切切在java堆中的同一个对象),

据说ConcurrentHashMap 就是用16个对象锁实现的

我也模拟一下

package thread.base.sync.hashmap;

import java.util.HashMap;
import java.util.concurrent.TimeUnit;

/**
*
* @author ZhenWeiLai 模拟16个并发的线程安全put
* @param <K>
* @param <V>
*/
public class SyncHashMap<K, V> extends HashMap<K, V> {
/**
*
*/
private static final long serialVersionUID = 4071859310703431745L;

// 初始化16个对象锁
Object[] lock = new Object[16];

public SyncHashMap() {
for (int i = 0; i < 16; i++) {
lock[i] = new Object();
}
}

/**
* 线程安全方法
*
* @param key
* @param value
* @return
* @throws InterruptedException
*/
public V safePut(K key, V value) throws InterruptedException {
/**
* 不一样的key有可能得到一样的余数,据说hashcode算法问题.我这里是取巧,不深究
* 万一两个不同的key得到一样的余数,那么慢的一个就要等待5秒咯
* 随机获取16个对象锁中的一个
*/
synchronized (lock[key.hashCode() % 16]) {
System.out.println("aaaa");
TimeUnit.SECONDS.sleep(5);
// 同步调用原生put方法
return super.put(key, value);
}
}

}

测试方法,两个key相同,其中获取锁慢的那个线程会等5秒再输出控制台

package thread.base.sync.hashmap;

/**
*
* @author ZhenWeiLai
*
*/
public class TestClass {
public static void main(String[] args) {
SyncHashMap<Integer,Integer> shm = new SyncHashMap<>();
new Thread(()->{
try {
//两个线程操作同一个key,
shm.safePut(1, 1);
} catch (Exception e) {
e.printStackTrace();
}
}).start();

new Thread(()->{
try {
//两个线程操作同一个key
shm.safePut(1,1);
} catch (Exception e) {
e.printStackTrace();
}
}).start();
}
}