Synchronized原理

个人的形象理解就是，被synchronize修饰的对象，就像是一个坑位，但是不能蹲两个人！！！哈哈哈哈哈哈哈

---

造成线程安全问题的主要诱因

1. 存在共享数据
2. 存在多条线程共同操作这些数据

解决问题的根本方法：
同一时刻有且只有一个线程在操作共享数据，其他线程必须等到该线程处理完数据后再对共享数据进行操作。此时便引入了互斥锁。

互斥锁的特性：

1. 互斥性：即在同一时间只允许一个线程持有某个对象锁，通过这种特性来实现多线程的协调机制，这样在同一时间只有一个线程对需要同步的代码块（复合操作）进行访问。互斥性也称为操作的原子性。
2. 可见性：必须确保在锁被释放前，对共享变量所做的修改，对随后获得该锁的另一个线程是可见的（即在获得锁时应获得最新共享变量的值），否则另一个线程可能是在本地缓存的某个副本上继续操作，从而引起不一致。

synchronized锁的不是代码，锁的都是对象

根据获取的锁的分类：获取对象锁和获取类锁

获取对象锁的两种方法：

1. 同步代码块（synchronized(this)，synchronized(类实例对象)，锁是小括号中的实例对象）
   上代码

public class SyncDemo2 {
	public static void main(String[] args) {
		final Shop shop = new Shop();		
		Thread t1 = new Thread(){
			public void run(){
				shop.buy();
			}
		};
		Thread t2 = new Thread(){
			public void run(){
				shop.buy();
			}
		};
		t1.start();
		t2.start();
	}
}

class Shop{
//	public synchronized void buy(){
	public void buy(){
		Thread t = Thread.currentThread();
		try {
			System.out.println(t.getName()+":正在挑衣服");
			Thread.sleep(5000);
			
			synchronized (this) {
				System.out.println(t.getName()+":正在试衣服");
				Thread.sleep(5000);
			}
			
			
			System.out.println(t.getName()+":结账离开");
		} catch (Exception e) {
		}			
	}
}

输出：

2. 同步非静态方法（synchronized method），锁是当前对象的实例对象
   代码：

class Shop{
	public synchronized void buy(){
		Thread t = Thread.currentThread();
		try {
			System.out.println(t.getName()+":正在挑衣服");
			Thread.sleep(5000);
			
			synchronized (this) {
				System.out.println(t.getName()+":正在试衣服");
				Thread.sleep(5000);
			}
			
			
			System.out.println(t.getName()+":结账离开");
		} catch (Exception e) {
		}			
	}
}

输出：

获取类锁的两种方法：

1. 同步代码块（synchronized(类.class)，锁是小括号()中的类对象(Class对象)）

public class SyncDemo3 {
	public static void main(String[] args) {
		Thread t1 = new Thread(){
			public void run() {
				Boo.dosome();
			}
		};
		Thread t2 = new Thread(){
			public void run() {
				Boo.dosome();
			}
		};
		t1.start();
		t2.start();
	}
}

class Boo{
	public static void dosome() {
		synchronized (Boo.class) {
			Thread t = Thread.currentThread();
			try {
				System.out.println(t.getName() + ":正在运行dosome方法");
				Thread.sleep(5000);
				System.out.println(t.getName() + ":运行dosome方法完毕");

			} catch (Exception e) {
			}
		}
	}
}

输出：

2. 同步静态方法（synchronized static method），锁是当前对象的类对象（Class对象）

public class SyncDemo3 {
	public static void main(String[] args) {
		Thread t1 = new Thread(){
			public void run() {
				Boo.dosome();
			}
		};
		Thread t2 = new Thread(){
			public void run() {
				Boo.dosome();
			}
		};
		t1.start();
		t2.start();
	}
}

class Boo{
	public synchronized static void dosome(){
		Thread t = Thread.currentThread();
		try {
			System.out.println(t.getName()+":正在运行dosome方法");
			Thread.sleep(5000);
			System.out.println(t.getName()+":运行dosome方法完毕");
		} catch (Exception e) {
		}
	}
}

输出：

对象锁和类锁的总结

1. 有线程访问对象的同步代码块时，另外的线程可以访问该对象的非同步代码块；
2. 若锁住的是一个对象，一个线程在访问对象的同步代码块时，另一个访问对象的同步代码块的线程会被阻塞。
3. 若锁住的是同一个对象，一个线程在访问对象的同步方法时，另一个访问对象同步方法的线程会被阻塞。
4. 若锁住的是同一个对象，一个线程在访问对象的同步代码块时，另一个访问对象同步方法的线程会被阻塞，反之亦然。
5. 同一个类的不同对象的对象锁互不干扰
6. 类锁由于也是一种特殊的对象锁，因此表现和上述1，2，3，4一致，而由于一个类只有一把对象锁，所以同一个类的不同对象使用类锁将会是同步的
7. 类锁和对象锁互不干扰