大致分成:

1.原子更新基本类型

2.原子更新数组

3.原子更新抽象类型

4.原子更新字段

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicIntegerArray;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
import java.util.concurrent.atomic.AtomicReference; public class Sequence {
private AtomicInteger value=new AtomicInteger(0);
private int [] s={2,1,4,6};
AtomicIntegerArray array=new AtomicIntegerArray(s); AtomicReference<User> use=new AtomicReference<>(); AtomicIntegerFieldUpdater<User> old=
AtomicIntegerFieldUpdater.newUpdater(User.class,
"old"); public int getNext(){
User user=new User();
System.out.println(old.getAndIncrement(user));
System.out.println(old.getAndIncrement(user));
System.out.println(old.getAndIncrement(user));
old.getAndIncrement(user);
array.getAndIncrement(2);
array.getAndAdd(2, 10);
return value.getAndIncrement();//自增value++
//value.incrementAndGet();//++value
}
public static void main(String[] args) {
Sequence s=new Sequence();
new Thread(new Runnable() { @Override
public void run() {
System.out.println(Thread.currentThread().getName()+""
+s.getNext());
try {
Thread.sleep(100);
} catch (InterruptedException e) { e.printStackTrace();
}
} }).start();
// new Thread(new Runnable() {
//
// @Override
// public void run() {
// System.out.println(Thread.currentThread().getName()+""
// +s.getNext());
// try {
// Thread.sleep(100);
// } catch (InterruptedException e) {
//
// e.printStackTrace();
// }
// }
//
// }).start();
}
}

  Lock接口:

Lock需要显示的获取和释放锁,繁琐,但是能让代码更灵活,随时,获取和释放锁

Synchronized:不需要显示的获取和释放锁 ,简单

使用lock可以方便的实现公平性

非阻塞的获取锁

能被中断的获取锁

