多线程之三：JDK并发包

最新推荐文章于 2023-06-06 16:37:22 发布

莱宝

最新推荐文章于 2023-06-06 16:37:22 发布

阅读量365

点赞数

分类专栏： Java 文章标签： java多线程

本文链接：https://blog.csdn.net/qq_21508727/article/details/80617634

版权

Java 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

整理自炼数成金

源码连接：

1. 各种同步控制工具的使用

1.1.ReentrantLock

1.1.1. 可重入单线程可以重复进入，但要重复退出

1.1.2. 可中断 lockInterruptibly()

1.1.3. 可限时超时不能获得锁，就返回false，不会永久等待构成死锁

1.1.4. 公平锁先来先得 (相对不公平锁，线程调度的效率会差点)

[java] view plain copy

public ReentrantLock(boolean fair)
public static ReentrantLock fairLock = new ReentrantLock(true);

公平是有代价的。如果您需要公平，就必须付出代价，但是请不要把它作为您的默认选择。

1.1.5. 代码示例

[java] view plain copy

Public class Test{
Lock lock = new ReentrantLock();
Public void Method1(){
try {
lock.lockInterruptibly ();
// update object state
}
finally {
lock.unlock();
}
}
}

可以看到 Lock 和 synchronized 有一点明显的区别 —— lock 必须在 finally 块中释放。否则，如果受保护的代码将抛出异常，锁就有可能永远得不到释放！这一点区别看起来可能没什么，但是实际上，它极为重要。忘记在 finally 块中释放锁，可能会在程序中留下一个定时炸弹，当有一天炸弹爆炸时，您要花费很大力气才有找到源头在哪。而使用同步，JVM 将确保锁会获得自动释放。

1.2.Condition

1.2.1. 概述

类似于 Object.wait()和Object.notify()

与ReentrantLock结合使用

Lock 对象则充当绑定到这个锁的条件变量的工厂对象，与标准的 wait 和 notify 方法不同，对于指定的 Lock ，可以有不止一个条件变量与它关联。这样就简化了许多并发算法的开发。例如，条件（Condition）的 Javadoc 显示了一个有界缓冲区实现的示例，该示例使用了两个条件变量，“not full”和“not empty”，它比每个 lock 只用一个 wait 设置的实现方式可读性要好一些（而且更有效）。

1.2.2. 主要接口

[java] view plain copy

void await() throws InterruptedException;
void awaitUninterruptibly();
long awaitNanos(long nanosTimeout) throws InterruptedException;
boolean await(long time, TimeUnit unit) throws InterruptedException;
boolean awaitUntil(Date deadline) throws InterruptedException;
void signal();
void signalAll();

1.2.3. API详解

await()方法会使当前线程等待，同时释放当前锁，当其他线程中使用signal()时或者signalAll()方法时，线程会重新获得锁并继续执行。或者当线程被中断时，也能跳出等待。这和Object.wait()方法很相似。

awaitUninterruptibly()方法与await()方法基本相同，但是它并不会再等待过程中响应中断。

singal()方法用于唤醒一个在等待中的线程。相对的singalAll()方法会唤醒所有在等待中的线程。这和Obej ct.notify()方法很类似。

1.2.4.代码示例

[java] view plain copy

public class BlockQueue<T> {
private ReentrantLock lock = new ReentrantLock();
private Condition FullCondition = lock.newCondition();
private Condition EmptyCondition = lock.newCondition();
private List<T> list = new ArrayList<T>() ;
private int Max;
public BlockQueue(int size){
Max = size;
}
public boolean push(T t){
try{
lock.lock();
while(list.size()>=Max){
FullCondition.await();
}
list.add(t);
EmptyCondition.signal();
}catch(Exception e){
e.printStackTrace();
}finally{
lock.unlock();
}
// synchronized(list){
// while(true){
// if(list.size()>=Max){
// try{
// list.wait();
// }catch(Exception e){
// e.printStackTrace();
// }
// }else{
// break;
// }
// }
// list.add(t);
//
// list.notify();
// }
return true;
}
public T poll(){
T t = null;
try{
lock.lock();
while(list.isEmpty()){
EmptyCondition.await();
}
t = list.get(0);
list.remove(0);
FullCondition.signal();
}catch(Exception e){
e.printStackTrace();
}finally{
lock.unlock();
}
// synchronized(list){
// while(true){
// if(list.isEmpty()){
// try{
// list.wait();
// }catch(Exception e){
// e.printStackTrace();
// }
// }else{
// break;
// }
// }
// t = list.get(0);
// list.remove(0);
// list.notify();
// }
return t;
}
}

