synchronized、Lock锁

Lock锁

可重入锁：ReentrantLock类

public class LockTest {

    public static void main(String[] args) {
        Test a = new Test("小红");
        new Thread(a).start();
        new Thread(a).start();
    }

    static class Test implements Runnable{

        int ticket = 10;
        String name;

        public Test(String name){
            this.name = name;
        }

        @Override
        public void run() {
//            synchronized (this){
//            }
            ReentrantLock lock = new ReentrantLock();
                try {
                    lock.lock();
                    while (ticket > 0) {
                        Thread.sleep(100);
                        System.out.println(this.name + ":拿到了第"+ticket--);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    lock.unlock();
                }
            }
        }
}

小红:拿到了第10
小红:拿到了第9
小红:拿到了第8
小红:拿到了第7
小红:拿到了第5
小红:拿到了第6
小红:拿到了第4
小红:拿到了第3
小红:拿到了第2
小红:拿到了第1

lock记得finally里面将lock.unlock();关闭

synchronized、lock

lock是显示锁(手动开启关闭)

synchronized是隐式锁,出了作用域自动释放锁；

lock只有代码块锁,synchronized有代码块锁、对象锁、方法锁;

lock锁，JVM花费时间更少，使用效率高，

synchronized锁使用范围更广;

优先顺序

lock > synchronized代码块 > synchronized方法锁;

死锁情况

产生死锁条件

1.互斥条件：一个资源每次只能被一个进程使用；

2.请求与保持条件：一个进程在获取其他资源阻塞时，并不释放自己占用的资源；

3.不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺；

4.循环等待条件：多个进程间形成一种头尾相接的循环等待资源关系；

例

public class SynchronizedTest implements Runnable{
    // static 修饰,保证资源只一份
    static JingZi jz = new JingZi();
    static KouHong kh = new KouHong();
    int number;
    String name;

    public SynchronizedTest(int number,String name){
        this.number = number;
        this.name = name;
    }
    @Override
    public void run() {
        getA();
    }
    public void getA(){
        if(number == 0){
            synchronized (jz){
                System.out.println(this.name + ":获得了镜子的锁");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (kh){
                    System.out.println(this.name + ":获得了口红的锁");
                }
            }
        }else{
            synchronized (kh){
                System.out.println(this.name + ":获得了口红的锁");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (jz){
                    System.out.println(this.name + ":获得了镜子的锁");
                }
            }
        }
    }
    static  class JingZi{}
    static class KouHong{}
    static class Test{
        public static void main(String[] args) {
            SynchronizedTest a = new SynchronizedTest(0,"AAA");
            SynchronizedTest b = new SynchronizedTest(1,"BBB");
            new Thread(a).start();
            new Thread(b).start();
        }
    }
}

AAA:获得了镜子的锁
BBB:获得了口红的锁

两个人一人占了一个锁，都没办法进行下一步；