超时获取锁

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock; public class Sequence {
private int value;
Lock lock=new ReentrantLock();//所有的线程公用一把锁
public int getNext() {
lock.lock();
int a= value++;
lock.unlock();
return a;
} public static void main(String[] args) {
Sequence s = new Sequence();
new Thread(new Runnable() { @Override
public void run() {
while (true) {
System.out.println(Thread.currentThread().getName() + "" + s.getNext());
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} }).start(); new Thread(new Runnable() { @Override
public void run() {
while (true) {
System.out.println(Thread.currentThread().getName() + "" + s.getNext());
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} }).start(); new Thread(new Runnable() { @Override
public void run() {
while (true) {
System.out.println(Thread.currentThread().getName() + "" + s.getNext());
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} }).start();
}
}

  实现一个锁的重入:

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock; public class MyLock implements Lock{ private boolean isLocked=false;
private Thread lockBy=null;
private int lockCount=0;
@Override
public synchronized void lock() {
//Thread.activeCount()
Thread currentThread=Thread.currentThread();//获取当前线程
while(isLocked &&currentThread!=lockBy){ //不相等,等待
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
isLocked=true;
lockBy=currentThread;
lockCount++;
}
} @Override
public synchronized void unlock() {
if(lockBy==Thread.currentThread()){
lockCount--;
if(lockCount==0){
notify();
isLocked=false;
}
}
}
@Override
public void lockInterruptibly() throws InterruptedException {
// TODO Auto-generated method stub } @Override
public Condition newCondition() {
// TODO Auto-generated method stub
return null;
} @Override
public boolean tryLock() {
// TODO Auto-generated method stub
return false;
} @Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
// TODO Auto-generated method stub
return false;
}
}

  

public class Demo {
MyLock lock=new MyLock();
public void a(){
lock.lock();
System.out.println("a");
b();
lock.unlock();
}
public void b(){
lock.lock();
System.out.println("b");
lock.unlock();
}
public static void main(String[] args) {
Demo demo=new Demo();
new Thread(new Runnable() {
@Override
public void run() {
demo.a();
}
}).start();
}
}

  AbstractQueuedSynchronizer(AQS)

开发文档:http://tool.oschina.net/apidocs/apidoc?api=jdk-zh

公平锁:

公平锁是对锁的获取而言,如果一个锁是公平的,那么锁的获取顺序就是应该符合请求的绝对时间顺序。

import java.util.ArrayList;
import java.util.List; public class FairLock {
private boolean isLocked=false;
private Thread lockingThread=null;
private List<QueueObject> waitingThreads=new ArrayList<QueueObject>(); private void lock() throws InterruptedException{
QueueObject queueObject=new QueueObject();
synchronized (this) {
waitingThreads.add(queueObject);
}
try {
queueObject.doWait();
} catch (InterruptedException e) {
synchronized (this) {
waitingThreads.remove(queueObject);
}
throw e;
}
} public synchronized void unlock(){
if(this.lockingThread!=Thread.currentThread()){
throw new IllegalMonitorStateException("Calling thread has not locked this lock");
}
isLocked=false;
lockingThread=null;
if(waitingThreads.size()>0){
waitingThreads.get(0).doNotify();
}
}
}

  

public class QueueObject {
private boolean isNotified=false;
public synchronized void doWait() throws InterruptedException{
while(!isNotified){
this.wait();
}
this.isNotified=false;
}
public synchronized void doNotify(){
this.isNotified=true;
this.notify();
}
public boolean equals(Object o){
return this==o;
}
}

  aqs实现锁重入:

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock; public class MyLock2 implements Lock{
private Helper helper=new Helper();
private class Helper extends AbstractQueuedSynchronizer{
@Override
protected boolean tryAcquire(int arg){
//如果第一个线程进来,可以拿到锁,可以返回true //第二个线程进来,拿不到锁,返回false.有种特列,
//如果当前进来的线程的和当前保存的线程是同一个线程,则可以拿到锁,但是有代价。要更新状态的值 //如何判断是第一个线程进来,还是其他线程
int state=getState();
Thread t=Thread.currentThread();
if(state==0){
if(compareAndSetState(0, arg)){
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
}else if(getExclusiveOwnerThread()==t){
setState(state+1);
return true;
} return false;
}
@Override
protected boolean tryRelease(int arg){
//锁的获取和释放肯定是一一对应的,那么调用此方法的线程一定是当前线程
if(Thread.currentThread()!=getExclusiveOwnerThread()){
throw new RuntimeException();
}
int state=getState()-arg;
boolean flag=false;
if(getState()==0){
setExclusiveOwnerThread(null);
flag=true;
}
setState(state);
return flag;
}
Condition newCondition(){
return new ConditionObject();
}
} @Override
public void lock() {
helper.acquire(1);
} @Override
public void lockInterruptibly() throws InterruptedException {
helper.acquireInterruptibly(1);
} @Override
public Condition newCondition() {
return helper.newCondition();
} @Override
public boolean tryLock() {
return helper.tryAcquire(1);
} @Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
return helper.tryAcquireNanos(1, unit.toNanos(time));
} @Override
public void unlock() {
helper.release(1);
} }

  

public class Main {
private int value;
private MyLock2 lock=new MyLock2();
public int next(){
lock.lock();
try {
Thread.sleep(300);
return value++;
} catch (InterruptedException e) {
throw new RuntimeException();
}finally {
lock.unlock();
}
}
public void a(){
lock.lock();
System.out.println("a");
b();
lock.unlock();
}
public void b(){
lock.lock();
System.out.println("b");
lock.unlock();
}
public static void main(String[] args) {
Main m=new Main();
new Thread(new Runnable() {
@Override
public void run() {
m.a();
}
}).start();
// new Thread(new Runnable() {
// @Override
// public void run() {
// while(true){
// System.out.println(Thread.currentThread().getId()
// +""+ m.next());
// }
// }
// }).start();
// new Thread(new Runnable() {
// @Override
// public void run() {
// while(true){
// System.out.println(Thread.currentThread().getId()
// +""+ m.next());
// }
// }
// }).start();
} }

JDK提供的原子类和AbstractQueuedSynchronizer(AQS)的更多相关文章

  1. Java并发编程原理与实战十三:JDK提供的原子类原理与使用

    原子更新基本类型 原子更新数组 原子更新抽象类型 原子更新字段 原子更新基本类型:   package com.roocon.thread.t8; import java.util.concurren ...

  2. JDK提供的原子类原理与使用

    原子更新基本类型 原子更新数组 原子更新抽象类型 原子更新字段 原子更新基本类型: package com.roocon.thread.t8; import java.util.concurrent. ...

  3. 并发编程学习笔记(4)----jdk5中提供的原子类及Lock使用及原理

    (1)jdk中原子类的使用: jdk5中提供了很多原子类,它会使变量的操作变成原子性的. 原子性:原子性指的是一个操作是不可中断的,即使是在多个线程一起操作的情况下,一个操作一旦开始,就不会被其他线程 ...

  4. css 框架——base.css,作用是重设浏览器默认样式和提供通用原子类。自己留存

    今天发下我自己的 css 框架——base.css,作用是重设浏览器默认样式和提供通用原子类. @charset "utf-8"; /*! * @名称:base.css * @功能 ...

  5. B8 Concurrent JDK中的乐观锁与原子类

    [概述] 乐观锁采用的是一种无锁的思想,总是假设最好的情况,认为一个事务在读取数据的时候,不会有别的事务对数据进行修改,只需要在修改数据的时候判断原数据数据是否已经被修改了.JDK 中 java.ut ...

  6. Java多线程系列——原子类的实现(CAS算法)

    1.什么是CAS? CAS:Compare and Swap,即比较再交换. jdk5增加了并发包java.util.concurrent.*,其下面的类使用CAS算法实现了区别于synchronou ...

  7. 【Java并发工具类】原子类

    前言 为保证计数器中count=+1的原子性,我们在前面使用的都是synchronized互斥锁方案,加锁独占访问的方式未免太过霸道,于是我们来介绍另一种解决原子性问题的无锁方案:原子变量.在正式介绍 ...

  8. 【漫画】CAS原理分析!无锁原子类也能解决并发问题!

    本文来源于微信公众号[胖滚猪学编程].转载请注明出处 在漫画并发编程系统博文中,我们讲了N篇关于锁的知识,确实,锁是解决并发问题的万能钥匙,可是并发问题只有锁能解决吗?今天要出场一个大BOSS:CAS ...

  9. java的原子类到底是啥?ABA,CAS又是些什么?

    1)解决并发不是用锁就能解决吗,那SDK干嘛还要搞个原子类出来? 锁虽然能解决,但是加锁解锁始终还是对性能是有影响的,并且使用不当可能会造成死锁之类的问题. 2)原子类是怎样使用的,比如说我要实现一个 ...

随机推荐

  1. TODO list(咕咕咕。。。

    1. Segment Tree Beats 2. ZR集训补题(还剩10题) 3. 尽可能将各种数据结构写得熟练...(某神仙:要把平衡树写得跟线段树一样熟练) 4. 树相关数据结构和算法(dsu o ...

  2. powershell.exe WannaCrypt(永恒之蓝) down.bddp.net

    今天win机器进程出现大量 powershell.exe,把cpu占满100%,打开任务管理器看到如下信息: powershell -nop -w hidden -ep bypass -c " ...

  3. nRF51822 Beacon 扫描请求包的设置

    Nordic 公司自己做有 iBeacon的板子和 SDK,很少有人拥有这个SDK,我最近在朋友那也拿到了一个,但是还没有时间看. 现在我们用普通的SDK自带的 Beacon 例程来做开发,开发的时相 ...

  4. clion ctrl+鼠标左键不能调到函数实现

    问题:ctrl+鼠标左键只能在函数定义和申明之间跳转,不能跳转到implement,如果按ctrl+shift+B会报“no implement”. 解决:更改CMakeList文件,更改版本号. c ...

  5. 【pytorch 代码】pytorch 网络结构可视化

    部分内容转载自 http://blog.csdn.net/GYGuo95/article/details/78821617,在此表示由衷感谢. 此方法需要安装python-graphviz:  con ...

  6. 记一次edusoho问题

    问题描述:Edusoho如何迁移到本地windows或另外一台Linux服务器上 解决问题步骤: 1.参考官方文档官方文档地址如下:http://www.qiqiuyu.com/my/course/3 ...

  7. Wireshark常用快捷键&&过滤器语法

    目录 一.快捷键 二.过滤器语法 1.捕获过滤器的BPF(Berkeley Packet Filter)语法 2.显示过滤器 一.快捷键 Ctrl+M 标记/取消标记 shift+ctrl+N/B 下 ...

  8. golang 文件传输小demo(转载)

    转载地址:https://www.cnblogs.com/qq702368956/p/10195497.html 获取文件信息需要用到os. Stat接口,发送文件前开启接收者(服务端),启动客户端先 ...

  9. NGINX Cache Management (.imh nginx)

    In this article, we will explore the various NGINX cache configuration options, and tips on tweaking ...

  10. 已知X,Y独立,那么X^2与Y也独立

    考虑离散情况,  P{X^2=k} => P{X=sqrt(k)} 由X,Y独立可知, P{X=Sqrt(k}  | Y=y} =P{X=Sqrt(x)}, P{X^2=k | Y=y} =P{ ...