Java同步锁(synchronized)、锁(lock)以及死锁

1、实体类

package com.cn.donleo.thread.phone;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author liangd
 * date 2020-11-02 08:53
 * code
 */
public class MyPhone implements Runnable {

    private int phoneNum = 100;
    /*
     * 同步锁的两种方式：
     * 1、锁对象   synchronized (this)
     * 2、锁方法   public synchronized void run()   锁方法其实是锁的当前对象，synchronized (this) ，synchronized (MyPhone.class)
     * 同步锁优缺点：
     * 1、解决了多线程安全问题
     * 2、增加了线程同步锁后，必须一个一个执行，浪费资源，降低了程序的运行效率
     */
    /**
     * 1、对不同的runnable传入同一个lock
     * 2、lock和synchronized类似，只不过这个是手动上锁，手动释放锁
     *    synchronized属于自动上锁和释放
     * 3、Lock和synchronized的区别
     *   1）synchronized试用于并发量小的，lock更适用于并发量大的
     *   2）lock更灵活，可以自由定义多把锁的枷锁解锁顺序
     *   3）Lock还有中断锁和定时锁。
     *   4）当线程运行到synchronized同步方法中，就会拥有obj对象的对象锁
     *   5）Wait会释放对象锁，sleep不会释放对象锁
     *   6）Synchronized用对象锁:
     */
    private Lock lock = new ReentrantLock();

    @Override
    public synchronized void run() {
        //while(true)是一个无穷循环语句  我们必须在他的循环语句内部加入一个判断  当他达到了什么要求就会跳出
        while (true) {
            //锁对象,指当前对象
//            synchronized (this){
//            synchronized ("Myphone"){
            if (phoneNum > 0) {
                lock.lock();
                try {
                    /*
                        1、卖手机的时候不可能都是同时卖出或者被预定在MyPhone类里面增加sleep
                         休眠100毫秒
                        2、淘宝最后一部手机进来
                           京东也有人预定手机，现在没有--，也可以进来
                           同理，拼多多也有人预定手机，现在没有--，也可以进来
                        3、会出现负数
                     */
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    //lock.unlock()要放在finally里面，因为如果上面报异常的情况下锁就不会手动释放，放在finally里面始终要执行
                    lock.unlock();
                }
                System.out.println(Thread.currentThread().getName() + "卖出了一部手机，还剩余" + --phoneNum + "部手机");
            } else {
                System.out.println("手机已经全部卖完，请下次再来");
                return;
            }
//            }

        }
    }
}

2、测试同步锁

package com.cn.donleo.thread.phone;

/**
 * @author liangd
 * date 2020-11-02 08:59
 * code 线程同步测试
 */
public class TestMyPhone {
    /**
     * 手机属于预定模式，分别由京东，淘宝，拼多多三个商家在卖
     * 现在有华为P40PRO手机100部，怎么来实现
     * 思考：
     * 1.有一百部手机
     * 2.京东，淘宝，拼多多是同时卖手机，属于三个线程
     * 3.有一个仓库进行发货，这个可以理解为main方法
     * @param args
     */
    public static void main(String[] args){
        MyPhone myPhone = new MyPhone();
            Thread tb = new Thread(myPhone,"淘宝");
            Thread jd = new Thread(myPhone,"京东");
            Thread pdd = new Thread(myPhone,"拼多多");
            tb.start();
            jd.start();
            pdd.start();

    }
}

3、测试死锁

package com.cn.donleo.thread.phone;

/**
 * @author liangd
 * date 2020-11-02 09:42
 * code 死锁测试
 */
public class TestSynchronized {
    /**
     * 1、死锁4个必要条件
     *  （1） 互斥条件：一个资源每次只能被一个进程使用。
     *  （2） 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
     *  （3） 不剥夺条件:进程已获得的资源，在未使用完之前，不能强行剥夺。
     *  （4） 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。
     * 2、如何避免死锁
     *  （1）加锁顺序（线程按照一定的顺序加锁）
     *  （2）加锁时限（线程尝试获取锁的时候加上一定的时限，超过时限则放弃对该锁的请求，并释放自己占有的锁）
     *  （3）死锁检测
     *   最简单的方式：不要写嵌套锁就好
     */
    public static void main(String[] args) {
        /*
         *  多次测试，出现死锁，程序一直在运行，A和B都没有吃到饭
         */
        //匿名内部类，直接new接口必须实现接口中的抽象方法
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized ("A") {
                    System.out.println(Thread.currentThread().getName() + "拿到A筷子了");
                    //嵌套锁
                    synchronized ("B") {
                        System.out.println(Thread.currentThread().getName() + "拿到A筷子了，同时拿到B筷子了，可以吃饭了");
                    }
                }
            }
        }, "男朋友").start();
        //再开一个线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized ("B") {
                    System.out.println(Thread.currentThread().getName() + "拿到B筷子了");
                    //嵌套锁
                    synchronized ("A") {
                        System.out.println(Thread.currentThread().getName() + "拿到B筷子了，同时拿到A筷子了，可以吃饭了");
                    }
                }
            }
        }, "女朋友").start();
    }
}