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

Posted yvan1115

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了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的线程访问。

以上是关于Java多线程工具包java.util.concurrent---Lock的主要内容,如果未能解决你的问题,请参考以下文章

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

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

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

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

Java多线程_同步工具CyclicBarrier

Java多线程(线程池原子性并发工具类)