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();
    }
}