Java多線(xiàn)程死鎖

線(xiàn)程活性問(wèn)題是由資源稀缺或者程序自身設(shè)計(jì)缺陷導(dǎo)致線(xiàn)程一直處于非RUNNABLE狀態(tài),或者線(xiàn)程雖然處于RUNNABLE狀態(tài),但是要執(zhí)行的任務(wù)一直無(wú)法進(jìn)展。

死鎖

如果兩個(gè)或者更多的線(xiàn)程因相互等待而被永遠(yuǎn)暫停,我們就稱(chēng)這些線(xiàn)程產(chǎn)生了死鎖。

有關(guān)死鎖的一個(gè)經(jīng)典問(wèn)題是哲學(xué)家就餐問(wèn)題。

package com.wkcto.threadactivity.deadlock;

/**
 * 定義筷子類(lèi)
 */
public class Chopstick {
    public final  int id;   //筷子編號(hào)

    public Chopstick(int id) {
        this.id = id;
    }

    @Override
    public String toString() {
        return "Chopstick-" + id;
    }
}

package com.wkcto.threadactivity.deadlock;

/**
 * 模擬哲學(xué)家就餐
 */
public class Test {
    public static void main(String[] args) {
        int num = 5;        //有5個(gè)哲學(xué)家,5根筷子
        //創(chuàng)建一個(gè)存儲(chǔ)5根筷子的數(shù)組
        Chopstick[] chopsticks = new Chopstick[num];
        //給數(shù)組中的筷子賦值
        for (int i = 0; i < chopsticks.length; i++) {
            chopsticks[i] = new Chopstick(i);
        }

        //創(chuàng)建5個(gè)哲學(xué)家線(xiàn)程
        for (int i = 0; i < num; i++) {
            Philosopher philosopher = new Philosopher(i, chopsticks[i], chopsticks[ (i+1) % num]);
            philosopher.start();
        }
    }
}

package com.wkcto.threadactivity.deadlock;

import java.util.Random;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 定義哲學(xué)家類(lèi),繼承Thread線(xiàn)程類(lèi)
 * 使用顯示鎖ReentrantLock的tryLock()方法申請(qǐng)鎖, 允許在申請(qǐng)鎖時(shí)指定一個(gè)超時(shí)時(shí)間
 */
public class Philosopher extends Thread {
    public final int id;    //哲學(xué)家編號(hào)
    public final Chopstick left;    //左邊筷子
    public final Chopstick right;   //右邊筷子

    public Philosopher(int id, Chopstick left, Chopstick right) {
        super("Philosopher==" + id);
        this.id = id;
        this.left = left;
        this.right = right;

    }

    //哲學(xué)家不斷的思考與吃飯
    @Override
    public void run() {
        while (true) {
            think();
            eat();
        }
    }

    final ReentrantLock leftLock = new ReentrantLock();
    final ReentrantLock rightLock = new ReentrantLock();

