互斥锁synchronized
synchronized
是java语言内置功能,访问被synchronized
关键字修饰的方法或者代码块时,首先要获得当前方法或者被修饰对象的锁。
任何方法/对象的锁只有一个,所以在同一时刻不可能有两个或以上的线程同时持有,因此被称为互斥锁。直到方法或代码块执行完毕,或者线程异常被结束,锁被释放,其他线程才能获取到锁,执行该方法或代码块。
synchronized
使用方法有两种,一是同步方法:
public synchronized void method(){
//...
}
或者同步代码块:
private Object o = new Object();
public void method(){
synchronized(o){
//....
}
}
需要注意的是,同一个对象的锁只有一个,不同对象之间是不会相互影响的。如果synchronized
修饰的是static
方法,因为static是一个类共用一个方法,所以不管什么时候调用该方法都要先获取到锁,非static
方法,则只有同一个对象多次调用synchronized
方法时才需要获取锁。
Lock
Lock是java.util.concurrent.locks
包中的一个接口。与synchronized
一样,都是可重入锁:同一个线程可以多次获取同一个锁。
区别主要有以下几点:
Lock需要用户手动释放,并且释放次数需要与获取次数相同,如果释放次数小于获取次数,那么锁不会被释放掉
Lock在获取锁的过程中是可以被打断的(并非执行状态,获取到锁执行程序的过程中是不可能被打断的,只有阻塞状态才能被打断,sleep,join,还有lockInterruptibly。yield是就绪状态,持有锁但是无法被打断)
Lock可以实现公平锁和非公平锁。
Lock接口主要有以下方法:
void lock(); //获取锁,如果锁被其他线程持有,进入等待状态
void lockInterruptibly() throws InterruptedException;//获取可打断锁
boolean tryLock();//尝试获取锁,如果获取成功,则返回true,如果获取失败(即锁已被其他线程获取),则返回false,不会等待
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;//可以指定等待时间,等待时可以被打断
void unlock();//释放锁
Condition newCondition();
ReentrantLock
ReentrantLock
是实现了Lock接口的类,也是最常用的Lock。
public class Test implements Runnable{
Lock lock = new ReentrantLock();
public static void main(String[] args) {
Test test = new Test();
for(int i=0; i<5; i++) {
new Thread(test).start();
}
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "start.....");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
lock.lock();
// lock.lock();
System.out.println(Thread.currentThread().getName() + " get lock.");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally {
System.out.println(Thread.currentThread().getName() + " release lock.");
lock.unlock();
}
}
}
执行结果如下:
Thread-1start.....
Thread-0start.....
Thread-2start.....
Thread-3start.....
Thread-4start.....
Thread-2 get lock.
Thread-2 release lock.
Thread-0 get lock.
Thread-0 release lock.
Thread-4 get lock.
Thread-4 release lock.
Thread-3 get lock.
Thread-3 release lock.
Thread-1 get lock.
Thread-1 release lock.
可以看到,Lock这里起到了和synchronized
同样的效果,只是需要在finally手动释放锁。如果在lock.lock();
下边再加一行lock.lock();
,让同一个线程获取两次锁,但是在finally里只释放一次,结果就会被阻塞在第一个线程里,锁一直得不到释放,后边的线程一直处于等待状态。
公平锁和非公平锁:
公平锁是指等待时间最长的线程先获取锁,非公平锁是指所有线程同时竞争,默认实现的非公平锁,显然效率要高一些。
还是上边的代码,如果把lock改成公平锁:Lock lock = new ReentrantLock(true);
,执行的结果如下:
Thread-1start.....
Thread-2start.....
Thread-0start.....
Thread-4start.....
Thread-3start.....
Thread-1 get lock.
Thread-1 release lock.
Thread-2 get lock.
Thread-2 release lock.
Thread-0 get lock.
Thread-0 release lock.
Thread-4 get lock.
Thread-4 release lock.
Thread-3 get lock.
Thread-3 release lock.
显然是按照等待时间长短来先后获取锁的。
ReadWriteLock 读写锁
ReadWriteLock 也是一个接口,它只有两个方法:
- Lock readLock();
- Lock writeLock();
分别是获取读锁和写锁,此处把读写分开了,因为写操作是独占的,不可以多个线程同时进行,而读操作是可以的。
public class Test implements Runnable{
ReadWriteLock lock = new ReentrantReadWriteLock();
public static void main(String[] args) {
Test t = new Test();
for(int i=0; i<5; i++) {
new Thread(t).start();
}
}
@Override
public void run() {
lock.readLock().lock();
// lock.writeLock().lock();
System.out.println(Thread.currentThread().getName() + "get lock");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "release lock");
lock.readLock().unlock();
// lock.writeLock().unlock();
}
}
执行结果如下:
Thread-0get lock
Thread-1get lock
Thread-2get lock
Thread-3get lock
Thread-4get lock
Thread-1release lock
Thread-0release lock
Thread-2release lock
Thread-3release lock
Thread-4release lock
可以看到,多个线程是同时进行的,如果换成writeLock,就是一个一个线程获取锁了,执行结果如下:
Thread-0get lock
Thread-0release lock
Thread-1get lock
Thread-1release lock
Thread-2get lock
Thread-2release lock
Thread-3get lock
Thread-3release lock
Thread-4get lock
Thread-4release lock
也就是说,读锁不是互斥锁,而写锁是互斥锁,那么读写锁之间呢?可以看下边的代码:
public class ReadWLock {
ReadWriteLock lock = new ReentrantReadWriteLock();
public void read() {
lock.readLock().lock();
System.out.println(Thread.currentThread().getName() + "get read lock");
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "release read lock");
lock.readLock().unlock();
}
public void write() {
lock.writeLock().lock();
System.out.println(Thread.currentThread().getName() + "get write lock");
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "release write lock");
lock.writeLock().unlock();
}
}
public static void main(String[] args) {
ReadWLock t = new ReadWLock();
new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
t.read();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
t.write();
}
}).start();
}
执行结果如下:
Thread-0get read lock
Thread-0release read lock
Thread-1get write lock
Thread-1release write lock
也就是说,读写锁之间也是互斥关系。
注意,ReadWriteLock支持锁降级,但是不支持锁升级:
public static void main(String[] args) {
ReentrantReadWriteLock rtLock = new ReentrantReadWriteLock();
rtLock.readLock().lock();
System.out.println("get readLock.");
rtLock.writeLock().lock();
System.out.println("blocking");
}
上边的代码,先获取了读锁,然后尝试获取写锁,会导致死锁,是不可以的,但是,反过来先申请写锁再申请读锁是可行的。
ReadWriteLock同样支持公平锁。
Condition
Lock中还有一个方法:Condition newCondition()
,此方法可以返回一个Condition对象,Condition的主要方法如下:
void await() throws InterruptedException;//类似Object.wait()方法,进入等待状态,释放锁,但是可以被打断
void awaitUninterruptibly();//不能被打断
long awaitNanos(long nanosTimeout) throws InterruptedException;
boolean await(long time, TimeUnit unit) throws InterruptedException;
boolean awaitUntil(Date deadline) throws InterruptedException;
void signal();//类似于notify()
void signalAll();//类似于notifyAll()
Condition常用于线程间的协作,参考以下例子,控制多个线程的执行顺序:
public class ConditionTest {
Lock lock = new ReentrantLock();
Condition a = lock.newCondition();
Condition b = lock.newCondition();
Condition c = lock.newCondition();
private char currentChar = 'A';
public void printA() {
// 控制A->B->C的输出顺序,所以三个方法必须加锁,不能同步执行,否则顺序必定是不可控的
lock.lock();
try {
try {
if (currentChar != 'A') {
// 当前输出字符不是A的时候,让出锁,程序阻塞在这里,直到可以打印A的时候继续执行
a.await();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.print('A');
// A输出完毕,将当前输出字符赋值为B,并通知等待输出B的线程
currentChar = 'B';
b.signal();
} finally {
lock.unlock();
}
}
public void printB() {
// 控制A->B->C的输出顺序,所以三个方法必须加锁,不能同步执行,否则顺序必定是不可控的
lock.lock();
try {
try {
if (currentChar != 'B') {
// 当前输出字符不是B的时候,让出锁,程序阻塞在这里,直到可以打印C的时候继续执行
b.await();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.print('B');
// B输出完毕,将当前输出字符赋值为C,并通知等待输出C的线程
currentChar = 'C';
c.signal();
} finally {
lock.unlock();
}
}
public void printC() {
// 控制A->B->C的输出顺序,所以三个方法必须加锁,不能同步执行,否则顺序必定是不可控的
lock.lock();
try {
try {
if (currentChar != 'C') {
// 当前输出字符不是C的时候,让出锁,程序阻塞在这里,直到可以打印C的时候继续执行
c.await();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.print('C');
// B输出完毕,将当前输出字符赋值为C,并通知等待输出C的线程
currentChar = 'A';
a.signal();
} finally {
lock.unlock();
}
}
public static void main(String... args) {
ConditionTest test = new ConditionTest();
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
@Override
public void run() {
test.printA();
}
}).start();
}
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
@Override
public void run() {
test.printB();
}
}).start();
}
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
@Override
public void run() {
test.printC();
}
}).start();
}
}
}
//可以得到输出结果:ABCABCABCABCABC