(1)jdk中原子类的使用:

jdk5中提供了很多原子类,它会使变量的操作变成原子性的。

原子性:原子性指的是一个操作是不可中断的,即使是在多个线程一起操作的情况下,一个操作一旦开始,就不会被其他线程干扰。

jdk中的rt.jar中提供给了很多的原子性操作类。它们是位于java.util.concurrent.atomic包中,如图:

由图可以看到,jdk提供了很多基础类型的原子类操作,已经对象(AomicReference)原子操作类,数组的原子操作类,已经对象属性院子操作类(AtomicReferenceFieldUpdater)等,篇幅关系不会一一的放使用Demo,只放AtomicReferenceFieldUpdater这个相对特殊一点的类的使用案例,感兴趣的同学可以自己去java.util.concurrent.atomic查看源码,并一一实验。示例代码:

package com.wangx.thread.t4;

import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;

public class AtomicReferenceFieldUpdaterTest {
//使用newUpdater方法构建实例,第一个参数为需要操作对象,第二个参数为需要操作的属性的数据类型字节码文件,第三个为属性名字
AtomicReferenceFieldUpdater<User, String> atomicReferenceFieldUpdater = AtomicReferenceFieldUpdater.newUpdater(User.class, String.class, "name");
User user = new User();
public void printName (String name) {
atomicReferenceFieldUpdater.set(user,name);
System.out.println(user.getName());
}
public static void main(String[] args) {
AtomicReferenceFieldUpdaterTest atomicReferenceFieldUpdaterTest = new AtomicReferenceFieldUpdaterTest();
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
atomicReferenceFieldUpdaterTest.printName("张三");
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
atomicReferenceFieldUpdaterTest.printName("李四");
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
atomicReferenceFieldUpdaterTest.printName("网五");
}
}
}).start();
}
}

当不知道对应类型的原子类怎么构建时,源码是一个很好的选择,如上案例,进入源码,找到newUpdater,方法的注释会很明确的告诉你每个参数代表的意思,如图:

原子性操作类的原理:

进入任意一个原子类中,都可以看到,其实它最终都会调用sun.misc.Unsafe类中的compareXXX方法来操作变量,Unsafe不属于java标准,它跟C语言一样可以拥有操作指针空间的能力,但是过度的使用会使的出错几率很大,所以java也不建议我们使用它,但是它提供的一些锁的机制却是被原子类使用,这里使用的就是Unsafe中提供的cas算法,cas算法就是通过不断的比较当前值与期望值,最终来确保线程安全的。

(二)Lock锁的使用及原理:

Java中实现了很多的锁,读写锁,重入锁等,他们位于java.util.concurrent.locks包中,Lock接口提供了很多方法使得我们在并发场景下保证线程安全。的我们这里使用重入锁为例演示lock的使用。代码为:

package com.wangx.thread.t4;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock; public class Sequence { private int value; //使用重入锁
Lock lock = new ReentrantLock(); public int getValue () {
lock.lock();
value++;
lock.unlock();
return value;
} public static void main(String[] args) {
Sequence sequence = new Sequence(); new Thread(new Runnable() {
@Override
public void run() {
while (true) {
System.out.println(sequence.getValue());
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
System.out.println(sequence.getValue());
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
System.out.println(sequence.getValue());
}
}
}).start();
}
}

前面已经演示过该代码在不适用锁或synchronized时会产生的线程安全问题,也使用了synchronized来避免了线程安全问题,这里使用Lock的lock和unlock也能实现线程的安全,同时也能在自己想要释放锁的位置unlock锁,同时提供了几个方法让我们在开发中线程的操作变得更加的便利。所以Lock也是有其存在的意义的,在线程开发非常复杂的情况下,使用Lock会比synchronized更加简单。

这里我们简单的实现一个基于synchronized的Lock。

首先构建一个需要使用锁的场景,然后一步步分析,最后实现锁,

  1)构建使用场景,Sequence为例

package com.wangx.thread.t4;

import java.util.concurrent.locks.Lock;

public class Sequence {

    private int value;

    //使用重入锁
Lock lock = new MyLock(); public int getValue () {
//获取锁
lock.lock();
value++;
//释放锁
lock.unlock();
return value;
} public static void main(String[] args) {
Sequence sequence = new Sequence(); new Thread(new Runnable() {
@Override
public void run() {
while (true) {
System.out.println(sequence.getValue());
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
System.out.println(sequence.getValue());
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
while (true) {
System.out.println(sequence.getValue());
}
}
}).start();
}
}

实现是为了我们更好的理解,所以只实现lock和unlock方法。

由场景可以看出,当线程进入方法时,需要获取锁,实现的方式就是我们可以给lock方法加上synchronized关键字,以Lock对象作为内置锁,实现方式为:

