Lock锁的使用

Posted edda

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Lock锁的使用相关的知识,希望对你有一定的参考价值。

   在Java多线程中,可以使用synchronized关键字实现线程之间的同步互斥,在jdk1.5后新增的ReentrantLock类同样可达到此效果,且在使用上比synchronized更加灵活。

观察ReentrantLock类可以发现其实现了Lock接口

public class ReentrantLock implements Lock,java.io.Serializable

1、使用ReentrantLock实现同步

   lock()方法:上锁

   unlock()方法:释放锁

  1. /*
  2. * 使用ReentrantLock类实现同步
  3. * */
  4. class MyReenrantLock implements Runnable{
  5. //向上转型
  6. private Lock lock = new ReentrantLock();
  7. public void run() {
  8. //上锁
  9. lock.lock();
  10. for(int i = 0; i < 5; i++) {
  11. System.out.println("当前线程名: "+ Thread.currentThread().getName()+" ,i = "+i);
  12. }
  13. //释放锁
  14. lock.unlock();
  15. }
  16. }
  17. public class MyLock {
  18. public static void main(String[] args) {
  19. MyReenrantLock myReenrantLock = new MyReenrantLock();
  20. Thread thread1 = new Thread(myReenrantLock);
  21. Thread thread2 = new Thread(myReenrantLock);
  22. Thread thread3 = new Thread(myReenrantLock);
  23. thread1.start();
  24. thread2.start();
  25. thread3.start();
  26. }
  27. }

                        技术图片

由此我们可以看出,只有当当前线程打印完毕后,其他的线程才可继续打印,线程打印的数据是分组打印,因为当前线程持有锁,但线程之间的打印顺序是随机的。

即调用lock.lock()代码的线程就持有了“对象监视器”,其他线程只有等待锁被释放再次争抢。

2、使用Condition实现等待/通知

synchronized关键字结合wait()notify()notifyAll()方法的使用可以实现线程的等待与通知模式。在使用notify()notifyAll()方法进行通知时,被通知的线程是JVM随机选择的。

ReentrantLock类同样可以实现该功能,需要借助Condition对象,可实现“选择性通知”。Condition类是jdk1.5提供的,且在一个Lock对象中可以创建多个Condition(对象监视器)实例。

Condition类的await():是当前执行任务的线程处于等待状态

  1. /*
  2. * 错误的使用Condition实现等待、通知
  3. * */
  4. class MyCondition implements Runnable{
  5. private Lock lock = new ReentrantLock();
  6. public Condition condition = lock.newCondition();
  7. public void run() {
  8. try {
  9. System.out.println("当前线程名:"+Thread.currentThread().getName()+" 开始等待时间:"+System.currentTimeMillis());
  10. //线程等待
  11. condition.await();
  12. System.out.println("我陷入了等待...");
  13. } catch (InterruptedException e) {
  14. e.printStackTrace();
  15. }
  16. }
  17. }
  18. public class MyLock{
  19. public static void main(String[] args) {
  20. MyCondition myCondition = new MyCondition();
  21. Thread thread1 = new Thread(myCondition,"线程1");
  22. thread1.start();
  23. }
  24. }
技术图片

观察运行结果可以发现,报出监视器出错的异常,解决的办法是我们必须在condition.await()方法调用前用lock.lock()代码获得同步监视器。对上述代码做出如下修改:

  1. /*
  2. * 使用Condition实现等待
  3. * */
  4. class MyCondition implements Runnable{
  5. private Lock lock = new ReentrantLock();
  6. public Condition condition = lock.newCondition();
  7. public void run() {
  8. try {
  9. //上锁
  10. lock.lock();
  11. System.out.println("当前线程名:"+Thread.currentThread().getName()+" 开始等待时间:"+System.currentTimeMillis());
  12. //线程等待
  13. condition.await();
  14. System.out.println("我陷入了等待...");
  15. } catch (InterruptedException e) {
  16. e.printStackTrace();
  17. }finally {
  18. //释放锁
  19. lock.unlock();
  20. System.out.println("锁释放了!");
  21. }
  22. }
  23. }
  24. public class MyLock{
  25. public static void main(String[] args) {
  26. MyCondition myCondition = new MyCondition();
  27. Thread thread1 = new Thread(myCondition,"线程1");
  28. thread1.start();
  29. }
  30. }

       技术图片

