一。读写锁

  传统的同步锁就是独占式锁,当线程使用资源时候保持独占,无论读写。当人们发现请求队列(假设)中相邻请求为读-读的时候,阻塞是一种浪费资源的操作。比如公告板,所有路过的人(请求)都是读操作,并没有因为你和他在读的时候对内容造成了改变,所以在模型中,读与读操作不需要阻塞。而读写相邻则需要进行独占式操作了,因为写未完成的时候,信息是不完整的,此时读出来的信息有可能是错误的,所以写必然要保持独占式操作。而在应用程序中,读的频率是写的好几倍,也就是说如果读-读是不阻塞的,那么对性能来说是毋庸置疑的提升。

  Java中存在一种锁,名曰:ReentrantReadWriteLock。他可以实现内存中对资源操作的读写锁,读与读是不阻塞的。

import java.util.Random;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock; /**
* Created by MacBook on 2018/3/10.
*/
public class ReadWriteLockDemo {
private static Lock relock = new ReentrantLock();
private static ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
private static Lock readLock = readWriteLock.readLock();
private static Lock writeLock = readWriteLock.writeLock();
private int value;
public Object handleRead(Lock lock) throws Exception{
try{
lock.lock();
Thread.sleep(1000);
return value;
}finally {
lock.unlock();
}
}
public void handleWrite(Lock lock,int index) throws Exception{
try{
lock.lock();
Thread.sleep(1000);
value = index;
}finally {
lock.unlock();
}
}
public static void main(String[] args){
ReadWriteLockDemo demo = new ReadWriteLockDemo();
Runnable readThread = new Runnable() {
@Override
public void run() {
try{
System.out.println("read:"+demo.handleRead(readLock));
}catch (Exception e){
e.printStackTrace();
}
}
};
Runnable writeThread = new Runnable() {
@Override
public void run() {
try{
// demo.handleWrite(relock,new Random().nextInt());
demo.handleWrite(writeLock,new Random().nextInt());
System.out.println("id:"+Thread.currentThread().getId()+" done!");
}catch (Exception e){
e.printStackTrace();
}
}
};
for(int i=0;i<18;i++){
new Thread(readThread).start();
}
for(int i=0;i<18;i++){
new Thread(writeThread).start();
}
} }

    此demo使用了重入锁和读写锁的对比,在主程序中分别新建18个读写操作,如果使用了读操作,则打印的读操作是连续的;如果使用了重入锁,则可能的情况是读写相邻打印,并且都是阻塞的,读者可以自行测试体会。