 public synchronized void lock() {}

同时unlock也需要synchronized来进行同步,所以当方法进入时这里就拿到了锁,同时我们还应该维护一个boolean变量isLocked来标记该锁是否已经被获取到了,初始值为false,所以当线程第一次进来时获取锁,并将赋值为true,表示锁已经被占用,其他线程进入等待。

 public synchronized void lock() {
while (isLocked) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
isLocked = true;
}

使用while更能确保在某次意外唤醒之后其他线程仍能进行等待。

当调用unlock时,我们需要的释放锁,那么这里就是需要唤醒等待的线程,并将锁状态更改为未被占用,即isLocked = false;

代码为:

 public synchronized void unlock() {
isLocked = false;
//唤醒等待的线程
notify();
}

这样一个简易的Lock就实现了,但是synchronized是一个重入锁,即当前线程拿到该线程后,可以进入到其他加了该内置锁的方法中继续执行,而我们的锁则是会出线锁无限等待的过程,示例代码:

package com.wangx.thread.t4;

import java.util.concurrent.locks.Lock;

public class Demo {

    private Lock lock = new MyLock();
public void a () {
lock.lock();
System.out.println("a");
b();
lock.unlock();
} private void b() {
lock.lock();
System.out.println("b");
lock.unlock();
} public static void main(String[] args) {
Demo demo = new Demo(); demo.a();
}
}

运行程序时会发现,当a打印之后,线程将会一直等待着,分析原因可以知道,当第一次进入a方法时。获取到所,此时的isLocked就变成了true,继续执行进入b方法是,调用lock方法,就会使线程一直等待,出不了while循环,所以导致线程挂起,所以还需要维护两个变量,一个是lockBy用来判断是否是当前线程,此时情况是执行两个方法是同一个线程,同时维护一个线程重入次数,在多层次调用时需要在适当的情况下唤醒其他线程。

package com.wangx.thread.t4;

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;
/**
* lock方法
*/
@Override
public synchronized void lock() {
//获取当前线程
Thread currentThread = Thread.currentThread();
//判断进来的线程是否是当前线程
while (isLocked && currentThread != lockBy) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//保存当前线程
lockBy = currentThread;
//标记锁重入次数
lockCount++;
isLocked = true;
} @Override
public synchronized void unlock() {
Thread currentThread = Thread.currentThread();
//当不是当前线程进入时,什么都不用做
if (currentThread == lockBy) {
//调用一次unlock减一次,实现多重调用时多个unlock
lockCount--;
//当所有重入锁释放完成之后,唤醒等待线程
if (lockCount == 0) {
isLocked = false;
//唤醒等待的线程
notify();
}
}
}
}

第一次进入lock方法时,while条件为false,此时维护当前线程到lock,当调用b方法时,由于此时的线程为同一个,所以也不会执行wait,此时lockCount为2(第一次进入也自增了),执行打印b,然后再执行b方法的unlock,lockCount--,然后回到a方法,在执行unlock,lockCount--,此时lockCount为0,表示该锁可以释放了,所以将isLocked标记为false,可以被其他线程拿到,唤醒其他等待的线程。这样就真正的实现了一个可重入的简易的自己锁。再次执行测试,将会发现a,b打印,线程退出。

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

