alexpdh's blog

理解 JVM:Java 内存模型(三)—— 锁

什么是线程安全?

线程安全是指当一个对象被多个线程访问操作时,最终都能得到正确的结果,那这个对象是线程安全的。Java 中可以通过同步块和加锁保障线程安全。


锁是 Java 并发编程中最重要的同步机制,它可以让等待在临界区的线程互斥执行。

关键字 synchronized

synchronized 也是一种锁,它通过字节码指令 monitorenter 和 monitorexist 隐式的来使用 lock 和 unlock 操作。synchronized 具有原子性和可见性。

synchronized 示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
/**
* @Project Name:test
* @File Name:SynchronizedTest.java
* @Package Name:com.pdh
* @Date:2017年2月12日下午5:36:46
*/
package com.pdh.test.thread;
/**
* synchronized 具有原子性和可见性
*
* @author pengdh
* @date 2017/11/12
*/
public class SynchronizedDemo {
private int safeNum = 0;
private int unsafeNum = 0;
/**
* 使用 synchronized 同步实现复合运算,线程安全的
*/
private synchronized void safeIncrease() {
safeNum++;
}
/**
* 普通复合运算,线程不安全的
*/
private void unsafeIncrease() {
unsafeNum++;
}
public static void main(String[] args) {
SynchronizedDemo demo = new SynchronizedDemo();
for (int i = 0; i < 20000; i++) {
new Thread(() -> {
demo.unsafeIncrease();
demo.safeIncrease();
}).start();
}
while (Thread.activeCount() > 2) {
Thread.yield();
}
System.out.println("unsafeNum: " + demo.unsafeNum);
System.out.println("safeNum: " + demo.safeNum);
}
}

在示例中,申明了两个方法,一个是使用了 synchronized 修饰的同步块方法 safeIncrease() 对共享变量 safeNum 的自增操作,由于该方法使用了 synchronized 同步块实现了线程对变量 safeNum 的互斥操作,是线程安全的,所以最终获取到了正确的结果 20000;而另一个方法 unsafeIncrease() 为使用任何手段保护 全局变量 unsafeNum,是线程不安全的,所以最终获取到的结果大多数情况下是小于 20000 的。

重入锁(ReentrantLock)

从 JDK 5.0 开始,Java 并发包实现了高性能的支持重入的锁 ReentrantLock,属于一种排它锁。重入锁通过显示的请求获取和释放锁,为了避免获得锁后,没有释放锁,而造成其它线程无法获得锁而造成死锁,一般建议将释放锁操作放在finally块里。

重入锁示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
package com.pdh.test.thread.lock;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* ReentrantLock 实现线程同步
*
* @author pengdh
* @date 2017/11/12
*/
public class ReentrantLockDemo implements Runnable {
private int num = 0;
private Lock lock = new ReentrantLock();
/**
* 利用重入锁实现变量累加操作
*/
private void increase() {
lock.lock();
try {
num++;
} catch (Exception e) {
e.printStackTrace();
}finally {
lock.unlock();
}
}
public static void main(String[] args) {
ReentrantLockDemo demo = new ReentrantLockDemo();
for (int i = 0; i < 2000; i++) {
new Thread(() -> {
demo.increase();
}).start();
}
// 等待所有线程全部执行完
while (Thread.activeCount() > 2) {
Thread.yield();
}
System.out.println(demo.num);
}
}

重入锁提供以下几个主要方法

  • lock():获得锁,如果锁已经被占用,则等待;
  • lockInterruptibly():获取锁,若获取成功立即返回;若获取不成功则阻塞等待。与lock方法不同的是,在阻塞期间,如果当前线程被打断(interrupt)则该方法抛出InterruptedException。该方法可以有效避免死锁题。
  • tryLock():该方法尝试获取锁,如果成功,返回 true ,若失败返回 false。该方法不等待,立即返回。
  • tryLock(long time, TimeUnit unit):该方法尝试获取锁,若成功,则返回 true,若失败,则等待相应的时间,如果该时间内能获得锁,则返回 true,如果相应的时间内仍未获取到锁则返回 false,如果在等待期间当前线程被中断则抛出 InterruptedException;
  • unlock():释放锁;

synchronized 与 ReentrantLock 的区别

  1. 所有使用 synchronized 的地方都可以使用 ReentrantLock ;
  2. synchronized 是通过字节码指令 monitorenter 和 monitorexist 实现隐式加锁和解锁,而 ReentrantLock 是通过 lock 和 unlock 操作实现显示加锁和解锁;
  3. ReentrantLock 可以实现公平和非公平两种锁,而 synchronized 只能实现非公平锁;
  4. ReentrantLock 可以中断对锁的等待来避免 synchronized 可能带来的死锁问题;