    private void eat() {
        //吃飯需要先拿左邊筷子,這根筷子就是被當(dāng)前哲學(xué)家獨(dú)占使用
        try {
            if (leftLock.tryLock(100, TimeUnit.MILLISECONDS)){
                System.out.println(this + " 拿起左邊筷子");
                Thread.sleep(new Random().nextInt(100));
                if (rightLock.tryLock(100, TimeUnit.MILLISECONDS)){
                    System.out.println(this + " 拿起右邊筷子, 有了一雙筷子,可以吃飯了");
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            if (rightLock.isHeldByCurrentThread()){
                rightLock.unlock();
            }
            if (leftLock.isHeldByCurrentThread()){
                leftLock.unlock();
            }
        }
    }

    private void think() {
        System.out.println(this + " 哲學(xué)家正在思考.....");
        try {
            Thread.sleep(new Random().nextInt(100));   //模擬思考時(shí)長(zhǎng)
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public String toString() {
        return "Philosopher{" +
                "id=" + id +
                ", left=" + left +
                ", right=" + right +
                '}';
    }
}

package com.wkcto.threadactivity.deadlock;

import java.util.Random;

/**
 * 定義哲學(xué)家類(lèi),繼承Thread線(xiàn)程類(lèi)
 */
public class Philosopher1 extends  Thread{
    public final int id;    //哲學(xué)家編號(hào)
    public final Chopstick left;    //左邊筷子
    public final Chopstick right;   //右邊筷子

    public Philosopher1(int id, Chopstick left, Chopstick right) {
        super("Philosopher==" + id );
        this.id = id;
        this.left = left;
        this.right = right;
    }

    //哲學(xué)家不斷的思考與吃飯
    @Override
    public void run() {
        while (true){
            think();
            eat();
        }
    }

    private void eat() {
        //吃飯需要先拿左邊筷子,這根筷子就是被當(dāng)前哲學(xué)家獨(dú)占使用
        synchronized ( left ){
            System.out.println(this + " 拿起左邊的筷子");
            try {
                Thread.sleep(new Random().nextInt(100));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //有了左邊筷子后,還需要拿右邊筷子
            synchronized (right){
                System.out.println(this + "有了一雙筷子,可以吃飯");
            }
        }

    }

    private void think() {
        System.out.println( this + " 哲學(xué)家正在思考.....");
        try {
            Thread.sleep(new Random().nextInt(100));   //模擬思考時(shí)長(zhǎng)
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public String toString() {
        return "Philosopher{" +
                "id=" + id +
                ", left=" + left +
                ", right=" + right +
                '}';
    }
}

package com.wkcto.threadactivity.deadlock;

import java.util.Random;

/**
 * 定義哲學(xué)家類(lèi),繼承Thread線(xiàn)程類(lèi)
 *  可以使用粗鎖化解決死鎖問(wèn)題
 *  某一時(shí)刻只允許一個(gè)哲學(xué)家吃飯,在某個(gè)哲學(xué)家吃飯時(shí),其他哲學(xué)家要么進(jìn)行思考,要么等待
 *  實(shí)際上,哲學(xué)家吃飯只需要兩根筷子, 現(xiàn)在有5根筷子,可以允許兩個(gè)哲學(xué)家同時(shí)吃飯. 現(xiàn)在使用粗鎖化只允許有一個(gè)哲學(xué)家吃飯,出現(xiàn)了資源浪費(fèi)的情況
 */
public class Philosopher2 extends  Thread{
    public final int id;    //哲學(xué)家編號(hào)
    public final Chopstick left;    //左邊筷子
    public final Chopstick right;   //右邊筷子

    public Philosopher2(int id, Chopstick left, Chopstick right) {
        super("Philosopher==" + id );
        this.id = id;
        this.left = left;
        this.right = right;
    }

    //哲學(xué)家不斷的思考與吃飯
    @Override
    public void run() {
        while (true){
            think();
            eat();
        }
    }
    private static  final Object OBJ = new Object();        //定義常量作為鎖對(duì)象
    private void eat() {
        synchronized ( OBJ ){
            System.out.println(this + " 拿起左邊的筷子");
            try {
                Thread.sleep(new Random().nextInt(100));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(this + "拿起右邊筷子后,就有了一雙筷子,可以吃飯");

        }

    }

    private void think() {
        System.out.println( this + " 哲學(xué)家正在思考.....");
        try {
            Thread.sleep(new Random().nextInt(100));   //模擬思考時(shí)長(zhǎng)
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public String toString() {
        return "Philosopher{" +
                "id=" + id +
                ", left=" + left +
                ", right=" + right +
                '}';
    }
}

package com.wkcto.threadactivity.deadlock;

import java.util.Random;

/**
 * 定義哲學(xué)家類(lèi),繼承Thread線(xiàn)程類(lèi)
 *  可以保證所有線(xiàn)程使用相同的鎖的順序來(lái)避免死鎖
 *  可以給所有的筷子設(shè)置一個(gè)編號(hào), 對(duì)于哲學(xué)家來(lái)說(shuō) ,始終先拿編號(hào)小的筷子,再拿編號(hào)大的筷子
 */
public class Philosopher3 extends  Thread{
    public final int id;    //哲學(xué)家編號(hào)
    public final Chopstick left;    //左邊筷子
    public final Chopstick right;   //右邊筷子

    public Philosopher3(int id, Chopstick left, Chopstick right) {
        super("Philosopher==" + id );
        this.id = id;
       //根據(jù)筷子編號(hào)賦值,如果left筷子編號(hào)小于right編號(hào)正常賦值
        if (left.id < right.id){
            this.left = left;
            this.right = right;
        }else {
            this.left = right;
            this.right = left;
        }
    }

    //哲學(xué)家不斷的思考與吃飯
    @Override
    public void run() {
        while (true){
            think();
            eat();
        }
    }
    private void eat() {
        //吃飯需要先拿左邊筷子,這根筷子就是被當(dāng)前哲學(xué)家獨(dú)占使用
        synchronized ( left ){
            System.out.println(this + " 拿起左邊的筷子");
            try {
                Thread.sleep(new Random().nextInt(100));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //有了左邊筷子后,還需要拿右邊筷子
            synchronized (right){
                System.out.println(this + "有了一雙筷子,可以吃飯");
            }
        }

    }

    private void think() {
        System.out.println( this + " 哲學(xué)家正在思考.....");
        try {
            Thread.sleep(new Random().nextInt(100));   //模擬思考時(shí)長(zhǎng)
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    @Override
    public String toString() {
        return "Philosopher{" +
                "id=" + id +
                ", left=" + left +
                ", right=" + right +
                '}';
    }
}