Synchronized升级过程是怎样的

Synchronized 方法

1: Synchronized 是java的内置锁，也是排它锁和非公平锁，排它锁也就是当前线程获取锁后，其他线程都会阻塞挂起 ，非公平锁是在线程后去锁的时候会先尝试后去锁，获取不到在进行阻塞。

2: Synchronized 是如何保证 '原子性' 的？是因为进入 Synchronized 块的内存语义是把 Synchronized 块内使用的 '工作内存清除'， 这样在使用共享变量时就会直接存主内存中获取并复制到工作你内存中，在退出 Synchronized 语句块时 会把 工作内存中计算过的 '共享变量' 更新到主内存中。

3: 获取到 Synchronized 锁 ，都是 '对象锁'而非'代码块锁' (锁的都是对象或类，而不是某个方法)，因此 Synchronized 是具有可重入性，在获取到该对象锁后可以不用再次获取该对象其他方法的锁，直接进入。

4: 如果是 Synchronized 用在 static 上， 就代表是类锁(.class)，无论创建多少个对象都不可行；

区别

wait和sleep区别在于wait会释放锁， 但是sleep不会释放锁 ，sleep会导致线程阻塞挂起。

wait/wait(timeout)/notify/notifyAll 方法仅可以在获取到锁后才可以使用。

解释

wait： 线程等待。

wait(time)： 线程等待，如果时间超过了设置的time，则继续执行。

notify： 随机唤醒一个等待的线程。

notifyAll： 唤醒全部等待线程。

代码演示

/**
 * @Auther: concurrenncy
 * @Date: 2019-03-25 16:43
 * @Company: 随行付支付有限公司
 * @maill: lan_tao@suixingpay.com
 * @Description: wait 和 sleep 区别在于 wait会释放锁， 但是 sleep 不会 ，sleep会导致线程阻塞挂起
 */
        public class WaitAndNotifyTest {
            private static Object obj = new Object();
            public static void main(String[] args) {
                // 创建线程 thread1
                Thread thread1 = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            System.out.println(Thread.currentThread().getName() + "   begin wait...");
                            synchronized (obj) {
                                obj.wait();
                            }
                            System.out.println(Thread.currentThread().getName() + "   end wait...");
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }, "thread1");
                // 创建线程 thread2
                Thread thread2 = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            System.out.println(Thread.currentThread().getName() + "   begin wait...");
                            synchronized (obj) {
                                obj.wait();
                            }
                            System.out.println(Thread.currentThread().getName() + "   end wait...");
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }, "thread2");
                // 启动
                thread1.start();
                thread2.start();
                try {
                    // 睡眠一秒
                    Thread.sleep(1000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 如果调用 notify 的线程未获取 对象锁，在调用 notify 的时候会抛出 java.lang.IllegalMonitorStateException 异常
                synchronized (obj) {
                    // 唤醒 使用 obj 调用 wait 方法的其中一个线程 (随机)
                    obj.notify();
                    // 唤醒 使用呢 obj 调用 wait 方法的所有线程
                    obj.notifyAll();
                }
            }
        }