在控制台只打印出一句,原因是调用了Condition对象的await()方法,是的当前执行任务的线程进入等待状态。

Condition类的signal():是当前执行任务的线程处于等待状态

  1. /*
  2. * 使用Condition实现等待、通知
  3. * */
  4. class MyCondition implements Runnable{
  5. private Lock lock = new ReentrantLock();
  6. public Condition condition = lock.newCondition();
  7. public void run() {
  8. try {
  9. //上锁
  10. lock.lock();
  11. System.out.println(" 开始等待时间:"+System.currentTimeMillis());
  12. System.out.println("我陷入了等待...");
  13. //线程等待
  14. condition.await();
  15. //释放锁
  16. lock.unlock();
  17. System.out.println("锁释放了!");
  18. } catch (InterruptedException e) {
  19. e.printStackTrace();
  20. }
  21. }
  22. //通知方法
  23. public void signal(){
  24. try {
  25. lock.lock();
  26. System.out.println("结束等待时间:"+System.currentTimeMillis());
  27. //通知等待线程
  28. condition.signal();
  29. } finally {
  30. lock.unlock();
  31. }
  32. }
  33. }
  34. public class MyLock{
  35. public static void main(String[] args) throws InterruptedException {
  36. MyCondition myCondition = new MyCondition();
  37. Thread thread1 = new Thread(myCondition,"线程1");
  38. thread1.start();
  39. Thread.sleep(3000);
  40. myCondition.signal();
  41. }
  42. }

             技术图片

观察结果我们成功地实现了等待通知。

可以得知:Object类中的wait()方法等同于Condition类中的await()方法。

                Object类中的wait(long timeout)方法等同于Condition类中的await(long time,TimeUnit unit)方法。

                Object类中的notify()方法等同于Condition类中的singal()方法。

               Object类中的notifyAll()方法等同于Condition类中的singalAll()方法。

   