该示例是自定义阻塞队列的实现，从代码可以看出，Object. notify ()会对该Object所有wait队列中随机唤醒一个，可能唤醒的不是我们想要的，例如读操作唤醒了读操作，所以可能会造成死锁。而Condition可以有多个，所以可以有目的的唤醒操作。例如只唤醒读操作或写操作。

1.3. Semaphore（信号量）

1.3.1. 概述共享锁运行多个线程同时临界区

1.3.2. 主要接口

[java] view plain copy

public void acquire()
public void acquireUninterruptibly()
public boolean tryAcquire()
public boolean tryAcquire(long timeout, TimeUnit unit)
public void release()

1.3.3.代码示例

[java] view plain copy

public class TestSemaphore {
public static void main(String[] args) {
// 线程池
ExecutorService exec = Executors.newCachedThreadPool();
// 只能5个线程同时访问
final Semaphore semp = new Semaphore(5);
// 模拟20个客户端访问
for (int index = 0; index < 20; index++) {
final int NO = index;
Runnable run = new Runnable() {
public void run() {
try {
// 获取许可
semp.acquire();
System.out.println("Accessing: " + NO);
Thread.sleep((long) (Math.random() * 10000));
// 访问完后，释放
semp.release();
System.out.println("-----------------"+semp.availablePermits());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
exec.execute(run);
}
// 退出线程池
exec.shutdown();
}
}

Java 并发库的Semaphore 可以很轻松完成信号量控制，Semaphore可以控制某个资源可被同时访问的个数，通过 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。比如在Windows下可以设置共享文件的最大客户端访问个数。

1.4.ReadWriteLock

1.4.1. 概述

ReadWriteLock是JDK5中提供的读写分离锁

读写锁：分为读锁和写锁，多个读锁不互斥，读锁与写锁互斥，这是由jvm自己控制的，你只要上好相应的锁即可。如果你的代码只读数据，可以很多人同时读，但不能同时写，那就上读锁；如果你的代码修改数据，只能有一个人在写，且不能同时读取，那就上写锁。总之，读的时候上读锁，写的时候上写锁！

1.4.2. 访问情况

读-读不互斥：读读之间不阻塞。

读-写互斥：读阻塞写，写也会阻塞读。

写-写互斥：写写阻塞。

1.4.3. 主要接口

[java] view plain copy

private static ReentrantReadWriteLock readWriteLock=new ReentrantReadWriteLock();
private static Lock readLock = readWriteLock.readLock();
private static Lock writeLock = readWriteLock.writeLock();

1.4.4. 代码示例

[java] view plain copy

class Queue3{
private Object data = null;//共享数据，只能有一个线程能写该数据，但可以有多个线程同时读该数据。
private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
public void get(){
rwl.readLock().lock();//上读锁，其他线程只能读不能写
System.out.println(Thread.currentThread().getName() + " be ready to read data!");
try {
Thread.sleep((long)(Math.random()*1000));
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
rwl.readLock().unlock(); //释放读锁，最好放在finally里面
}
System.out.println(Thread.currentThread().getName() + "have read data :" + data);
}
public void put(Object data){
rwl.writeLock().lock();//上写锁，不允许其他线程读也不允许写
System.out.println(Thread.currentThread().getName() + " be ready to write data!");
try {
Thread.sleep((long)(Math.random()*1000));
this.data = data;
} catch (InterruptedException e) {
e.printStackTrace();
}finally{
rwl.writeLock().unlock();//释放写锁
}
System.out.println(Thread.currentThread().getName() + " have write data: " + data);
}
}

代码中get方法可以多个线程同时访问，当put方法被调用时会等正在进行的get方法全部释放了读锁，然后争取到写锁。但是写锁只能1个线程同时拥有，读锁可以多个线程同时拥有。

1.5.CountDownLatch

1.5.1. 概述

倒数计时器

一种典型的场景就是火箭发射。在火箭发射前，为了保证万无一失，往往还要进行各项设备、仪器的检查。只有等所有检查完毕后，引擎才能点火。这种场景就非常适合使用CountDownLatch。它可以使得点火线程，等待所有检查线程全部完工后，再执行主线程

1.5.2. 主要接口

[java] view plain copy

static final CountDownLatch end = new CountDownLatch(10);
end.countDown();
end.await();

1.5.3. 示意图

1.5.4. 代码示例

[java] view plain copy

public class Test {
public static void main(String[] args) {
final CountDownLatch latch = new CountDownLatch(2);
new Thread(){
public void run() {
try {
System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");
Thread.sleep(3000);
System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕");
latch.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
};
}.start();
new Thread(){
public void run() {
try {
System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");
Thread.sleep(3000);
System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕");
latch.countDown();
} catch (InterruptedException e) {
e.printStackTrace();
}
};
}.start();
try {
System.out.println("等待2个子线程执行完毕...");
latch.await();
System.out.println("2个子线程已经执行完毕");
System.out.println("继续执行主线程");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

1.6.CyclicBarrier

1.6.1. 概述

Cyclic意为循环，也就是说这个计数器可以反复使用。比如，假设我们将计数器设置为10。那么凑齐第一批1 0个线程后，计数器就会归零，然后接着凑齐下一批10个线程

1.6.2. 主要接口

public CyclicBarrier(int parties, Runnable barrierAction)

barrierAction就是当计数器一次计数完成后，系统会执行的动作 await()

1.6.3. 示意图

1.6.4. 代码示例

[java] view plain copy

public class Test {
public static void main(String[] args) {
int N = 4;
CyclicBarrier barrier = new CyclicBarrier(N,new Runnable() {
@Override
public void run() {
System.out.println("当前线程"+Thread.currentThread().getName());
}
});
for(int i=0;i<N;i++)
new Writer(barrier).start();
}
static class Writer extends Thread{
private CyclicBarrier cyclicBarrier;
public Writer(CyclicBarrier cyclicBarrier) {
this.cyclicBarrier = cyclicBarrier;
}
@Override
public void run() {
System.out.println("线程"+Thread.currentThread().getName()+"正在写入数据...");
try {
Thread.sleep(5000); //以睡眠来模拟写入数据操作
System.out.println("线程"+Thread.currentThread().getName()+"写入数据完毕，等待其他线程写入完毕");
cyclicBarrier.await();
} catch (InterruptedException e) {
e.printStackTrace();
}catch(BrokenBarrierException e){
e.printStackTrace();
}
System.out.println("所有线程写入完毕，继续处理其他任务...");
}
}
}

输出结果：

线程Thread-0正在写入数据...

线程Thread-3正在写入数据...

线程Thread-2正在写入数据...

线程Thread-1正在写入数据...

线程Thread-2写入数据完毕，等待其他线程写入完毕

线程Thread-0写入数据完毕，等待其他线程写入完毕

线程Thread-3写入数据完毕，等待其他线程写入完毕

线程Thread-1写入数据完毕，等待其他线程写入完毕

当前线程Thread-3

所有线程写入完毕，继续处理其他任务...

从上面输出结果可以看出，每个写入线程执行完写数据操作之后，就在等待其他线程写入操作完毕。

当所有线程线程写入操作完毕之后，所有线程就继续进行后续的操作了。

1.7. LockSupport

1.7.1. 概述

提供线程阻塞原语

1.7.2. 主要接口

LockSupport.park();

LockSupport.unpark(t1);

1.7.3. 与suspend()比较

不容易引起线程冻结

1.7.4. 中断响应

能够响应中断，但不抛出异常。中断响应的结果是，park()函数的返回，可以从Thread.interrupted()得到中断标志

1.8.ReentrantLock 的实现

1.8.1. CAS状态

1.8.2. 等待队列

1.8.3. park()

2. 并发容器

2.1.集合包装

为集合类包了一层衣服，为每个方法添加了同步的实现。

2.1.1. HashMap

Collections.synchronizedMap

public static Map m=Collections.synchronizedMap(new HashMap());

2.1.2. List

synchronizedList

2.1.3. Set

synchronizedSet

2.2.ConcurrentHashMap

高性能HashMap

看起来是一个Map数据结构，内部实现将其划分为几个小的Map，而且每个Map都有独立的锁，形成分区锁。每个分区的读写操作不影响另一个分区。

2.3.BlockingQueue

阻塞队列

莱宝

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
多线程之三：JDK并发包

整理自炼数成金源码连接：1.各种同步控制工具的使用 1.1.ReentrantLock1.1.1.可重入单线程可以重复进入，但要重复退出1.1.2.可中断lockInterruptibly()1.1.3.可限时超时不能获得锁，就返回false，不会永久等待构成死锁1.1...
复制链接

扫一扫

专栏目录