java中提供了两种不同的方式加锁,synchronized和juc包下的Lock接口。
* sychronized可重入、不可中断、非公平;Lock可重入、可中断、非公平和公平;
* Lock是java 1.5中引入的线程同步工具,它主要用于多线程下共享资源的控制。
- 需要用户主动释放锁
- 可中断,设置超时中断
- 默认也是非公平锁,可以设置成公平锁
- 锁绑定多个condition用来精确唤醒
* 常见方法:
* void lock();尝试获取锁,获取成功则返回,否则阻塞当前线程。
* void lockInterruptibly() throws InterruptedException;尝试获取锁,线程在成功获取锁之前被中 断,则放弃获取锁,抛出异常。
* boolean tryLock();尝试获取锁,获取锁成功则返回true,否则返回false。
* boolean tryLock(long time, TimeUnit unit)尝试获取锁,若在规定时间内获取到锁,则返回true, 否则返回false,未获取锁之前被中断,则抛出异常。
* void unlock();释放锁,一般需要使用try/finally结构保证锁的释放。
lock的基本使用
//Lock的基本使用
public class Test1 {
public static void main(String[] args) {
NumOperation no = new NumOperation();
// 启动8个线程,一个线程执行50次加,一个线程执行50次减操作
Thread[] ts = new Thread[8];
for (int k = 0; k < 4; k++) {
ts[k * 2] = new Thread(() -> {
for (int i = 0; i < 50; i++)
no.add();
});
ts[k * 2].start();
ts[k * 2 + 1] = new Thread(() -> {
for (int i = 0; i < 50; i++)
no.sub();
});
ts[k * 2 + 1].start();
}
for (Thread tmp : ts)
if (tmp != null)
try {
tmp.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Main:" + no.getNum());
}
}
class NumOperation {
private Long num = 0L;// 共享数据
//这里的静态特性用于保证锁只有一个
private static final Lock lock = new ReentrantLock();// 重入锁,是Lock接口的一个实现
public void add() {
lock.lock(); // 申请锁,获取不到锁则会阻塞
try {
System.out.println(Thread.currentThread() + "开始加操作..." + num);
num++;
System.out.println(Thread.currentThread() + "结束加操作..." + num);
} finally {
lock.unlock();// 释放锁,lock允许重入,但是必须保证申请和释放次数相等
}
}
public void sub() {
lock.lock();
try {
System.out.println(Thread.currentThread() + "开始减操作..." + num);
num--;
System.out.println(Thread.currentThread() + "结束减操作..." + num);
} finally {
lock.unlock();
}
}
public Long getNum() {
return num;
}
}
Lock有三个实现类,一个是ReentrantLock,另两个是ReentrantReadWriteLock
* 类中的两个静态内部类ReadLock和WriteLock。这些类的底层使用都依赖于juc包
* 抽象队列同步器AbstractQueuedSynchronizer
* 使用方法:多线程下访问(互斥)共享资源时, 访问前加锁,访问结束以后解锁,
* 解锁的操作推荐放入finally块中。
* private static final ReentrantLock lock=new ReentrantLock(); 定义锁对象
* 在具体方法中
lock.lock();
try{
代码块;
}finally{
lock.unlock();
}
Condition接口是一个可以带条件的线程通知接口,需要和Lock锁一起使用,
* 用于实现比Object类种线程通知方法更精细的控制 wait/notify/notifyAll
* 方法:
* await()类似于Object种的wait方法
* signal()类似于Object中的notify方法
* 应用场景:线程如果不满足某个Condition将被暂停挂起,而等到线程满足条件时被唤醒
synchronized的缺陷
* sychronized是java的一个关键字,是java内置的特性,没有区分读写锁
* Lock接口
* 实现类ReentrantLock,区分读写ReadWriteLock接口
- tryLock
- lock
* 具体实现类ReentrantLock
* 实现了Lock接口
- newCondition创建一个条件对象,用来管理得到锁但是不能执行工作的线程
* 如果一个线程lock.lock()已经获取了锁,也可以多次调用这个方法(重入锁名称的来源),都可以获取到锁,但是获取多少次锁必须通过lock.unlock释放多少次,否则其它线程会阻塞在lock.lock()方法上,注意lock()方法和unlock()方法的执行次数必须匹配,所以一般建议使用lock.lock();try{}finally{lock.unlock();}
当调用condition.await()阻塞线程时会自动释放锁,不管调用了多少次lock.lock(),这时阻塞在lock.lock()方法上线程则可以获取锁
当调用condition.signal()唤醒线程时会继续上次阻塞的位置继续执行,默认会自动重新获取锁(注意和阻塞时获取锁的次数一致)
ReentrantReadWriteLock是Lock的另一种实现方式,ReentrantLock是一个排他锁,同一时间只允许一个线程访问,而ReentrantReadWriteLock允许多个读线程同时访问,但不允许写线程和读线程、写线程和写线程同时访问。相对于排他锁,提高了并发性。在实际应用中,大部分情况下对共享数据(如缓存)的访问都是读操作远多于写操作,这时ReentrantReadWriteLock能够提供比排他锁更好的并发性和吞吐量。
ReentrantLock底层实现
*
* 底层实现依赖于Sync实现的,Sync是AbstractQueuedSynchronizer的抽象子类。
* 在ReentrantLock中有2个静态内部类NonfairSync和FairSync分别代表非公平锁
* 和公平锁,可以在创建ReentrantLock对象时使用参数进行指定。
* public ReentrantLock() {
sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
ReentrantLock提供了很多的额外方法,例如isFair()可以判断锁是否为公平锁
isLocked判断锁是否被任何线程获取了,isHeldByCurrentThread判断锁是否被
当前线程获取,hasQueuedThreads()判断是否有线程在等待该锁
* ReadWriteLock接口
* 实例上和Lock接口无关,提供了通过分开读锁和写锁,控制锁阻塞的方法,提高程序
* 的执行效率
*
* public interface ReadWriteLock {
Lock readLock(); 用于获取读锁,读锁之间不相互阻塞
Lock writeLock(); 用于获取写锁,写锁和其它锁互斥
}
功能在于将文件的读写操作分开,分成2个锁分配给线程,从而实现多个线程可以同时
执行读操作
实现类ReentrantReadWriteLock
提供了写锁和读锁的实现
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class Test1 {
private static final ReadWriteLock lock = new ReentrantReadWriteLock();
public void get() {
lock.readLock().lock();// 获取读锁
try {
long start = System.currentTimeMillis();
while (System.currentTimeMillis() - start <= 1) {
System.out.println(Thread.currentThread() + "正在进行读操作...");
}
System.out.println(Thread.currentThread() + "读取操作完毕");
} finally {
lock.readLock().unlock();
}
}
public void put() {
lock.writeLock().lock();// 获取写锁
try {
long start = System.currentTimeMillis();
while (System.currentTimeMillis() - start <= 1) {
System.out.println(Thread.currentThread() + "正在进行写操作...");
}
System.out.println(Thread.currentThread() + "写出操作完毕");
} finally {
lock.writeLock().unlock();
}
}
public static void main(String[] args) {
Test1 test1 = new Test1();
for (int i = 0; i < 5; i++) {
int k=i;
new Thread(() -> {
if (k % 2 == 0)
test1.get();
else
test1.put();
}).start();
}
}
}
Lock和synchronized的区别:
- Lock是一个接口,而synchronized是Java中的关键字,synchronized是内置的
语言实现
- synchronized在发生异常时,会自动释放线程占有的锁,因此不会导致死锁现象
发生;而Lock在发生异常时,如果没有主动通过unLock()去释放锁(所以建议使用的
try/finally结构),则很可能造成死锁现象,因此使用Lock时需要在finally块中
释放锁
- Lock可以让等待锁的线程响应中断,而synchronized却不行,使用synchronized
时,等待的线程会一直等待下去,不能够响应中断
- 通过Lock可以知道有没有成功获取锁,而synchronized却无法办到
Thread类中提供了一个静态方法,可以判断boolean holdsLock(Object obj)
- Lock可以提高多个线程进行读操作的效率。
在性能上来说,如果竞争资源不激烈,两者的性能是差不多的,而当竞争资源非常激烈
时(即有大量线程同时竞争),此时Lock的性能要远远优于synchronized。所以说,在
具体使用时要根据适当情况选择。
条件变量就是表示条件的一种变量。但是必须说明,这里的条件是没有实际含义的,仅仅
是个标记而已,并且条件的含义往往通过代码来赋予其含义。条件变量都实现了java.
util.concurrent.locks.Condition接口,条件变量的实例化是通过一个Lock对象上调用 newCondition()方法来获取的,这样,条件就和一个锁对象绑定起来了。因此,Java
中的条件变量只能和锁配合使用,来控制并发程序访问竞争资源的安全。
条件变量Condition接口定义了等待/通知两种类型的方法,在线程调用这些方法时,需要
提前获取Condition对象关联的锁(在基于wait/notify方法实现的方案中需要获取的是对
象锁)。
Condition对象是需要关联Lock对象的,经调用Lock对象的newCondition()对象创建而来
,也就是说Condition的使用是需要依赖Lock对象的。
- await()导致当前线程等待,直到其它线程调用该Condition的signal()方法或者
signalAll()方法来唤醒该线程
- signal()唤醒在Lock对象上等待的单个线程。如果所有线程都在该Lock对象上等待,
则会选择唤醒其中一个线程。选择是任意的
- signalAll()唤醒在此Lock对象上等待的所有线程。只有当前线程放弃对该Lock对象
的锁定后,才可以执行被唤醒的线程