3、生产者消费者模式

  1. /*
  2. * 生产者、消费者模式
  3. * 一对一交替打印
  4. * */
  5. class MyServer{
  6. private ReentrantLock lock = new ReentrantLock();
  7. public Condition condition = lock.newCondition();
  8. public Boolean flag = false;
  9. public void set() {
  10. try {
  11. lock.lock();
  12. while(flag == true) {
  13. condition.await();
  14. }
  15. System.out.println("当前线程名:"+Thread.currentThread().getName()+" hello");
  16. flag = true;
  17. condition.signal();
  18. } catch (InterruptedException e) {
  19. e.printStackTrace();
  20. }finally {
  21. lock.unlock();
  22. }
  23. }
  24. public void get() {
  25. try {
  26. lock.lock();
  27. while(flag == false) {
  28. condition.await();
  29. }
  30. System.out.println("当前线程名:"+Thread.currentThread().getName()+" lemon");
  31. flag = false;
  32. condition.signal();
  33. } catch (InterruptedException e) {
  34. e.printStackTrace();
  35. }finally {
  36. lock.unlock();
  37. }
  38. }
  39. }
  40. class MyCondition1 extends Thread{
  41. private MyServer myServer;
  42. public MyCondition1(MyServer myServer) {
  43. super();
  44. this.myServer = myServer;
  45. }
  46. public void run() {
  47. for(int i = 0 ;i < Integer.MAX_VALUE;i++) {
  48. myServer.set();
  49. }
  50. }
  51. }
  52. class MyCondition2 extends Thread{
  53. private MyServer myServer;
  54. public MyCondition2(MyServer myServer) {
  55. super();
  56. this.myServer = myServer;
  57. }
  58. public void run() {
  59. for(int i = 0 ;i < Integer.MAX_VALUE;i++) {
  60. myServer.get();
  61. }
  62. }
  63. }
  64. public class MyLock{
  65. public static void main(String[] args) throws InterruptedException {
  66. MyServer myServer = new MyServer();
  67. MyCondition1 myCondition1 = new MyCondition1(myServer);
  68. MyCondition2 myCondition2 = new MyCondition2(myServer);
  69. myCondition1.start();
  70. myCondition2.start();
  71. }
  72. }

                   技术图片

  1. /*
  2. * 生产者、消费者模式
  3. * 多对多交替打印
  4. * */
  5. class MyServer{
  6. private ReentrantLock lock = new ReentrantLock();
  7. public Condition condition = lock.newCondition();
  8. public Boolean flag = false;
  9. public void set() {
  10. try {
  11. lock.lock();
  12. while(flag == true) {
  13. System.out.println("可能会有连续的hello进行打印");
  14. condition.await();
  15. }
  16. System.out.println("当前线程名:"+Thread.currentThread().getName()+" hello");
  17. flag = true;
  18. condition.signal();
  19. } catch (InterruptedException e) {
  20. e.printStackTrace();
  21. }finally {
  22. lock.unlock();
  23. }
  24. }
  25. public void get() {
  26. try {
  27. lock.lock();
  28. while(flag == false) {
  29. System.out.println("可能会有连续的lemon进行打印");
  30. condition.await();
  31. }
  32. System.out.println("当前线程名:"+Thread.currentThread().getName()+" lemon");
  33. flag = false;
  34. condition.signal();
  35. } catch (InterruptedException e) {
  36. e.printStackTrace();
  37. }finally {
  38. lock.unlock();
  39. }
  40. }
  41. }
  42. class MyCondition1 extends Thread{
  43. private MyServer myServer;
  44. public MyCondition1(MyServer myServer) {
  45. super();
  46. this.myServer = myServer;
  47. }
  48. public void run() {
  49. for(int i = 0 ;i < Integer.MAX_VALUE;i++) {
  50. myServer.set();
  51. }
  52. }
  53. }
  54. class MyCondition2 extends Thread{
  55. private MyServer myServer;
  56. public MyCondition2(MyServer myServer) {
  57. super();
  58. this.myServer = myServer;
  59. }
  60. public void run() {
  61. for(int i = 0 ;i < Integer.MAX_VALUE;i++) {
  62. myServer.get();
  63. }
  64. }
  65. }
  66. public class MyLock{
  67. public static void main(String[] args) throws InterruptedException {
  68. MyServer myServer = new MyServer();
  69. MyCondition1[] myCondition1 = new MyCondition1[10];
  70. MyCondition2[] myCondition2 = new MyCondition2[10];
  71. for(int i = 0; i < 10; i++) {
  72. myCondition1[i] = new MyCondition1(myServer);
  73. myCondition2[i] = new MyCondition2(myServer);
  74. myCondition1[i].start();
  75. myCondition2[i].start();
  76. }
  77. }
  78. }

                         技术图片

4、公平锁与非公平锁

Lock分为“公平锁”和“非公平锁”。

公平锁:表示线程获取锁的顺序是按照线程加锁的顺序来的进行分配的,即先来先得FIFO先进先出顺序。

非公平锁:一种获取锁的抢占机制,是随机拿到锁的,和公平锁不一样的是先来的不一定先拿到锁,这个方式可能造成某些线程一直拿不到锁,结果就是不公平的·。

  1. /*
  2. * 公平锁
  3. * */
  4. class MyService{
  5. private ReentrantLock lock;
  6. public MyService(boolean isFair) {
  7. super();
  8. lock = new ReentrantLock(isFair);
  9. }
  10. public void serviceMethod() {
  11. try {
  12. lock.lock();
  13. System.out.println("线程名:"+Thread.currentThread().getName()+"获得锁定");
  14. } finally {
  15. lock.unlock();
  16. }
  17. }
  18. }
  19. public class MyLock{
  20. public static void main(String[] args) {
  21. //设置当前为true公平锁
  22. final MyService myService = new MyService(true);
  23. Runnable runnable = new Runnable() {
  24. public void run() {
  25. System.out.println("线程名:"+Thread.currentThread().getName()+"运行了");
  26. myService.serviceMethod();
  27. }
  28. };
  29. Thread[] threads = new Thread[10];
  30. for(int i = 0;i < 10; i++) {
  31. threads[i] = new Thread(runnable);
  32. }
  33. for(int i = 0;i < 10; i++) {
  34. threads[i].start();
  35. }
  36. }
  37. }
            技术图片

