java多线程之同步锁（Lock）

Bertha 。 2022-05-17 13:19 489阅读 0赞 
  1.   从Java5开始，提供了Lock， Lock提供了比synchronized方法和synchronized代码块更广泛的锁定操作，Lock可以实现更灵活的结构，并且支持多个相关的Condition对象(对象监视器)。
  3.   Lock是控制多个线程对共享资源进行访问的工具。通常，锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象。

示例代码：

ReentrantLockTest类：

  1. public class ReentrantLockTest {
  3.     private final ReentrantLock lock = new ReentrantLock();
  4.         //创建10个线程
  5.     public void userPrint() {
  6.         for (int i = 0; i < 10; i++) {
  7.             new Thread(new Runnable() {
  9.                 public void run() {
  10.                     print();
  11.                 }
  12.             }).start();
  13.         }
  14.     }
  16.     public void print() {
  17.         lock.lock();
  18.         System.out.println("线程" + Thread.currentThread().getName() + "正在使用打印机");
  19.         try {
  20.             Thread.sleep(new Random().nextInt(1000));
  21.             System.out.println("线程" + Thread.currentThread().getName() + "资源使用打印机");
  22.         } catch (InterruptedException e) {
  23.             // TODO Auto-generated catch block
  24.             e.printStackTrace();
  25.         }
  26.                 //获取等待得到同步锁的线程个数
  27.         System.out.println("还剩 " + lock.getQueueLength() + "人要使用打印机");
  28.         lock.unlock();
  29.     }
  30. }

Main类：

  1. public class Main {
  3.     public static void main(String[] args) throws Exception {
  4.         new ReentrantLockTest().userPrint();
  5. }

测试结果：

70

可以看到我们创建的10个线程并没有同时进来使用打印机方法，而是每次至进入一个线程使用打印机。

Lock操作多个Condition对象：

实例代码：

ReentrantLockTest类：

  1. public class ReentrantLockTest {
  3.     private final ReentrantLock lock = new ReentrantLock();
  4.     private Condition conditionA = lock.newCondition();
  5.     private Condition conditionB = lock.newCondition();
  7.     public void waitA() {
  8.         lock.lock();
  9.         try {
  10.             System.out.println(Thread.currentThread().getName() + "等待条件");
  11.             conditionA.await();
  12.         } catch (InterruptedException e) {
  13.             // TODO Auto-generated catch block
  14.             e.printStackTrace();
  15.         }
  16.         lock.unlock();
  17.     }
  19.     public void waitB() {
  20.         lock.lock();
  21.         try {
  22.             System.out.println(Thread.currentThread().getName() + "等待条件(没有人唤醒我，我将一直等待..)");
  23.             conditionB.await();
  24.         } catch (InterruptedException e) {
  25.             // TODO Auto-generated catch block
  26.             e.printStackTrace();
  27.         }
  28.         lock.unlock();
  29.     }
  31.     public void signal() throws InterruptedException {
  32.         lock.lock();
  33.         Thread.sleep(1000);
  34.         System.out.println(Thread.currentThread().getName() + "执行完毕，唤醒A");
  35.         conditionA.signal();
  36.         lock.unlock();
  37.     }
  39.     public void condition() throws InterruptedException {
  40.         new Thread(new Runnable() {
  42.             public void run() {
  43.                 waitA();
  44.             }
  45.         }).start();
  46.         new Thread(new Runnable() {
  48.             public void run() {
  49.                 waitB();
  50.             }
  51.         }).start();
  52.         new Thread(new Runnable() {
  54.             public void run() {
  55.                 try {
  56.                     signal();
  57.                 } catch (InterruptedException e) {
  58.                     // TODO Auto-generated catch block
  59.                     e.printStackTrace();
  60.                 }
  61.             }
  62.         }).start();
  63.     }
  64. }

Mian类：

  1. public class Main {
  3.     public static void main(String[] args) throws Exception {
  4.         new ReentrantLockTest().condition();
  5. }

测试结果：

70 1

上例中，我们可以看到我们创建了两个Condition对象，并且启动了三个线程，waitA和waitB方法都在其中一个线程执行，但是signal方法只唤醒了持有ConditionA的方法，而另一个waitB方法将一直等待被唤醒。使用Condition可以进行线程间的通信。

发表评论

表情：
评论列表 （有 0 条评论，489人围观）

还没有评论，来说两句吧...

相关阅读

    相关 线程同步之 lock

    ock是一个接口，是通过代码来实现的，他的底层也是基于CAS原理，属于一种乐观锁，他与synchronized也有一定的区别： 1.用法不一样。synchronized...

    末蓝、末蓝、/ 0 赞/ 191 阅读