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();
总结三个例子
- 效率:Lock > synchronized > Semaphore
- Lock对比synchronized的主要优势在于可以跨方法跨代码块
- 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