由打印结果可以看出,基本呈现有序的状态,这就是公平锁的特点。

  1. /*
  2. * 非公平锁
  3. * */
  4. class MyService{
  5. private ReentrantLock lock;
  6. public MyService(boolean isFair) {
  7. super();
  8. lock = new ReentrantLock(isFair);
  9. }
  10. public void serviceMethod() {
  11. try {
  12. lock.lock();
  13. System.out.println("线程名:"+Thread.currentThread().getName()+"获得锁定");
  14. } finally {
  15. lock.unlock();
  16. }
  17. }
  18. }
  19. public class MyLock{
  20. public static void main(String[] args) {
  21. //设置当前为true公平锁
  22. final MyService myService = new MyService(false);
  23. Runnable runnable = new Runnable() {
  24. public void run() {
  25. System.out.println("线程名:"+Thread.currentThread().getName()+"运行了");
  26. myService.serviceMethod();
  27. }
  28. };
  29. Thread[] threads = new Thread[10];
  30. for(int i = 0;i < 10; i++) {
  31. threads[i] = new Thread(runnable);
  32. }
  33. for(int i = 0;i < 10; i++) {
  34. threads[i].start();
  35. }
  36. }
  37. }

技术图片

非公平锁的运行结果基本都是无须的,则可以表明先start()启动的线程并不一定先获得锁。

5、使用ReentrantReadWriteLock

ReentrantLock具有完全互斥排他的效果,即同一时间只有一个线程在执行ReentrantLock.lock()方法后的任务。这样虽然保证了实例变量的线程安全性,但是效率低下。所以在Java中提供有读写锁ReentrantReadWriteLock类,使其效率可以加快。在某些不需要操作实例变量的方法中,完全可以使用ReentrantReadWriteLock来提升该方法代码运行速度。

读写锁表示两个锁:

读操作相关的锁,也成为共享锁。

写操作相关的锁,也叫排他锁。

多个读锁之间不互斥,读锁与写锁互斥,多个写锁互斥。

在没有线程Thread进行写入操作时,进行读操作的多个Thread可以获取读锁,但是进行写入操作时的Thread只有获取写锁后才能进行写入操作。

1)多个读锁共享

  1. /*
  2. * 多个读锁共享
  3. * */
  4. class MyService{
  5. private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
  6. public void read() {
  7. try {
  8. //读锁
  9. lock.readLock().lock();
  10. System.out.println("线程名: "+Thread.currentThread().getName()+"获取读锁" );
  11. Thread.sleep(1000);
  12. } catch (InterruptedException e) {
  13. e.printStackTrace();
  14. }finally {
  15. //释放读锁
  16. lock.readLock().unlock();
  17. }
  18. }
  19. }
  20. //线程1
  21. class Thread1 extends Thread{
  22. private MyService myService;
  23. public Thread1(MyService myService) {
  24. super();
  25. this.myService = myService;
  26. }
  27. public void run() {
  28. myService.read();
  29. }
  30. }
  31. //线程2
  32. class Thread2 extends Thread{
  33. private MyService myService;
  34. public Thread2(MyService myService) {
  35. super();
  36. this.myService = myService;
  37. }
  38. public void run() {
  39. myService.read();
  40. }
  41. }
  42. public class MyLock{
  43. public static void main(String[] args) {
  44. MyService myService = new MyService();
  45. Thread1 thread1 = new Thread1(myService);
  46. Thread2 thread2 = new Thread2(myService);
  47. thread1.start();
  48. thread2.start();
  49. }
  50. }

                 技术图片

从打印结果可以看出,两个线程几乎同时进入lock()方法后面的代码。

