Lock对象在功能上比sybchronized更加丰富。
ReentrantLock类
使用ReentrantLock实现同步
调用ReentrantLock对象的lock()获取锁,调用unlock()释放锁,如下
lock的使用
public class MyService {
private Lock lock = new ReentrantLock();
public void testMethod() {
lock.lock();
for (int i = 0; i < 5; i++) {
System.out.println("ThreadName is " + Thread.currentThread().getName() + (" " + (i + 1)));
}
lock.unlock();
}
}
线程类
public class MyThread extends Thread {
private MyService myService;
public MyThread(MyService myService) {
super();
this.myService = myService;
}
@Override
public void run() {
myService.testMethod();
}
}
测试
public class Test {
public static void main(String[] args) {
MyService myService = new MyService();
MyThread a = new MyThread(myService);
MyThread b = new MyThread(myService);
MyThread c = new MyThread(myService);
a.start();
b.start();
c.start();
}
}
结果
可以看出,只有当锁释放后,其他线程才可以继续抢锁并输出(抢锁顺序与启动的顺序不一定一致)
Condition对象的使用
Condition对象具有更好的灵活性。例如,可以实现多路通知功能,也就是在一个Lock对象中可以创建多个Condition实例,线程对象注册在指定的Condition中,从而可以有选择性的进行线程的通知,在调度上更加灵活
在使用notify()/notifyAll()方法进行通知时,被通知的线程由JVM选择,而notifyAll()会通知所有waiting线程,没有选择权。
Condition对象的作用是控制并处理线程状态,它可以使线程保持wait状态,也可以让其继续运行,如下
创建Lock对象和Condition对象
public class MyService {
private ReentrantLock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
public void waitMethod() {
try {
lock.lock();
System.out.println("A");
condition.await();
System.out.println("B");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
System.out.println("锁释放了");
}
}
}
线程类
public class MyThread extends Thread {
private MyService myService;
public MyThread(MyService myService) {
super();
this.myService = myService;
}
@Override
public void run() {
myService.waitMethod();
}
}
测试
public class Test {
public static void main(String[] args) {
MyService myService = new MyService();
MyThread a = new MyThread(myService);
MyThread b = new MyThread(myService);
MyThread c = new MyThread(myService);
a.start();
b.start();
c.start();
}
}
结果
说明调用Condition对象的await()方法将当前执行任务的线程转换成wait状态,并释放锁
使用Condition对象的方法实现wait/notify机制
Condition对象拥有await()和signal(),和wait()、notify()效果类似,如下
业务代码
public class MyService {
private Lock lock = new ReentrantLock();
public Condition condition = lock.newCondition();
public void await() {
try {
lock.lock();
System.out.println("await's time is " + System.currentTimeMillis());
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void signal() {
try {
lock.lock();
System.out.println("signal's time is " + System.currentTimeMillis());
condition.signal();
} finally {
lock.unlock();
}
}
}
线程类
public class MyThread extends Thread {
private MyService myService;
public MyThread(MyService myService) {
super();
this.myService = myService;
}
@Override
public void run() {
myService.await();
}
}
测试
public class Test {
public static void main(String[] args) throws InterruptedException {
MyService myService = new MyService();
MyThread myThread = new MyThread(myService);
myThread.start();
Thread.sleep(3000);
myService.signal();
}
}
结果
await()运行原理: 并发包源代码内部执行了Unsafe类中的public native void park(boolean isAbsolute, long time)方法,让当前线程暂停。isAbsolute代表是否为绝对时间,time代表时间值
通知部分线程
可以通过Condition对象唤醒部分指定的线程(有助于提高效率),也可以对线程分组,然后唤醒指定组中的线程
业务代码
public class MyService {
private Lock lock = new ReentrantLock();
public Condition conditionA = lock.newCondition();
public Condition conditionB = lock.newCondition();
public void awaitA() {
try {
lock.lock();
System.out.println("begin await A time is" + System.currentTimeMillis() +
"ThreadName is " + Thread.currentThread().getName());
conditionA.await();
System.out.println("end await A time is" + System.currentTimeMillis() +
"ThreadName is " + Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void awaitB() {
try {
lock.lock();
System.out.println("begin await B time is" + System.currentTimeMillis() +
"ThreadName is " + Thread.currentThread().getName());
conditionB.await();
System.out.println("end await B time is" + System.currentTimeMillis() +
"ThreadName is " + Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void signalAll_A() {
try {
lock.lock();
System.out.println("signalAll_A time is" + System.currentTimeMillis() +
"ThreadName is " + Thread.currentThread().getName());
conditionA.signalAll();
} finally {
lock.unlock();
}
}
public void signalAll_B() {
try {
lock.lock();
System.out.println("signalAll_B time is" + System.currentTimeMillis() +
"ThreadName is " + Thread.currentThread().getName());
conditionB.signalAll();
} finally {
lock.unlock();
}
}
}
线程类A, B
public class ThreadA extends Thread {
private MyService myService;
public ThreadA(MyService myService) {
super();
this.myService = myService;
}
@Override
public void run() {
myService.awaitA();
}
}
public class ThreadB extends Thread {
private MyService myService;
public ThreadB(MyService myService) {
super();
this.myService = myService;
}
@Override
public void run() {
myService.awaitB();
}
}
测试
public class Test {
public static void main(String[] args) throws InterruptedException {
MyService myService = new MyService();
ThreadA a = new ThreadA(myService);
a.setName("A");
a.start();
ThreadB b = new ThreadB(myService);
b.setName("B");
b.start();
Thread.sleep(3000);
myService.signalAll_A();
}
}
结果
A被唤醒,B还继续等待
公平锁与非公平锁
公平锁:采用先到先得的策略,每次获取锁之前都会检查队列里面有没有排队等待的线程,没有才会尝试获取锁,有就追加到队列中。
非公平锁:采用“有机会插队”的策略,一个线程获取锁之前要先去尝试获取锁而非在队列等待,即后启动也可能先拿到锁。如果没有拿到,那么才将自身追加到队列中进行等待。
ReentrantReadWriteLock类
ReentrantLock类具有完全排他的效果,同一时间只有一个线程在执行lock.lock()后的任务,效率低下
ReentrantReadWriteLock进行读操作的时候不需要同步,提升运行速度。
读写有两个锁:一个读相关–共享锁,一个写相关–排它锁
读锁间不互斥,其他均互斥
以下各部分只有业务代码不同,线程类,测试类一致
先给出线程类、测试类
public class MyThread extends Thread {
private MyService myService;
public MyThread(MyService myService) {
super();
this.myService = myService;
}
@Override
public void run() {
myService.testMethod();
}
}
public class Test {
public static void main(String[] args) {
MyService myService = new MyService();
MyThread a = new MyThread(myService);
a.start();
MyThread b = new MyThread(myService);
b.start();
}
}
读读共享
public class MyService {
private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
private String username = "abc";
public void testMethod() {
try {
lock.readLock().lock();
System.out.println("begin " + Thread.currentThread().getName() + " " +
System.currentTimeMillis());
System.out.println("print service " + username);
Thread.sleep(4000);
System.out.println(" end " + Thread.currentThread().getName() + " " +
System.currentTimeMillis());
lock.readLock().unlock();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
结果
写写互斥
public class MyService {
private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
public void write() {
try {
try {
lock.writeLock().lock();
System.out.println("get writeLock " + Thread.currentThread().getName() + " " +
System.currentTimeMillis());
Thread.sleep(10000);
} finally {
lock.writeLock().unlock();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
结果
注意时间差(互斥)
读写互斥
此处各部分代码与上述均不同
业务代码
public class MyService {
private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
public void read() {
try {
try {
lock.readLock().lock();
System.out.println("get readLock " + Thread.currentThread().getName() + " " +
System.currentTimeMillis());
Thread.sleep(10000);
} finally {
lock.readLock().unlock();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void write() {
try {
try {
lock.writeLock().lock();
System.out.println("get writeLock " + Thread.currentThread().getName() + " " +
System.currentTimeMillis());
Thread.sleep(10000);
} finally {
lock.writeLock().unlock();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
线程类
public class MyThread extends Thread {
private MyService myService;
public MyThread(MyService myService) {
super();
this.myService = myService;
}
@Override
public void run() {
myService.read();
}
}
public class MyThreadB extends Thread {
private MyService myService;
public MyThreadB(MyService myService) {
super();
this.myService = myService;
}
@Override
public void run() {
myService.write();
}
}
测试方法:
public class Test2 {
public static void main(String[] args) {
MyService myService = new MyService();
MyThread a = new MyThread(myService);
a.setName("A");
a.start();
MyThreadB b = new MyThreadB(myService);
b.setName("B");
b.start();
}
}
结果
注意时间差
写读互斥与上面读写互斥类似