并发编程学习笔记(4)----jdk5中提供的原子类及Lock使用及原理的更多相关文章

  1. Java并发编程学习笔记

    Java编程思想,并发编程学习笔记. 一.基本的线程机制 1.定义任务:Runnable接口 线程可以驱动任务,因此需要一种描述任务的方式,这可以由Runnable接口来提供.要想定义任务,只需实现R ...

  2. 并发编程学习笔记(15)----Executor框架的使用

    Executor执行已提交的 Runnable 任务的对象.此接口提供一种将任务提交与每个任务将如何运行的机制(包括线程使用的细节.调度等)分离开来的方法.通常使用 Executor 而不是显式地创建 ...

  3. 并发编程学习笔记(13)----ConcurrentLinkedQueue(非阻塞队列)和BlockingQueue(阻塞队列)原理

    · 在并发编程中,我们有时候会需要使用到线程安全的队列,而在Java中如果我们需要实现队列可以有两种方式,一种是阻塞式队列.另一种是非阻塞式的队列,阻塞式队列采用锁来实现,而非阻塞式队列则是采用cas ...

  4. 并发编程学习笔记(12)----Fork/Join框架

    1. Fork/Join 的概念 Fork指的是将系统进程分成多个执行分支(线程),Join即是等待,当fork()方法创建了多个线程之后,需要等待这些分支执行完毕之后,才能得到最终的结果,因此joi ...

  5. 并发编程学习笔记(10)----并发工具类CyclicBarrier、Semaphore和Exchanger类的使用和原理

    在jdk中,为并发编程提供了CyclicBarrier(栅栏),CountDownLatch(闭锁),Semaphore(信号量),Exchanger(数据交换)等工具类,我们在前面的学习中已经学习并 ...

  6. 并发编程学习笔记(9)----AQS的共享模式源码分析及CountDownLatch使用及原理

    1. AQS共享模式 前面已经说过了AQS的原理及独享模式的源码分析,今天就来学习共享模式下的AQS的几个接口的源码. 首先还是从顶级接口acquireShared()方法入手: public fin ...

  7. 并发编程学习笔记(6)----公平锁和ReentrantReadWriteLock使用及原理

    (一)公平锁 1.什么是公平锁? 公平锁指的是在某个线程释放锁之后,等待的线程获取锁的策略是以请求获取锁的时间为标准的,即使先请求获取锁的线程先拿到锁. 2.在java中的实现? 在java的并发包中 ...

  8. 并发编程学习笔记(5)----AbstractQueuedSynchronizer(AQS)原理及使用

    (一)什么是AQS? 阅读java文档可以知道,AbstractQueuedSynchronizer是实现依赖于先进先出 (FIFO) 等待队列的阻塞锁和相关同步器(信号量.事件,等等)提供一个框架, ...

  9. JUC并发编程学习笔记

    JUC并发编程学习笔记 狂神JUC并发编程 总的来说还可以,学到一些新知识,但很多是学过的了,深入的部分不多. 线程与进程 进程:一个程序,程序的集合,比如一个音乐播发器,QQ程序等.一个进程往往包含 ...

随机推荐

  1. SQLite数据库基本操作

    SQLite 是一个开源的嵌入式关系数据库,实现自包容.零配置.支持事务的SQL数据库引擎. 其特点是高度便携.使用方便.结构紧凑.高效.可靠. 与其他数据库管理系统不同,SQLite 的安装和运行非 ...

  2. EXISTS 执行顺序 CLR-2-2-引用类型和值类型

    EXISTS 执行顺序   select * from a where a.s_status=1 and exists (select orderid from b on a.orderid=b.or ...

  3. Oracle 远程访问配置 在 Windows Forms 和 WPF 应用中使用 FontAwesome 图标 C#反序列化XML异常:在 XML文档(0, 0)中有一个错误“缺少根元素” C#[Win32&WinCE&WM]应用程序只能运行一个实例:MutexHelper Decimal类型截取保留N位小数向上取, Decimal类型截取保留N位小数并且不进行四舍五入操作

    Oracle 远程访问配置   服务端配置 如果不想自己写,可以通过 Net Manager 来配置. 以下配置文件中的 localhost 改为 ip 地址,否则,远程不能访问. 1.网络监听配置 ...

  4. 获取Linux磁盘分区的UUID

    在设置fstab自动挂载时,需要填写如下的信息: # <file system> <mount point> <type> <options> < ...

  5. Eclipse的安装使用

    1.从官网下载最新的Eclipse http://www.eclipse.org/downloads/

  6. gitlab的安装和配置

    1 使用omnibus gitlab来安装gitlab 也就是说,将gitlab和它所需要的组件打一个包,即打一个bundle进行安装. 第一步,安装gitlab的源. curl https://pa ...

  7. POJ2686 Traveling by Stagecoach 状态压缩DP

    POJ2686 比较简单的 状态压缩DP 注意DP方程转移时,新的状态必然数值上小于当前状态,故最外层循环为状态从大到小即可. #include <cstdio> #include < ...

  8. 两个局域网(办公网-IDC)安全互通方案2:by GRE and linux server&深入理解GRE

    (0)gre的turnel的打通 1. 这个过程就是双方建立turnel的过程.           (1)局域网路由过程 1.主机A发送一个源为192.168.1.2,目的为10.1.1.2的包 ( ...

  9. 使用showmap分析android进程内存占用情况(转载)

    转自:http://my.oschina.net/shaorongjie/blog/105354 可以使用adb shell showmap pid查看一个进程的showmap,这对于我们来说非常有用 ...

  10. 双栈排序 2008年NOIP全国联赛提高组(二分图染色)

    双栈排序 2008年NOIP全国联赛提高组  时间限制: 1 s  空间限制: 128000 KB  题目等级 : 大师 Master     题目描述 Description Tom最近在研究一个有 ...