Lock用法總結分享

Lock

在上一篇文章中我們講到如何使用關鍵字synchronized來實現同步存取。本文我們繼續來探討這個問題，從Java 5之後，在java.util.concurrent.locks套件下提供了另外一種方式來實現同步訪問，那就是Lock。

也許有朋友會問，既然都可以透過synchronized來實現同步存取了，那麼為什麼還需要提供Lock？這個問題將在下面進行闡述。本文先從synchronized的缺陷講起，然後再講述java.util.concurrent.locks包下常用的有哪些類和接口，最後討論以下一些關於鎖的概念方面的東西

#synchronized缺陷

前面我們說過synchronized的執行緒釋放鎖的情況有兩種:

1. 程式碼區塊或同步方法執行完畢

2. 程式碼區塊或同步方法出現異常有jvm自動釋放鎖定

#從上面的synchronized釋放鎖定可以看出，只有synchronized程式碼區塊執行完畢或異常才會釋放，如果程式碼區塊中的程式因為IO原因阻塞了，那麼執行緒將永遠不會釋放鎖，但是此時另外的執行緒還要執行其他的程序，極大的影響了程式的執行效率，現在我們需要一種機制能夠讓執行緒不會一直無限的等待下去，能夠回應中斷，這個透過lock就可以辦到

另外如果有一個程序，包含多個讀線程和一個寫線程，我們可以知道synchronized只能一個一個線程的執行，但是我們需要多個讀線程同時進行讀，那麼使用synchronized肯定是不行的，但是我們使用lock同樣可以辦到

Lock

查看API可知，Lock是一個接口，因此是不可以直接創建對象的，但是我們可以利用其實現的類別來創建對象，這個先不著急，我們先看看Lock類別到底實現了什麼方法,具體的實現我們將會在介紹其實現的類別的時候再詳細的講解

方法

• lock() 取得鎖，如果沒有取得就會一直等待

• ##unlock() 釋放鎖定

• tryLock() 嘗試取得鎖定，如果成功取得鎖定就執行，如果沒有成功取得鎖定，那麼就不會等待了

• lockInterruptibly() 如果目前執行緒未中斷，則取得鎖定。

ReentrantLock

ReentrantLock是可重入鎖，是實作Lock介面的一個類，可重入是一種執行緒的分配機制，可重入的意思就是總是分配給最近獲得鎖的線程，這是一種不公平的分配機制，將會出現飢餓現象，當然為了解決這種現象，ReentrantLock的構造方法還提供了一個fair參數，如果fair為true表示使用公平分配機制，將會有等待時間最長的執行緒獲得鎖定

建構方法

• ReentrantLock() 建立一個對象，預設使用的時可重入的機制

• ReentrantLock(boolean fair) 如果fair為true那麼使用的是公平分配機制

常用方法

• #lock() 取得鎖，如果沒有取得到將會一直阻塞

下面使用一段程式示範以下lock方法的使用，程式碼如下:

##

//实现接口的线程类public class MyThread implements Runnable {public ReentrantLock rLock = null;  //注意这里的锁一定要是全局变量，否则每一个线程都创建一把锁，那么将会毫无意义
 public MyThread() {this.rLock = new ReentrantLock(); // 创建默认的可重入锁}// 将unlock方法放在finally中确保执行中代码出现异常仍然能够释放锁，否则将会造成其它的线程阻塞public void display() {this.rLock.lock(); // 获取锁try {for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + "正在输出"+ i);
            }
        } finally {this.rLock.unlock(); // 释放锁，注意这步是一定需要的}

    }@Overridepublic void run() {this.display(); // 调用display方法}

}//线程的测试类，主要是创建对象启动线程public class Test {public static void main(String[] args) {final MyThread thread = new MyThread(); // 创建对象// 下面创建两个线程,并且直接启动，new Thread(thread).start();new Thread(thread).start();

    }
}

執行上面的程式碼得到下圖的結果:

從上面的結果看出，線程是一個一個輸出的，並且只有等待一個線程輸出完畢才能執行下一個線程，這裡的僅僅是針對lock和unlock之間的代碼，之外的代碼並不是受到控制

#注意：

這裡的創建的可重入鎖的對象必須對於每一個線程來說是全局的變量，是可以共享的一個對象，如果你在display方法中創建這個對象，那麼是毫無意義的，因為每一個線程用的根本不是同一把鎖

• #boolean tryLock()

  首先嘗試獲取鎖，如果取得鎖了就執行，否則就不會一直等待

#下面使用一段程式碼嘗試以下這個方法，程式碼如下:

#

//实现接口的线程类public class MyThread implements Runnable {public ReentrantLock rLock = null; // 注意这里的锁一定要是全局变量，否则每一个线程都创建一把锁，那么将会毫无意义public MyThread() {this.rLock = new ReentrantLock(); // 创建默认的可重入锁}// 将unlock方法放在finally中确保执行中代码出现异常仍然能够释放锁，否则将会造成其它的线程阻塞public void display() {if (this.rLock.tryLock()) // 如果获取了锁{try {for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName()
                            + "正在输出" + i);
                }
            } finally {this.rLock.unlock(); // 释放锁，注意这步是一定需要的}

        } else {
            System.out.println(Thread.currentThread().getName()
                    + "获取锁失败，我将不会一直等待........");
        }

    }@Overridepublic void run() {this.display(); // 调用display方法}

}//线程的测试类，主要是创建对象启动线程public class Test {public static void main(String[] args) {final MyThread thread = new MyThread(); // 创建对象// 下面创建两个线程,并且直接启动，new Thread(thread).start();new Thread(thread).start();

    }
}

执行后的Lock用法總結分享如下图:

从上面的Lock用法總結分享我们知道线程0获取了锁开始执行，但是线程1并没有获取锁，但是使用的是tryLock并不是lock,因此不会一直等待下去，所以直接程序向下运行，直接跳过上锁的代码段，因此就输出了上面的那句话后直接结

ReadWriteLock

从API中可以知道，这个也是一个接口，用于实现读写线程，他有两个方法：Lock readLock(),Lock writeLock() 分别用于获得读锁和写锁，指定特定的锁可以实现特定的功能，比如读锁可以在写线程在执行的情况下可以实现多个读线程进行操作，下面我们来介绍它的具体的实现的类ReentrantReadWriteLock

ReentrantReadWriteLock

这个类也是一个可重入分配的类，当然前面已经说过了什么是可重入，现在我们来说说说这个类的详细的用法

构造方法

• ReentrantReadWriteLock() 使用默认（非公平）的排序属性创建一个新的 ReentrantReadWriteLock。

• ReentrantReadWriteLock(boolean fair) 使用给定的公平策略创建一个新的ReentrantReadWriteLock。

常用的方法

• ReentrantReadWriteLock.ReadLock readLock() 用于返回读取操作的锁

前面已经说过读取操作的锁是用来实现多个线程共同执行的，代码如下:

//实现接口的线程类public class MyThread implements Runnable {public ReentrantReadWriteLock rwlock = null;public Lock rLock = null;public MyThread() {this.rwlock = new ReentrantReadWriteLock(); // 创建对象，使用的是非公平的this.rLock = this.rwlock.readLock(); // 获取读取锁对象}// 将unlock方法放在finally中确保执行中代码出现异常仍然能够释放锁，否则将会造成其它的线程阻塞public void display() {this.rLock.lock(); // 获取读取锁try {for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + "正在输出"+ i);
            }
        } finally {this.rLock.unlock(); // 释放锁，注意这步是一定需要的}

    }@Overridepublic void run() {this.display(); // 调用display方法}

}//线程的测试类，主要是创建对象启动线程public class Test {public static void main(String[] args) {final MyThread thread = new MyThread(); // 创建对象// 下面创建两个线程,并且直接启动，for(int i=0;i<5;i++)
        {new Thread(thread).start();
        }
        


    }
}

执行上面的程序Lock用法總結分享如下:

从上面的Lock用法總結分享可以知道，其实使用读取操作是多个线程同时进行读取的操作，因此一定要小心谨慎的使用，根据自己的需求，一般不能在里面进行修改了，因为出现Lock用法總結分享不准确的Lock用法總結分享，这个就不多说了，相信大家都明白，总之要小心使用

• ReentrantReadWriteLock.WriteLock writeLock() 返回用于写入操作的锁

写入操作的锁和读取操作的锁不一样了，因为一次只能允许一个线程执行写入操作。

并且如果一个线程已经占用了读锁，另外一个线程申请写锁将会一直等待线程释放读锁。

如果一个线程已经占用了写锁，另外一个线程申请读锁，那么这个线程将会一直等待线程释放写锁才能执行。

总之意思就是写线程和读线程不能同时执行，但是多个读线程可以同时执行

下面将使用一个程序详细的体会以下读写锁的综合使用，代码如下：

//实现接口的线程类public class MyThread {public ReentrantReadWriteLock rwlock = null;public Lock rLock = null;public Lock wLock = null;public ArrayList<Integer> arrayList = null;public MyThread() {this.rwlock = new ReentrantReadWriteLock(); // 创建对象，使用的是非公平的this.rLock = this.rwlock.readLock(); // 获取读取锁对象arrayList = new ArrayList<>(); // 实例化this.wLock = this.rwlock.writeLock(); // 获取写入锁对象}// 将unlock方法放在finally中确保执行中代码出现异常仍然能够释放锁，否则将会造成其它的线程阻塞// //向arraylist中写入数据public void put() {this.wLock.lock(); // 获取写入锁try {for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName()
                        + "正在执行写入操作，写入" + i);this.arrayList.add(i);
            }
        } finally {this.wLock.unlock();
        }

    }// 从arraylist中读取数据，这里只是随机读取使用的是get，并没有做什么修改，因为这仅仅是读取操作，如果进行了修改必须实现同步public void get() {this.rLock.lock(); // 获取读取操作的锁Random random = new Random();if (!arrayList.isEmpty()) {try {for (int i = 0; i < 10; i++) {int index = random.nextInt(this.arrayList.size() - 1);int data = this.arrayList.get(index);
                    System.out.println(Thread.currentThread().getName()
                            + "正在读取数据     " + data);
                }
            } finally {this.rLock.unlock();

            }
        } else {
            System.out.println("ArrayList为空");
        }

    }

}//线程的测试类，主要是创建对象启动线程public class Test {public static void main(String[] args) {final MyThread thread = new MyThread(); // 创建对象ArrayList<Thread> arrayList = new ArrayList<>();/*         * 创建8个读线程，2个写线程         */for (int i = 0; i < 2; i++) {
            arrayList.add(new Thread() {@Overridepublic void run() {
                    thread.put();
                }
            });

        }        for(int i=0;i<8;i++)
        {
            arrayList.add(new Thread(){@Overridepublic void run() {
                    thread.get();
                }
            });
        }        
        
        
        for (Thread t : arrayList) {
            t.start();
        }

    }
}

Lock用法總結分享如下图:

从上面可以看出写入线程都是一个一个执行的，读取线程是一起执行的

注意： 所有的锁对象对于线程来说必须是全局变量，否则毫无意义。读线程只能进行不影响线程安全性的操作，比如不能进行对数据的修改插入，如果想要进行修改的话必须还要使用锁对必要的代码实现同步操作

参考文章

以上是Lock用法總結分享的詳細內容。更多資訊請關注PHP中文網其他相關文章！