JUC并发常用工具学习
今天主要来和大家分享一下JUC相关的一些简单知识，线程池文章就不介绍了，前面的文章有介绍，本文主要介绍Lock和认识synchronized和并发的一些工具类的使用。
Lock
传统的锁有synchronized关键字，我们可以直接在方法和代码块中使用它。
在Java中有ReentrantLock、ReentrantReadWriteLock
常用的ReentrantLock，默认采用的是非公平锁，也有公平锁的实现方式，简单点说，
-
公平锁需要根据申请锁的顺序来获取锁，按照先来先服务的原则。
-
非公平锁可以不按照申请锁的顺序，后申请的线程也可以按先申请锁的线程先获取锁。
public ReentrantLock() {
sync = new NonfairSync();
}
/**
* Creates an instance of {@code ReentrantLock} with the
* given fairness policy.
*
* @param fair {@code true} if this lock should use a fair ordering policy
*/
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
下面我们也可以通过一个卖票的小例子来看ReentrantLock的使用，其中最主要的是lock和unlock方法，这方法需要成对出现，否则可能会出现锁未释放的情况。
class Ticket1 {
private int number = 50;
Lock lock = new ReentrantLock();
/**
* 卖票的方式
*/
public synchronized void sale() {
// 加锁
lock.lock();
try {
if (number > 0) {
System.out.println(Thread.currentThread().getName() + "卖出了" + (number--) + "票，剩余" + number);
}
} catch (Exception ex) {
ex.printStackTrace();
} finally {
lock.unlock();
}
}
}
简单对比Lock和synchronized：
-
synchronized和Lock的类型不同，一个是关键字，一个是类。
-
Lock可以判断锁的状态，而synchronized是不可以的。
-
synchronized的锁释放是自动释放的，而Lock是需要手动释放锁。
-
synchronized线程会一直等待，而Lock是不一定等待下去。
-
synchronized是可重入锁，是非公平锁，Lock可以重入锁，可以设置是否公平。
-
Lock适合锁大量代码，synchronized适合锁少量的代码。
生产者的消费者问题
synchronized版
这个问题一直都是比较经典的问题，我们可以使用synchronized关键字实现配置wait方法，notifyAll方法和notify方法实现。
注意wait方法只能出现在同步方法中。
下面的例子需要防止虚假唤醒的问题，即需要采用循环的方式而不能采用if的方式，在JDK1.8文章的也有说明
class Data {
private int number = 0;
/**
* 资源类
*/
public synchronized void increment() {
// if (number != 0) {
while (number != 0) {
// 等待
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
number++;
System.out.println(Thread.currentThread().getName() + "=>" + number);
// 通知其他线程
this.notifyAll();
}
public synchronized void decrement() {
// if (number == 0) {
while (number == 0) {
// 等待
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
number--;
System.out.println(Thread.currentThread().getName() + "=>" + number);
// 通知
this.notifyAll();
}
}
Lock版
可能有人也会说，有synchronize不九可以处理了么，在Java中还有一个配合也是可以实现这个功能的，也就是Lock配置Condition的await方法和signal方法，这个比synchronizd强在哪里呢？这个可以实现精准唤醒，而通过synchronized方法里面的notify不能实现精准唤醒。
下面这个例子就可以实现按顺序实现唤醒。
class Data2 {
private Lock lock = new ReentrantLock();
Condition condition1 = lock.newCondition();
Condition condition2 = lock.newCondition();
Condition condition3 = lock.newCondition();
private int number = 1;
public void printA() {
lock.lock();
try {
while (number != 1) {
// 等待
condition1.await();
}
System.out.println(Thread.currentThread().getName() + "=>" + number);
// 唤醒指定的人
number = 2;
condition2.signal();
} catch (Exception ex) {
ex.printStackTrace();
} finally {
lock.unlock();
}
}
public void printB() {
lock.lock();
try {
while (number != 2) {
// 等待
condition2.await();
}
System.out.println(Thread.currentThread().getName() + "=>" + number);
// 唤醒指定的人
number = 3;
condition3.signal();
} catch (Exception ex) {
ex.printStackTrace();
} finally {
lock.unlock();
}
}
public void printC() {
lock.lock();
try {
while (number != 3) {
// 等待
condition3.await();
}
System.out.println(Thread.currentThread().getName() + "=>" + number);
// 唤醒指定的人
number = 1;
condition1.signal();
} catch (Exception ex) {
ex.printStackTrace();
} finally {
lock.unlock();
}
}
}
理解锁
我们如何判断锁的是谁？锁的是调用该方法的对象还是Class模板呢？这样可以帮助我们深入理解锁。
这里还是采用狂神视频的提到的8锁问题，应该看完就可以理解synchronized锁的判断。
场景一
-
是输出发短信还是打电话？发短信
-
发短信延迟4秒，是发短信还是打电话？发短信
synchronized锁的是方法的调用者，两个方法用的是同一把锁，谁先拿到先执行。
public class Test1 {
@SneakyThrows
public static void main(String[] args){
Phone phone = new Phone();
new Thread(() -> {
phone.sendMsg();
}, "A").start();
TimeUnit.SECONDS.sleep(1);
new Thread(() -> {
phone.call();
}, "B").start();
}
}
class Phone {
public synchronized void sendMsg() {
System.out.println("sendMsg");
}
public synchronized void call() {
System.out.println("call");
}
}
场景二
-
下面先输出哪个结果？发短信还是hello? hello
hello方法是没有锁的，不是同步方法，不受锁影响
public class Test2 {
public static void main(String[] args){
Phone1 phone = new Phone1();
new Thread(() -> {
phone.sendMsg();
}, "A").start();
new Thread(() -> {
phone.call();
}, "B").start();
new Thread(() -> {
phone.hello();
}, "C").start();
}
}
class Phone1 {
public synchronized void sendMsg() {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("sendMsg");
}
public synchronized void call() {
System.out.println("call");
}
public void hello() {
System.out.println("hello");
}
}
场景三
- 下面重新声明两个对象，一个调用同步发短信方法，一个调用call方法，先执行哪个方法？ call
因为两个同步方法，锁的是方法调用者的对象，这里有两把锁
public class Test2 {
public static void main(String[] args){
Phone1 phone1 = new Phone1();
Phone1 phone2 = new Phone1();
new Thread(() -> {
phone1.sendMsg();
}, "A").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(() -> {
phone2.call();
}, "B").start();
}
}
class Phone1 {
public synchronized void sendMsg() {
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("sendMsg");
}
public synchronized void call() {
System.out.println("call");
}
public void hello() {
System.out.println("hello");
}
}
场景四
- 增加两个静态同步方法，只有一个对象，先打印，发短信？打电话？发短信
类一加载就有了，这里锁的Class对象，Class是唯一的
public class Test3 {
public static void main(String[] args){
Phone3 phone3 = new Phone3();
new Thread(() -> {
phone3.sendMsg();
}, "A").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(() -> {
phone3.call();
}, "B").start();
}
}
class Phone3 {
public static synchronized void sendMsg() {
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("sendMsg");
}
public static synchronized void call() {
System.out.println("call");
}
public void hello() {
System.out.println("hello");
}
}
-
两个对象，是发短信还是打电话？发短信
Class模板只有一个
public class Test3 {
public static void main(String[] args){
Phone3 phone3 = new Phone3();
Phone3 phone2 = new Phone3();
new Thread(() -> {
phone3.sendMsg();
}, "A").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(() -> {
phone2.call();
}, "B").start();
}
}
- 一个对象，一个静态同步方法，一个普通同步方法，先发短信，还是先打电话？先打电话
sendMsg锁的是Class模板，call锁的是调用的对象
- 如果是两个对象，结果也是一样，结果还是打电话
public class Test4 {
public static void main(String[] args){
Phone4 phone4 = new Phone4();
new Thread(() -> {
phone4.sendMsg();
}, "A").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(() -> {
phone4.call();
}, "B").start();
}
}
class Phone4 {
public static synchronized void sendMsg() {
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("sendMsg");
}
public synchronized void call() {
System.out.println("call");
}
}
常见的并发辅助类
CountDownLatch
CountDownLatch里面定义了一个减法计算器，和一个阻塞队列，常用的方法有countDown和await方法，countDown相当于-1，await方法会等待计算器归零，然后再被唤醒向下执行。
public class CountDownLatchDemo {
public static void main(String[] args) throws InterruptedException {
// 总数6
CountDownLatch countDownLatch = new CountDownLatch(5);
// -1
countDownLatch.countDown();
for (int i = 0; i < 5; i++) {
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + "go out!");
countDownLatch.countDown();
}, String.valueOf(i)).start();
}
// 等待计数器归零，然后再向下执行
countDownLatch.await();
System.out.println("close door!");
}
}
CyclicBarrier
需要等待线程全部达到共同屏障点的同步辅助，其实就是一个加法计算器，主要是可以实现让一组线程达到同一屏障点，然后再进行后续操作。
public class CyclicBarrierDemo {
public static void main(String[] args){
CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () ->{
System.out.println("召唤神龙成功！");
});
for (int i = 1; i <= 7; i++) {
int temp = i;
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + "收集" + temp + "个龙珠");
try {
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}).start();
}
}
}
Semaphore
一个计数信号量，其中常用的两个方法acquire用于获取许可证，release释放许可证。
可以用于限流等场景，比如下面的停车场例子，当初始化为一个时，也可以用于做互斥锁。
public class SemaphoreTest {
public static void main(String[] args){
// 停车位
Semaphore semaphore = new Semaphore(3);
for (int i = 1; i <= 6; i++) {
new Thread(() -> {
// 等到
try {
semaphore.acquire();
System.out.println(Thread.currentThread().getName() + "抢到车位");
TimeUnit.SECONDS.sleep(2);
System.out.println(Thread.currentThread().getName() + "离开车位");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
semaphore.release();
}
}, String.valueOf(i)).start();
}
}
}
读写锁
读锁可以允许多个线程同时读，而写锁只允许一个线程写。
下面的例子模拟了一个缓存，这里也采用volatie关键字，用于保证map的数据的可见性。
public class ReadWriteLockDemo {
public static void main(String[] args){
MyCache myCache = new MyCache();
// 多线程写
for (int i = 1; i <= 5; i++) {
final int temp = i;
new Thread(() -> {
myCache.put(temp + "", temp + "");
}, String.valueOf(i)).start();
}
// 多线程读
for (int i = 1; i <= 5; i++) {
final int temp = i;
new Thread(() -> {
myCache.get(temp + "");
}, String.valueOf(i)).start();
}
}
}
class MyCache {
private volatile Map<String, Object> map = new HashMap<>();
private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
/**
* 一个线程写
*/
public void put(String key, Object value) {
readWriteLock.writeLock().lock();
try {
System.out.println(Thread.currentThread().getName() + "写入");
map.put(key, value);
System.out.println(Thread.currentThread().getName() + "写入成功！");
} catch (Exception e) {
e.printStackTrace();
} finally {
readWriteLock.writeLock().unlock();
}
}
/**
* 多个线程读
*/
public void get(String key) {
readWriteLock.readLock().lock();
try {
System.out.println(Thread.currentThread().getName() + "读取");
Object value = map.get(key);
System.out.println(Thread.currentThread().getName() + "读取成功:" + value);
} catch (Exception e) {
e.printStackTrace();
} finally {
readWriteLock.readLock().unlock();
}
}
}
总结
本文章分享的主要是一些并发工具类的使用和介绍，希望大家喜欢！
参考资料
狂神的JUC视频（B站上有，讲的还可以！ ）
