synchronized锁的粒度

synchronized做代码块锁的时候，如果是使用自定义的锁，或者this对象作为锁，那么锁定的是对象，如果对于静态的对象做锁定，那么锁定的就是类了。

当线程A,在操作访问锁定的对象时候， 线程B如果要进入synchronized代码块执行的时候是必须等待锁释放的。这样实际上就是将原本并行执行的代码，变为串行执行了。

当然还有另外一种方式，就是使用ThreadLocal对象，存储各个线程的使用对象的副本，达到线程间使用数据的隔离。

关于synchronized代码块锁贴一段代码记录：

package com.zongqian.test.thread;

import java.util.concurrent.TimeUnit;

public class SynchronizedTest implements Runnable {
int a = 0;


public SynchronizedTest(int a) {
super();
this.a = a;
}

public void run() {
if(a==0){
//锁class
synchronized (SynchronizedTest.class) {
try {
// a++;
System.out.println("enter class synchronized,a="+a+","+Thread.currentThread().getName());
TimeUnit.SECONDS.sleep(5);
System.out.println("class,a="+a+","+Thread.currentThread().getName());
} catch (InterruptedException e) {
}
}
}else{
//锁当前对象
synchronized (this) {
try {
// a++;
System.out.println("enter object synchronized,a="+a+","+Thread.currentThread().getName());
TimeUnit.SECONDS.sleep(4);
System.out.println("object,a="+a+","+Thread.currentThread().getName());
} catch (InterruptedException e) {
}
}
}

}

public static void main(String[] args) throws InterruptedException {
SynchronizedTest st0 = new SynchronizedTest(0);
SynchronizedTest st01 = new SynchronizedTest(0);

SynchronizedTest st1 = new SynchronizedTest(1);
SynchronizedTest st11 = new SynchronizedTest(1);

//第一种情况：类锁，同一个对象，此时synchronized块里面只有一个线程
// new Thread(st0).start();
// TimeUnit.SECONDS.sleep(2);
// new Thread(st01).start();

//第二种情况：类锁，不同对象，此时synchronized块里面只有一个线程
// new Thread(st0).start();
// TimeUnit.SECONDS.sleep(2);
// new Thread(st01).start();

//第三种情况：this对象锁，同一个对象，此时synchronized块里面只有一个线程
// new Thread(st1).start();
// TimeUnit.SECONDS.sleep(2);
// new Thread(st1).start();

//第四种情况：this对象锁，不同对象，此时synchronized块里面是2个线程并行
new Thread(st1).start();
TimeUnit.SECONDS.sleep(2);
new Thread(st11).start();

}
}