Condition 条件锁

Condition 的用法与 wait() 和 notify() 作用类似,wait() 和 notify() 是和 synchronized 关键字搭配使用,而 Condition 是与重入锁搭配使用。利用 Condition 对象,就可以让线程在合适的时间等待,或者在某个特定的时刻得到通知,继续执行。

Condition 提供以下几个方法

  • await():该方法会使当前线程等待,同时释放当前锁,当其它线程中使用 signal() 或者 singnalAll() 方法时,线程会重新获得锁并继续执行。或者当前线程被中断时,也能跳出等待。
  • awaitUninterruotibly():该方法使用和 await() 基本相同,但是它不会再等待的过程中响应中断。
  • singal():该方法用于唤醒一个在等待中的线程,而 singalAll() 方法会唤醒所有在等待的方法。

Condition 示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
package com.pdh.test.thread;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
* Condition 示例
*
* @author pengdh
* @date 2017/11/12
*/
public class ConditionDemo {
public static void main(String[] args) {
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
new Thread(() -> {
lock.lock();
System.out.println("thread 1 is waiting");
try {
condition.await();
System.out.println("thread 1 is wake up");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}).start();
new Thread(() -> {
lock.lock();
try {
System.out.println("thread 2 is running");
Thread.sleep(3000);
condition.signal();
} catch (Exception e) {
e.printStackTrace();
}finally {
lock.unlock();
}
}).start();
}
}

信号量(Semaphore)

信号量为多线程协作提供了更为强大的控制方法,广义上说,信号量是对锁的扩展。无论是内部锁 synchronized 还是重入锁 ReentrantLock,一次都只允许一个线程访问一个资源,而信号量却可以指定多个线程,同时访问某一个资源。

信号量提供了以下方法

  • acquire():该方法尝试获得一个许可。若无法获得,则线程会等待,直到有线程释放一个许可或者当前线程被中断。
  • acquire(int permits): 申请 permits(必须为非负数)个许可,若获取成功,则该方法返回并且当前可用许可数减permits;若当前可用许可数少于 permits 指定的个数,则继续等待可用许可数大于等于 permits;若等待过程中当前线程被中断,则抛出 InterruptedException。
  • acquireUninterruptibly() :该方法和 acquire() 类似,但不响应中断。
  • tryAcquire():尝试获得一个许可 ,如果成功则返回 true,如果失败则返回 false,它不会进行等待,立即返回。
  • release():用于在线程访问资源结束后,释放一个许可,以使其它等待许可的线程可以进行资源访问。

Semaphore 示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package com.pdh.test.thread;
import java.util.concurrent.Semaphore;
/**
* 信号量示例
*
* @author pengdh
* @date 2017/11/12
*/
public class SemaphoreDemo {
private static final Semaphore semaphoreToken = new Semaphore(5);
public static void main(String[] args) {
for (int i = 0; i < 100; i++) {
new Thread(() -> {
// 获取令牌
try {
semaphoreToken.acquire();
Thread.sleep(2000);
System.out.println(Thread.currentThread().getId() + " finished");
// 归还令牌
semaphoreToken.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
}
}

读写锁(ReadWriteLock)

读写锁适用于多线程编程中读多写少的场景中,对于原子性而言,更多是关注写操作,读和读操作之间并不需要互斥操作,只需要保证读和写或者写和写之间是互斥操作即可。所以如果在某个场景下读操作次数远远大于写操作次数,则可以使用读写锁来提高效率。

读写锁示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
package com.pdh.test.thread;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* 读写锁示例
*
* @author pengdh
* @date 2017/11/13
*/
public class ReadWriteLockDemo {
public static void main(String[] args) {
ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
new Thread(() -> {
readWriteLock.readLock().lock();
try {
System.out.println("the first read lock begin");
Thread.sleep(1000);
System.out.println("the first read lock end");
} catch (Exception e) {
e.printStackTrace();
}finally {
readWriteLock.readLock().unlock();
}
}).start();
new Thread(() -> {
readWriteLock.readLock().lock();
try {
System.out.println("the second read lock begin");
Thread.sleep(1000);
System.out.println("the second read lock end");
} catch (Exception e) {
e.printStackTrace();
}finally {
readWriteLock.readLock().unlock();
}
}).start();
new Thread(() -> {
readWriteLock.writeLock().lock();
try {
System.out.println("the write lock begin");
Thread.sleep(1000);
System.out.println("the write read lock end");
} catch (Exception e) {
e.printStackTrace();
}finally {
readWriteLock.writeLock().unlock();
}
}).start();
}
}

参考文献

  • Java 高并发程序设计
alexpdh wechat
欢迎扫一扫关注 程序猿pdh 公众号!