Java多线程工具包java.util.concurrent---Lock

什么是lock

java.util.concurrent.locks.Lock 是一个类似于 synchronized 块的线程同步机制。但是 Lock 比 synchronized 块更加灵活、精细。
首先创建了一个 Lock 对象。之后调用了它的 lock() 方法。这时候这个 lock 实例就被锁住。任何其他再过来调用 lock() 方法的线程将会被阻塞住，直到锁定 lock 实例的线程调用了 unlock() 方法。最后 unlock() 被调用了，lock 对象解锁了，其他线程可以对它进行锁定了。
锁定和取消锁定出现在不同作用范围中时，必须谨慎地确保保持锁定时所执行的所有代码用 try-finally 或 try-catch 加以保护，以确保在必要时释放锁。

常用方法

ReentrantLock 实现了Lock接口。

• lock()

public void lock()

获取锁。
如果该锁没有被另一个线程保持，则获取该锁并立即返回，将锁的保持计数设置为 1。

如果当前线程已经保持该锁，则将保持计数加 1，并且该方法立即返回。

如果该锁被另一个线程保持，则出于线程调度的目的，禁用当前线程，并且在获得锁之前，该线程将一直处于休眠状态，此时锁保持计数被设置为 1。

• unlock()

public void unlock()

试图释放此锁。
如果当前线程是此锁所有者，则将保持计数减 1。如果保持计数现在为 0，则释放该锁。如果当前线程不是此锁的持有者，则抛出 IllegalMonitorStateException。

Lock 和 synchronized 代码块的主要不同点

• synchronized 代码块不能够保证进入访问等待的线程的先后顺序。
• 你不能够传递任何参数给一个 synchronized 代码块的入口。因此，对于 synchronized 代码块的访问等待设置超时时间是不可能的事情。

• synchronized 块必须被完整地包含在单个方法里。而一个 Lock 对象可以把它的 lock() 和 unlock() 方法的调用放在不同的方法里。

  下面三个示例分别使用 lock synchronized semaphore来实现多窗口售票（秒杀）的场景。

• Lock实现

package com.yvan.lock;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * Lock多窗口卖票
 * @author yvan
 *
 */
public class AppMain {
    public static int tickets = 100;
    public static SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
    public static void main(String[] args) {
        System.out.println(format.format(new Date()));
        Lock lock = new ReentrantLock();
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 10; i++) {
            executorService.execute(new SaleTickets(lock));
        }
        executorService.shutdown();
        while (!executorService.isTerminated()) {
        }
        System.out.println(format.format(new Date()));
    }
}

class SaleTickets implements Runnable {
    private Lock lock;

    public SaleTickets(Lock lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        while (true) {
            try {
                lock.lock();
                if (AppMain.tickets > 0) {
                    AppMain.tickets--;
                    System.out.println(Thread.currentThread().getName() + "卖出一张票，还余下" + AppMain.tickets);
                } else {
                    System.out.println("票已经卖完了");
                    break;
                }
                TimeUnit.MILLISECONDS.sleep(100);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                process(lock);
            }
        }
    }
    /**
     * 跨方法
     * @param lock
     */
    public void process(Lock lock){
        lock.unlock();
    }

}

• synchronized

package com.yvan.lock;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 * synchronized
 * @author yvan
 *
 */
public class AppMainSynch {
    public static int tickets = 100;
public static SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
    public static void main(String[] args) {
        System.out.println(format.format(new Date()));
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 10; i++) {
            executorService.execute(new SynchronizdSaleTickets());
        }
        executorService.shutdown();
        while (!executorService.isTerminated()) {
        }
        System.out.println(format.format(new Date()));
    }
}

class SynchronizdSaleTickets implements Runnable {

    @Override
    public void run() {

        while (true) {
            synchronized ("lock") {
                try {
                    if (AppMainSynch.tickets > 0) {
                        AppMainSynch.tickets--;
                        System.out.println(Thread.currentThread().getName() + "卖出一张票，还余下" + AppMainSynch.tickets);
                    } else {
                        System.out.println("票已经卖完了");
                        break;
                    }
                    TimeUnit.MILLISECONDS.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

    }

}

• Semaphore实现

package com.yvan.lock;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
/**
 * semaphore实现多窗口卖票
 * @author yvan
 *
 */
public class AppMainSemaphore {
    public static int tickets = 100;
    public static SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
    public static void main(String[] args) {
        System.out.println(format.format(new Date()));
        Semaphore semaphore = new Semaphore(1);
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        for (int i = 0; i < 10; i++) {
            executorService.execute(new SemaphoreSaleTickets(semaphore));
        }
        executorService.shutdown();
        while (!executorService.isTerminated()) {
        }
        System.out.println(format.format(new Date()));
    }
}

class SemaphoreSaleTickets implements Runnable {
    private Semaphore semaphore;

    public SemaphoreSaleTickets(Semaphore semaphore) {
        this.semaphore = semaphore;
    }

    @Override
    public void run() {
        while (true) {
            try {
                semaphore.acquire();
                if (AppMainSemaphore.tickets > 0) {
                    AppMainSemaphore.tickets--;
                    System.out.println(Thread.currentThread().getName() + "卖出一张票，还余下" + AppMainSemaphore.tickets);
                } else {
                    System.out.println("票已经卖完了");
                    break;
                }
                TimeUnit.MILLISECONDS.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                semaphore.release();
            }
        }
    }

}

总结三个例子

1. 效率：Lock > synchronized > Semaphore
2. Lock对比synchronized的主要优势在于可以跨方法跨代码块
3. Semaphore信号许可，当许可不为1的时候，代码块可以被多个线程方法，而Lock和synchronized锁住的区域只能允许当前lock的线程访问。