二。对象监视器Condition

  在JDK实现了Lock来简化synchronized之后,Condition作为简化监视器而存在。Condition的await方法和signal方法对应对象的wait和signal。

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock; /**
* Created by MacBook on 2018/3/10.
*/
public class ConditionAndLock implements Runnable{
static ReentrantLock lock = new ReentrantLock();
static Condition condition = lock.newCondition(); public void run(){
try{
lock.lock();
condition.await();
System.out.println("thread is running");
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
public static void main(String[] args){
ConditionAndLock c = new ConditionAndLock();
Thread t = new Thread(c);
t.start();
lock.lock();
System.out.println("signal all");
condition.signalAll();
lock.unlock();
}
}

三。倒计时器CountDownLatch

  多线程中,需要知道这批线程的最大完成任务时间,也就是从第一个任务开始到最后返回这段时间的时长,那么倒计时器是必不可少的。就像各项资源准备完毕才进行下一步操作的模型一样,CountDownLatch就是这样的多线程模型。等到所有任务调用了计数器,并且计数器总数到达某个数量时候,它才会将阻塞代码放开,让主线程往下走。

import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors; /**
* 倒计时器
* Created by MacBook on 2018/3/10.
*/
public class CountDownLatchDemo implements Runnable{
static CountDownLatch end = new CountDownLatch(10);
static CountDownLatchDemo demo = new CountDownLatchDemo();
public void run(){
try{
Thread.sleep(new Random().nextInt(10)*1000);
System.out.println(Thread.currentThread().getId()+" check complete!");
end.countDown();
}catch (Exception e){
e.printStackTrace();
}
}
public static void main(String[] args) throws Exception{
ExecutorService service = Executors.newFixedThreadPool(10);
for(int i=0;i<10;i++){
service.submit(demo);
}
end.await();
System.out.println("fire");
service.shutdown();
}
}

    await方法是阻塞倒计时器所在线程的方法,等到线程池service中调用countDown方法到达一定的数量(此处是10)之后,主线程的await方法才会过去。

四。信号量

  信号量这个东西就比较玄乎了,有点像准入许可,拿到信号准入的时候才往下执行。就像是有一批人拿号,只有号码区间在某个范围的人能进去办事,然后办完事就会让资源释放,号码区间往后移。然而在信号量中应该算是复用类型的,归还了key值,将key值返回给下一个申请者。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore; /**
* Created by MacBook on 2018/3/10.
*/
public class SemapDemo implements Runnable{
final Semaphore semp = new Semaphore(5);
public void run(){
try{
semp.acquire();
Thread.sleep(2000);
System.out.println(Thread.currentThread().getId()+" done!");
semp.release();
}catch (Exception e){
e.printStackTrace();
}
}
public static void main(String[] args){
ExecutorService executorService = Executors.newFixedThreadPool(5);
SemapDemo semapDemo = new SemapDemo();
for(int i=0;i<20;i++){
executorService.submit(semapDemo);
}
executorService.shutdown();
}
}

  在acquire获得key之后,操作读写,之后release。

五。栅栏

  栅栏和倒计时器很像,就是拦住一堆线程,等到线程数达到某个设定值之后同时把它们放出去。但是不同的是,它可以每次设定值达成时候运行定制线程中的run方法。就像是每次一个栏,够数就放。

import java.util.Random;
import java.util.concurrent.CyclicBarrier; /**
* Created by MacBook on 2018/3/10.
*/
public class CylicBarrierDemo {
public static class Soldier implements Runnable{
private String soldier;
private final CyclicBarrier cyclicBarrier;
Soldier(String soldier,CyclicBarrier cyclicBarrier){
this.soldier = soldier;
this.cyclicBarrier = cyclicBarrier;
}
public void run(){
try{
cyclicBarrier.await();
doWork();
cyclicBarrier.await();
}catch (Exception e){
e.printStackTrace();
}
}
public void doWork(){
try{
Thread.sleep(Math.abs(new Random().nextInt()%10000));
}catch (Exception e){
e.printStackTrace();
}
System.out.println(soldier + " done!");
}
}
public static class BarrierRun implements Runnable{
boolean flag;
int n;
public BarrierRun(boolean flag,int n){
this.flag = flag;
this.n = n;
} public void run(){
if(flag){
System.out.println("士兵:"+n+"个 done!");
}else {
System.out.println("士兵:"+n+"个 集合完毕!");
flag = true;
}
}
}
public static void main(String[] args){
final int n = 10;
Thread[] allSoldier = new Thread[n];
boolean flag = false;
CyclicBarrier cyclic = new CyclicBarrier(n,new BarrierRun(flag,n));
System.out.println("集合");
for(int i =0; i < n ; i++){
System.out.println("士兵 "+i+" 报道");
allSoldier[i] = new Thread(new Soldier("士兵"+i,cyclic));
allSoldier[i].start();
}
}
}

  例中CyclicBarrier有两个参数,前一个就是提到的设定值,后一个就是定制线程了。每当到达设定值的时候会触发定制线程。

  每个阶段完成都会调用一下定制线程。

六。LockSupport提供线程挂起操作的支持类

  正如Condition使得原有的Object监视器封装成了新类,LockSupport提供使线程park和unpark之类的操作。

import java.util.concurrent.locks.LockSupport;

/**
* Created by MacBook on 2018/3/10.
*/
public class LockSupportDemo {
public static Object u = new Object();
static ChangeObjectThread t1 = new ChangeObjectThread("t1");
static ChangeObjectThread t2 = new ChangeObjectThread("t2");
public static class ChangeObjectThread extends Thread{
public ChangeObjectThread(String name){
super.setName(name);
}
public void run(){
synchronized (u){
System.out.println("in "+getName());
LockSupport.park();
}
}
}
public static void main(String[] args) throws Exception{
t1.start();
Thread.sleep(100);
t2.start();
LockSupport.unpark(t1);
LockSupport.unpark(t2);
t1.join();
t2.join();
} }

  它在park时候线程会变成wait状态,而不是runnable。

  来自《Java高并发程序设计》的读书笔记

Concurrent包工具类使用的更多相关文章

  1. 常用Concurrent.util包工具类——高并发

    一 Concurrent.util常用类: 1. CyclicBarrier: 假设有场景:每个线程代表一个跑步运动员,当运动员都准备好后,才一起出发只要有一个人没有准备好,大家都等待. import ...

  2. Java 操作jar包工具类以及如何快速修改Jar包里的文件内容

    需求背景:写了一个实时读取日志文件以及监控的小程序,打包成了Jar包可执行文件,通过我们的web主系统上传到各个服务器,然后调用ssh命令执行.每次上传前都要通过解压缩软件修改或者替换里面的配置文件, ...

  3. 高并发编程基础(java.util.concurrent包常见类基础)

    JDK5中添加了新的java.util.concurrent包,相对同步容器而言,并发容器通过一些机制改进了并发性能.因为同步容器将所有对容器状态的访问都串行化了,这样保证了线程的安全性,所以这种方法 ...

  4. Java操作FTP工具类(实例详解)

    这里使用Apache的FTP jar 包 没有使用Java自带的FTPjar包  工具类 package com.zit.ftp; import java.io.File; import java.i ...

  5. C#中SQLite的使用及工具类

    目录 SQLite简介 存储类 亲和类型 引用System.Data.SQLite.dll 软件包分类 使用本机库预加载 常用部署包 工具类 参考资料 SQLite简介 SQLite是一款轻型的数据库 ...

  6. 并发之java.util.concurrent.atomic原子操作类包

    15.JDK1.8的Java.util.concurrent.atomic包小结 14.Java中Atomic包的原理和分析 13.java.util.concurrent.atomic原子操作类包 ...

  7. 推荐使用concurrent包中的Atomic类

        这是一个真实案例,曾经惹出硕大风波,故事的起因却很简单,就是需要实现一个简单的计数器,每次取值然后加1,于是就有了下面这段代码:           private int counter = ...

  8. JUC 包下工具类,它的名字叫 LockSupport !你造么?

    前言 LockSupport 是 JUC 中常用的一个工具类,主要作用是挂起和唤醒线程.在阅读 JUC 源码中经常看到,所以很有必要了解一下. 公众号:liuzhihangs ,记录工作学习中的技术. ...

  9. 代码片段:基于 JDK 8 time包的时间工具类 TimeUtil

    摘要: 原创出处:www.bysocket.com 泥瓦匠BYSocket 希望转载,保留摘要,谢谢! “知识的工作者必须成为自己时间的首席执行官.” 前言 这次泥瓦匠带来的是一个好玩的基于 JDK ...

随机推荐

  1. msys2 设置home路径为windows用户路径

    1配置/etc/nsswitch.conf db_home: windows 2(可不配)增加windows环境变量HOME为%USERPROFILE% 3(可不配)ssh默认仍使用msys中的hom ...

  2. KbmMW 认证管理器说明(转载)

    这是kbmmw 作者关于认证管理器的说明,我懒得翻译了,自己看吧. There are 5 parts of setting up an authorization manager: A) Defin ...

