多线程——Lock的使用

Lock介绍：

lock关键字可确保当一个线程位于代码的临界区时，另一个线程不会进入该临界区。如果其他线程尝试进入锁定的代码，则它将一直等待（即被阻止），直到该对象被释放。

Lock是一个接口，其中常用的方法有：

• 尝试获取锁，获取成功则返回，否则阻塞当前线程
  void lock();

• 尝试获取锁，线程在成功获取锁之前被中断，则放弃获取锁，抛出异常
  void lockInterruptibly() throws InterruptedException;

• 尝试获取锁，获取锁成功则返回true，否则返回false
  boolean tryLock();

• 尝试获取锁，若在规定时间内获取到锁，则返回true，否则返回false，未获取锁之前被中断，则抛出异常
  boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

• 释放锁
  void unlock();

• 返回当前锁的条件变量，通过条件变量可以实现类似notify和wait的功能，一个锁可以有多个条件变量
  Condition newCondition();

ReentrantLock类：

ReentrantLock重入锁，是实现Lock接口的一个类，也是在实际编程中使用频率很高的一个锁，支持重入性，表示能够对共享资源能够重复加锁，即当前线程获取该锁再次获取不会被阻塞。在java关键字synchronized隐式支持重入性，synchronized通过获取自增，释放自减的方式实现重入。与此同时，ReentrantLock还支持公平锁和非公平锁两种方式。那么，要想完完全全的弄懂ReentrantLock的话，主要也就是ReentrantLock同步语义的学习：1. 重入性的实现原理；2. 公平锁和非公平锁

一个简单的示例：

main函数：

package ReentranLock;
public class Run {
   
    public static void main(String[] args) {
   
        MyService service = new MyService();
        MyThread a1 = new MyThread(service);
        MyThread a2 = new MyThread(service);
        MyThread a3 = new MyThread(service);
        a1.start();
        a2.start();
        a3.start();
    }
}

Service类：

package ReentranLock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MyService {
   
    private Lock lock = new ReentrantLock();

    public void testMethod() {
   
        lock.lock();
        for (int i = 0; i < 5; i++) {
   
            System.out.println("ThreadName=" + Thread.currentThread().getName() + (" " + (i + 1)));
        }
        lock.unlock();
    }
}

线程类：

package ReentranLock;

public class MyThread extends Thread {
   
    private MyService service;

    public MyThread(MyService service) {
   
        super();
        this.service = service;
    }

    @Override
    public void run() {
   
        service.testMethod();
    }
}

运行结果如下：

ThreadName=Thread-0 1
ThreadName=Thread-0