说明在此时使用lock.readLock()读锁可以提高程序运行效率,允许多个线程同时执行lock()方法后的代码。

2)多个写锁互斥

  1. /*
  2. * 多个写锁互斥
  3. * */
  4. class MyService{
  5. private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
  6. public void write() {
  7. try {
  8. //写锁
  9. lock.writeLock().lock();
  10. System.out.println("线程名: "+Thread.currentThread().getName()+"获取写锁,获得时间:"+System.currentTimeMillis() );
  11. Thread.sleep(1000);
  12. } catch (InterruptedException e) {
  13. e.printStackTrace();
  14. }finally {
  15. //释放写锁
  16. lock.writeLock().unlock();
  17. }
  18. }
  19. }
  20. //线程1
  21. class Thread1 extends Thread{
  22. private MyService myService;
  23. public Thread1(MyService myService) {
  24. super();
  25. this.myService = myService;
  26. }
  27. public void run() {
  28. myService.write();
  29. }
  30. }
  31. //线程2
  32. class Thread2 extends Thread{
  33. private MyService myService;
  34. public Thread2(MyService myService) {
  35. super();
  36. this.myService = myService;
  37. }
  38. public void run() {
  39. myService.write();
  40. }
  41. }
  42. public class MyLock{
  43. public static void main(String[] args) {
  44. MyService myService = new MyService();
  45. Thread1 thread1 = new Thread1(myService);
  46. Thread2 thread2 = new Thread2(myService);
  47. thread1.start();
  48. thread2.start();
  49. }
  50. }

                    技术图片

使用写锁代码writeLock.lock()的效果就是同一时间只允许一个线程执行lock()方法后的代码。

(3)读写/写读互斥

  1. /*
  2. * 读写/写读互斥,
  3. * */
  4. class MyService{
  5. private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
  6. public void read() {
  7. try {
  8. //读锁
  9. lock.readLock().lock();
  10. System.out.println("线程名: "+Thread.currentThread().getName()+"获取读锁,获得时间:"+System.currentTimeMillis() );
  11. Thread.sleep(1000);
  12. } catch (InterruptedException e) {
  13. e.printStackTrace();
  14. }finally {
  15. //释放读锁
  16. lock.readLock().unlock();
  17. }
  18. }
  19. public void write() {
  20. try {
  21. //写锁
  22. lock.writeLock().lock();
  23. System.out.println("线程名: "+Thread.currentThread().getName()+"获取写锁,获得时间:"+System.currentTimeMillis() );
  24. Thread.sleep(1000);
  25. } catch (InterruptedException e) {
  26. e.printStackTrace();
  27. }finally {
  28. //释放写锁
  29. lock.writeLock().unlock();
  30. }
  31. }
  32. }
  33. //线程1
  34. class Thread1 extends Thread{
  35. private MyService myService;
  36. public Thread1(MyService myService) {
  37. super();
  38. this.myService = myService;
  39. }
  40. public void run() {
  41. myService.read();
  42. }
  43. }
  44. //线程2
  45. class Thread2 extends Thread{
  46. private MyService myService;
  47. public Thread2(MyService myService) {
  48. super();
  49. this.myService = myService;
  50. }
  51. public void run() {
  52. myService.write();
  53. }
  54. }
  55. public class MyLock{
  56. public static void main(String[] args) {
  57. MyService myService = new MyService();
  58. Thread1 thread1 = new Thread1(myService);
  59. Thread2 thread2 = new Thread2(myService);
  60. thread1.start();
  61. thread2.start();
  62. }
  63. }

                  技术图片

此运行结果说明“读写/写读”操作是互斥的。

由此可表明:只要出现“写”操作,就是互斥的。


 



以上是关于Lock锁的使用的主要内容,如果未能解决你的问题,请参考以下文章

Redis实现分布式锁(设计模式应用实战)

并发技术12线程锁技术的使用

java并发线程锁技术的使用

Java多线程-Lock锁的使用,以及生产者和消费者的实现

synchronized 与 lock锁的异同

synchronized与Lock比较