java中怎么利用lockInterruptibly方法實現并發

這篇文章給大家介紹java中怎么利用lockInterruptibly方法實現并發，內容非常詳細，感興趣的小伙伴們可以參考借鑒，希望對大家能有所幫助。

lockInterruptibly方法是說線程在等待獲取鎖的同時還能響應線程interrupt方法的中斷請求。換句話說就是存在等待獲取鎖的同時還不能響應線程interrupt方法的中斷請求的情況，synchronized內置鎖便是，請看測試代碼：

public class LockInterruptTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Thread t1 = new Thread(){
            public void run(){
                synchronized (LockInterruptTest.class) {
                    while(true){
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        };
        t1.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        Thread t2 = new Thread(){
            public void run(){
                synchronized (LockInterruptTest.class) {
                    while(true){
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        };
        t2.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        Thread t3 = new Thread(){
            public void run(){
                System.out.println("準備中斷t2");
                t2.interrupt();
                System.out.println("中斷t2");
            }
        };
        t3.start();
    }

}
代碼中準備了3個線程，第2個線程嘗試獲取第1個線程的鎖，第3個線程嘗試中斷第2個線程。代碼是能夠正常看到“中斷t2”的，但是用jconsole工具就能看到第2個線程由于嘗試獲取鎖一直阻塞著：

換成lockInterruptibly后代碼如下：

public class LockInterruptTest {
    static ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) {
        Thread t1 = new Thread() {
            public void run() {
                try {
                    lock.lockInterruptibly();
                } catch (InterruptedException e1) {
                    e1.printStackTrace();
                }
                try {
                    while (true) {
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                } finally {
                    lock.unlock();
                }
            }
        };
        t1.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
        Thread t2 = new Thread() {
            public void run() {
                try {
                    lock.lockInterruptibly();
                    while (true) {
                        try {
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                } catch (InterruptedException e1) {
                    e1.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        };
        t2.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
        Thread t3 = new Thread() {
            public void run() {
                System.out.println("準備中斷t2");
                t2.interrupt();
                System.out.println("中斷t2");
            }
        };
        t3.start();
    }

}

通過jconsole工具可以發現第2個線程被成功中斷。
 

關于java中怎么利用lockInterruptibly方法實現并發就分享到這里了，希望以上內容可以對大家有一定的幫助，可以學到更多知識。如果覺得文章不錯，可以把它分享出去讓更多的人看到。