1. WIKI教程
2. 学习Java并发
3. Concurrency - Lock

Concurrency - Lock

java.util.concurrent.locks.Lock接口用作类似于synchronized块的线程同步机制。 新的锁定机制比同步块更灵活，提供更多选项。 Lock和synchronized块之间的主要区别如下 -

• Guarantee of sequence - 同步块不提供任何顺序保证，等待线程将被授予访问权限。 锁接口处理它。

• No timeout - 如果未授予锁定，则同步块No timeout选项。 Lock接口提供了这样的选项。

• Single method - 同步块必须完全包含在单个方法中，而锁定接口的方法lock（）和unlock（）可以在不同的方法中调用。

锁定方法

以下是Lock类中可用的重要方法列表。

Sr.No.	方法和描述
1	public void lock() 获得锁。
2	public void lockInterruptibly() 除非当前线程被中断，否则获取锁定。
3	public Condition newCondition() 返回绑定到此Lock实例的新Condition实例。
4	public boolean tryLock() 只有在调用时它是空闲的才能获取锁。
5	public boolean tryLock() 只有在调用时它是空闲的才能获取锁。
6	public boolean tryLock(long time, TimeUnit unit) 如果在给定的等待时间内空闲并且当前线程未被中断，则获取锁。
7	public void unlock() 释放锁定。

例子 (Example)

以下TestThread程序演示了Lock接口的一些这些方法。 在这里，我们使用lock（）来获取锁定，并使用unlock（）来释放锁定。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
class PrintDemo {
   private final Lock queueLock = new ReentrantLock();
   public void print() {
      queueLock.lock();
      try {
         Long duration = (long) (Math.random() * 10000);
         System.out.println(Thread.currentThread().getName() 
            + "  Time Taken " + (duration/1000) + " seconds.");
         Thread.sleep(duration);
      } catch (InterruptedException e) {
         e.printStackTrace();
      } finally {
         System.out.printf(
            "%s printed the document successfully.\n", Thread.currentThread().getName());
         queueLock.unlock();
      }
   }
}
class ThreadDemo extends Thread {
   PrintDemo  printDemo;
   ThreadDemo(String name,  PrintDemo printDemo) {
      super(name);
      this.printDemo = printDemo;
   }   
   @Override
   public void run() {
      System.out.printf(
         "%s starts printing a document\n", Thread.currentThread().getName());
      printDemo.print();
   }
}
public class TestThread {
   public static void main(String args[]) {
      PrintDemo PD = new PrintDemo();
      ThreadDemo t1 = new ThreadDemo("Thread - 1 ", PD);
      ThreadDemo t2 = new ThreadDemo("Thread - 2 ", PD);
      ThreadDemo t3 = new ThreadDemo("Thread - 3 ", PD);
      ThreadDemo t4 = new ThreadDemo("Thread - 4 ", PD);
      t1.start();
      t2.start();
      t3.start();
      t4.start();
   }
}

这将产生以下结果。

输出 (Output)

Thread - 1  starts printing a document
Thread - 4  starts printing a document
Thread - 3  starts printing a document
Thread - 2  starts printing a document
Thread - 1   Time Taken 4 seconds.
Thread - 1  printed the document successfully.
Thread - 4   Time Taken 3 seconds.
Thread - 4  printed the document successfully.
Thread - 3   Time Taken 5 seconds.
Thread - 3  printed the document successfully.
Thread - 2   Time Taken 4 seconds.
Thread - 2  printed the document successfully.

我们在这里使用ReentrantLock类作为Lock接口的实现。 ReentrantLock类允许线程锁定方法，即使它已经锁定了其他方法。