1.Synchronized对象监视器为Object时的使用
1）Synchronized修饰方法时，持有当前对象的锁，当有多个对象时，不同的对象有不同对象的“监视器”。
2）当Synchronized修饰类中的一个方法，而该类中的另一个方法没被Synchronized修饰时，这种情况下当A线程先调用被Synchronized修饰的方法时，A线程就先持有object对象的Lock锁，但是B线程可以异步调用object对象中的非Synchronized类型的方法。
如果B线程在A线程调用Synchronized方法后再调用Synchronized方法，就需要等待，也就是同步。
2.脏读：发生脏读的情况是在读取实例变量时，此值已经被其他线程更改过了。
以下是一个脏读情况：PublicVar类中setValue被synchronized修饰，但是getValue没被synchronized修饰，在setValue的方法中将username修改后使线程sleep5000ms。这时username被更改但是userpassword没有被更改，此时主线程中的getValue（）读取了数据读到的是被更改的username “B” 和没被更改的userpassword “AA”。
public class PublicVar{
public String username = "A";
public String password = "AA";
synchronized public void setValue(String username,String password){
try {
this.username = username;
Thread.sleep(5000);
this.password = password;
System.out.println("setValue method thread name=" + Thread.currentThread().getName() + " username=" + username + " password=" + password);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void getValue(){
System.out.println("getValue method thread name=" + Thread.currentThread().getName() + " username=" + username + " password=" + password);
}
}
public class ThreadA extends Thread{
private PublicVar publicVar;
public ThreadA(publicVar publicVar){
super();
this.publicVar = publicVar;
}
@Override
public void run(){
super.run();
publicVar.setValue("B","BB");
}
}
public class Test{
public static void main(String[] args){
try{
PublicVar publicVarRef ＝ new PublicVar（）；
ThreadA thread ＝ new ThreadA（publicVarRef）；
thread.start();
thread.sleep(200);
publicVarRef.getValue();
} catch (InterruptedException e){
e.printStackTrace();
}
}
}
该脏读的解决方法就是在getValue（）方法前也加上synchronized关键字，这样一来当A线程调用anyObject对象加入synchronized关键字的X方法时，A线程就获得了X方法所在对象的锁，所以其他线程必须等A线程执行完毕才可以调用X方法，而B线程如果调用声明了synchronized关键字的非X方法时，必须等A线程将X方法执行完，也就是释放对象锁后才可以调用。这时A已经执行完一个完整的任务，也就是说username和userpassword这两个实例变量已经同时被赋值，不存在脏读的基本环境。
3.synchronized锁重入：关键字synchronized拥有锁重入的功能，也就是在使用synchronized时，当一个线程得到一个对象锁后，再次请求此对象锁时是可以再次得到该对象的锁的。这也证明在一个synchronized方法／块的内部调用本类的其他synchronized方法／块时，是永远可以得到锁的。
子类是完全可以通过“可重入锁”调用父类的同步方法的。
“可重入锁”的概念是：自己可以再次获取自己的内部锁。比如有1条线程获得了某个对象的锁，此时这个对象锁还没有释放，当其再次想要获取这个对象的锁的时候还是可以获取的，如果锁不可重入的话就会造成死锁。
（底层原理是JVM的管程来实现详细可以看另一篇博客）
4.出现异常，锁自动释放：当一个线程执行代码出现异常时，其所持有的锁会自动释放。（底层也是管程来实现：如果一个同步方法执行期间抛出了异常，并且在方法内部无法处理此异常，那么这个同步方法所持有的管程将在异常抛到同步方法之外时自动释放）。
5.同步不具有继承性：父类方法有synchronized关键字，子类重写该方法不带synchronized关键字，那么子类该方法就不是同步。
6.synchronized方法的缺点及synchronized代码块的优点：synchronized关键字修饰方法的缺点就在于，当该方法需要长时间执行时，另一个线程需要等待持有线程执行完才能允许。 synchronized修饰代码块就可以解决这个缺点，当两个并发线程访问同一个对象object中的synchronized（this）同步代码块时，一段时间内只有一个线程被执行，另一个线程必须等待当前线程执行完这个代码后才能执行该代码。也就是说在方法内同步代码块外的部分可以异步执行。那么将长时间执行的一部分代码置于同步代码块外就能异步执行这一耗时较长的代码块，从而缩短运行时间。
7.synchronized代码块：关于synchronized（this）需要注意的是，当一个线程访问object的一个synchronized（this）同步代码块时，其他线程对同一个object中所有其他synchronized（this）同步代码块的访问将被阻塞，这说明synchronized使用的“对象监视器”是一个。和synchronized方法一样，synchronized（this）代码也是锁定当前对象。
8.将任意对象作为对象监视器：多个线程调用同一个对象中的不同名称的synchronized同步方法或synchronized（this）同步代码块时，调用的效果就是按顺序执行，也就是同步的，阻塞的。
这说明synchronized同步方法或synchronized（this）同步代码块分别有两种作用
（1）synchronized同步方法
1）对其他synchronized同步方法或synchronized（this）同步代码块调用呈阻塞状态。
2）同一时间只有一个线程可以执行synchronized同步方法中的代码。
（2）synchronized（this）同步代码块
1）对其他synchronized同步方法或synchronized（this）同步代码块调用呈阻塞状态。
2）同一时间只有一个线程可以执行synchronized（this）同步方法中的代码。
synchronized（非this对象x）同步代码块
1）在多个线程持有“对象监视器”为同一对象的前提下，同一时间只有一个线程可以执行synchronized（非this对象x）同步代码块。
2）当持有“对象监视器”为同一个对象的前提下，同一时间只有一个线程可以执行synchronized（非this对象x）同步代码块中的代码。
锁非this对象具有一定的优点：如果在一个类中有很多个synchronized方法，这时虽然能实现同步，但会受到阻塞，所以影响运行效率；但如果使用同步代码块锁非this对象，则synchronized（非this）代码块中的程序与同步方法是异步的，不与其他锁this同步方法争抢this锁，则可大大提高运行效率。
9.下面是一个两个synchronized同步方法之间的脏读现象：main线程开始执行时Thread1先执行并进入if (list.getSize() < 1) 判断语句中，并进入睡眠，但是另一个线程可以异步也进入if (list.getSize() < 1) 这个判断语句中那么这两个就都可以add（data）。
因为它们持有的是不同的对象监视器：同步代码块放在非同步synchronized方法中进行声明，并不能保证调用方法的线程的执行同步／顺序性，也就是线程调用方法的顺序是无序的，虽然在同步块中执行的顺序是同步的，这样极易出现脏读问题。
public class MyOneList{
private List list = new ArrayList();
synchronized public void add(String data){
list.add(data);
}
synchronized public int getSize(){
return list.size();
}
}
public class MyService {
public MyOneList addServiceMethod(MyOneList list,String data){
try {
if (list.getSize() < 1) {
Thread.sleep(2000);
list.add(data);
}
}catch(InterruptedException e){
e.printStackTrace();
}
return list;
}
}
public class MyThread1 extends Thread{
private MyOneList list;
public MyThread1(MyOneList list){
super();
this.list = list;
}
@Override
public void run(){
MyService msRef = new MyService();
msRef.addServiceMethod(list,"A");
}
}
public class MyThread2 extends Thread{
private MyOneList list;
public MyThread2(MyOneList list){
super();
this.list = list;
}
@Override
public void run(){
MyService msRef = new MyService();
msRef.addServiceMethod(list,"B");
}
}
public class run{
public static void main(String[] args) throws InterruptedException {
MyOneList list = new MyOneList();
MyThread1 thread1 = new MyThread1(list);
thread1.setName("A");
thread1.start();
MyThread2 thread2 = new MyThread2(list);
thread2.setName("B");
thread2.start();
Thread.sleep(6000);
System.out.println("listSize=" + list.getSize());
}
}
使用同步代码块可以避免上述脏读现象,添加synchronized (list) 可以使两个线程持有同一个对象监视器：
public class MyService {
public MyOneList addServiceMethod(MyOneList list,String data){
try {
synchronized (list) {
if (list.getSize() < 1) {
Thread.sleep(2000);
}
}
}catch(InterruptedException e){
e.printStackTrace();
}
return list;
}
}
“synchronized (非list对象x) ”格式的写法是将x对象本身作为“对象监视器”，这样就可以得出以下3个结论：
1）当多个线程同时执行synchronized (x)｛｝同步代码块时呈同步效果。
2）当其他线程执行x对象中synchronized同步方法时呈同步效果。
3）当其他线程执行x对象方法里面的synchronized (this）代码块时也是呈现同步效果。但需要注意：如果其他线程调用不加synchronized关键字的方法时，还是异步调用。