  3. 2018.09.26 bzoj4326: NOIP2015 运输计划(二分+树上差分)

    传送门 简单树上操作. 先转边权为点权. 显然所有的询问操作对应的路径会有一些交点,那么我们可以直接二分答案,对于所有大于二分值的询问用树上差分维护,最后dfs一遍每个点被覆盖了几次,当前情况合法当且 ...

  4. 2018.07.25 bzoj3878: [Ahoi2014&Jsoi2014]奇怪的计算器(线段树)

    传送门 线段树综合. 让我想起一道叫做siano" role="presentation" style="position: relative;"&g ...

  5. Django的路由层(1)

    https://www.cnblogs.com/yuanchenqi/articles/8876685.html URL配置(URLconf)就像Django 所支撑网站的目录.它的本质是URL与要为 ...

  6. 笔记:PS 智能对象

    什么是智能对象? 智能对象是包含栅格或矢量图像(如 Photoshop 或 Illustrator 文件)中的图像数据的图层.智能对象将保留图像的源内容及其所有原始特性,从而让您能够对图层执行非破坏性 ...

  7. 记spring mvc传入List<Object>的一次尝试

    首先,看一段异常: org.springframework.http.converter.HttpMessageNotReadableException: Could not read documen ...

  8. AOT和JIT以及混合编译的区别、优劣

    AOT,JIT是什么? JIT,即Just-in-time,动态(即时)编译,边运行边编译: AOT,Ahead Of Time,指运行前编译,是两种程序的编译方式 区别 这两种编译方式的主要区别在于 ...

  9. C++中的矩阵运算

    C++中的矩阵运算 1. 2阶矩阵的逆矩阵公式

  10. Even and Odd Functions

    \subsection{Even and Odd Functions} For a function $f$ in the form $y=f(x)$, we describe its type of ...