一文解析Synchronized

1 三个窗口卖50张票

1.1 TicketWindowRunnable

public class TicketWindowRunnable implements Runnable {
    private int index = 1;
    private final static int MAX = 50;
    @Override
    public void run() {
        while (true) {
            if (index > MAX) {
                break;
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " 的号码是：" + index++);
        }
    }
}

1.2 测试

public class BankTest {
    public static void main(String[] args) {
        TicketWindowRunnable runnable=new TicketWindowRunnable();
        Thread t1=new Thread(runnable,"一号窗口");
        Thread t2=new Thread(runnable,"二号窗口");
        Thread t3=new Thread(runnable,"三号窗口");
        t1.start();
        t2.start();
        t3.start();
    }
}

2 synchronized

关键字synchronized可以保证在同一时刻，只有一个线程可以执行某个方法或某个代码块。

2.1 修改TicketWindowRunnable

 public class TicketWindowRunnable implements Runnable {
    private int index = 1;
    private final static int MAX = 50;
    private final Object LOCK = new Object();
    @Override
    public void run() {
        while (true) {
            synchronized (LOCK) {
                if (index > MAX) {
                    break;
                }
                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " 的号码是：" + index++);
            }
        }
    }
}

2.2 测试

3 查看汇编

#编译
javac -encoding UTF-8  TicketWindowRunnable.java
#汇编
javap -c TicketWindowRunnable.class

4 synchronized应用方式

4.1 对象锁

(1) 代码

public class SynchronizedTest {
    public static void main(String[] args) {
        ObjectSynchronized lock=new ObjectSynchronized();
        Thread t1=new Thread(lock::m1,"t1");
        Thread t2=new Thread(lock::m2,"t2");
        t1.start();
        t2.start();
    }
}
/**
* 创建对象锁，锁同步方法快
*/
class ObjectSynchronized {
    private final Object LOCK = new Object();
    public void m1(){
        synchronized (LOCK){
            System.out.println(Thread.currentThread().getName()+",invoke ObjectSynchronized  m1 start");
            try {
                Thread.sleep(5*1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+",invoke ObjectSynchronized  m1 end");
        }
    }
    public void m2(){
        synchronized (LOCK){
            System.out.println(Thread.currentThread().getName()+",invoke ObjectSynchronized  m2 start");
            try {
                Thread.sleep(5*1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+",invoke ObjectSynchronized  m2 end");
        }
    }
}

4.2 This锁

 public class SynchronizedTest {
    public static void main(String[] args) {
        ThisSynchronized lock = new ThisSynchronized();
        Thread t1 = new Thread(lock::m1, "t1");
        Thread t2 = new Thread(lock::m2, "t2");
        t1.start();
        t2.start();
    }
}
/**
* 同步函数其实用到的锁就是 this 锁
*/
class ThisSynchronized {
    public  synchronized  void m1() {
        System.out.println(Thread.currentThread().getName() + ",invoke ObjectSynchronized  m1 start");
        try {
            Thread.sleep(5 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ",invoke ObjectSynchronized  m1 end");
    }
    public synchronized void m2() {
        System.out.println(Thread.currentThread().getName() + ",invoke ObjectSynchronized  m2 start");
        try {
            Thread.sleep(5 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ",invoke ObjectSynchronized  m2 end");
    }
}

4.3 This锁和对象锁同时存在时

public class SynchronizedTest {
    public static void main(String[] args) {
        ObjectAndThisSynchronized lock = new ObjectAndThisSynchronized();
        Thread t1 = new Thread(lock::m1, "t1");
        Thread t2 = new Thread(lock::m2, "t2");
        t1.start();
        t2.start();
    }
}
class ObjectAndThisSynchronized {
    private final Object LOCK = new Object();
    public void m1() {
        synchronized (LOCK) {
            System.out.println(Thread.currentThread().getName() + ",invoke ObjectSynchronized  m1 start");
            try {
                Thread.sleep(5 * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ",invoke ObjectSynchronized  m1 end");
        }
    }
    public synchronized void m2() {
        System.out.println(Thread.currentThread().getName() + ",invoke ObjectSynchronized  m2 start");
        try {
            Thread.sleep(5 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ",invoke ObjectSynchronized  m2 end");
    }
}

4.4 创建两个对象时

public class SynchronizedTest {
    public static void main(String[] args) {
        ObjectAndThisSynchronized lock1 = new ObjectAndThisSynchronized();
        ObjectAndThisSynchronized lock2 = new ObjectAndThisSynchronized();
        Thread t1 = new Thread(lock1::m1, "t1");
        Thread t2 = new Thread(lock2::m1, "t2");
        t1.start();
        t2.start();
    }
}

class ObjectAndThisSynchronized {

    public synchronized void m1() {
        System.out.println(Thread.currentThread().getName() + ",invoke ObjectSynchronized  m1 start");
        try {
            Thread.sleep(5 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ",invoke ObjectSynchronized  m1 end");
    }
}

4.5 static锁

public class SynchronizedTest {
    public static void main(String[] args) {
        Thread t1=new Thread(StaticSynchronized::m1,"t1");
        Thread t2=new Thread(StaticSynchronized::m2,"t2");
        t1.start();
        t2.start();
    }
}
class StaticSynchronized {
    public static synchronized void m1() {
        System.out.println(Thread.currentThread().getName() + ",invoke ObjectSynchronized  m1 start");
        try {
            Thread.sleep(5 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ",invoke ObjectSynchronized  m1 end");
    }
    public static synchronized void m2() {
        System.out.println(Thread.currentThread().getName() + ",invoke ObjectSynchronized  m2 start");
        try {
            Thread.sleep(5 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + ",invoke ObjectSynchronized  m2 end");
    }
}

5 死锁分析

public class DeadLock {
    private static final Object LOCK1=new Object();
    private static final Object LOCK2=new Object();
    public static void main(String[] args) {
        Thread t1=new Thread(()->{
            synchronized (LOCK1){
                try {
                    Thread.sleep(5*10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (LOCK2){
                }
            }
        },"t1");
        Thread t2=new Thread(()->{
            synchronized (LOCK2){
                synchronized (LOCK1){
                }
            }
        },"t2");
        t1.start();
        t2.start();
    }
}

扫描二维码关注公众号，回复： 11444497 查看本文章