`

java 并发编程之同步器

阅读更多

 

 在讨论Java的锁的时候,有一个概念很重要,那就是同步器,同步器可以想象成一种互斥量,当一个线程在进入临界区之前先要获得互斥量,同样,在线程获得同步状态之前也是需要获取到同步器。今天看到《java并发编程的艺术》第五章的时候觉得蛮有收获,所以这一篇算是整理下看书思路。

 

首先,我们来看一下Lock的接口

 

public interface Lock {

    void lock();
    boolean tryLock();
    void unlock();
    Condition newCondition();
}

 这个接口只是提供了几个常见的方法,而没有实现,当我们需要使用锁的时候会实现这个接口的lock和unlock方法,在这些方法的实现就是需要用到队列同步器 .AbstractQueuedSynchronizer, AbstractQueuedSynchronizer这个类提供了很多的同步方法,主要可分为三类:

1,状态追踪方法

       getState()   :获取当前状态

       setState(int ):设置当前状态

       compareAndSetState(int expect,int update);  CAS如果当前是expect值则设置其值为update,CAS具有同步功能,因为它具有volatile的读写特性,保证编译器不会对这一段代码进行重排序

2,独占锁同步

       acquire(int arg) 获取锁

       acquireInterruptibly(int arg)  中断

       tryAcquireNanos(int arg,long nanos)  尝试获取锁,并且如果超时则放弃

       

       boolean release(int arg)  释放锁

       

3,共享锁同步 共享锁和独占所方法解释差不多,只是共享锁能够同时让多个线程执行,独占锁只能单独的线程获取同步状态后执行,其余线程会进入等待队列

       acquireShared(int arg)

       acquireSharedInterruptibly(int arg)

      tryAcqiuireSharedNanos(int arg,long nanos)

 

      boolean releaseShared(int arg);      

     

AbstractQueuedSynchronizer这个同步队列在很多的并行类或者容器中都能看到身影,因为它是负责很多的同步处理的关键,一个线程在进入临界区之前需要执行acquire方法获得同步机会,而acquire方法先要tryAcquire()如果能够获取则进入执行,如果不能获取则进入等待队列(acquire有比较复杂的方法使得进入等待队列能够实现同步,而且保持FIFO的算法)。

 

我们可以自定义自己的锁和同步器,通过继承AbstractQueuedSynchronizer这个类实现自己的同步器,而因为AbstractQueuedSynchronizer的acquire和release方法的都要执行tryAcquire和tryRelease方法,因此我们只需要重写这两个方法就能实现自定义的同步算法。

 

首先,我们来实现一个自定义的独占锁

 

package com.luchi.concurrencyImpl;

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 Mutex implements Lock{

	
	//自定义内部类同步器
	private static class Sync extends AbstractQueuedSynchronizer{
		
		@Override
		protected boolean isHeldExclusively(){
			
			return getState()==1;
		}
		
		@Override
		public boolean tryAcquire(int acquires){
			
			
			if(compareAndSetState(0, 1)){
				setExclusiveOwnerThread(Thread.currentThread());
				return true;
			}
			return false;
		}
		
		@Override
		
		public boolean tryRelease(int release){
			
			if(getState()==0){
				throw new IllegalMonitorStateException();
			}
			setExclusiveOwnerThread(null);
			setState(0);
			return true;
			
			
		}
		Condition newCondition(){return new ConditionObject();}
		
	}
	
	private final Sync sync=new Sync();
	
	@Override
	public void lock() {
		// TODO Auto-generated method stub
		sync.acquire(1);
	}

	@Override
	public void unlock() {
		// TODO Auto-generated method stub
		sync.release(1);
		
	}
	@Override
	public void lockInterruptibly() throws InterruptedException {
		// TODO Auto-generated method stub
		sync.acquireInterruptibly(1);
	}

	@Override
	public boolean tryLock() {
		// TODO Auto-generated method stub
		return sync.tryAcquire(1);
	}

	@Override
	public boolean tryLock(long time, TimeUnit unit)
			throws InterruptedException {
		// TODO Auto-generated method stub
		return sync.tryAcquireNanos(1,unit.toNanos(time));
	}


	@Override
	public Condition newCondition() {
		// TODO Auto-generated method stub
		return sync.newCondition();
	}

}

 

接着我们来定义一段共享锁

 

package com.luchi.concurrencyImpl;

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 TwinsLock implements Lock{

	private final Sync sync=new Sync(2);
	//自定义队列同步器
	private static final class Sync extends AbstractQueuedSynchronizer{
		
		
		//初始化队列同步器的
		Sync(int count){
			if(count<=0){
				throw new  IllegalArgumentException("count must larger than zero");
				
			}
			setState(count);
		}
		
		@Override
		
		public int tryAcquireShared(int reduceCount){
			
			while(true){
				int current=getState();
				int newCount=current-reduceCount;
				if(newCount<0 || compareAndSetState(current,newCount)){
					
					return newCount;
					
				}
				
			}
		}
		
		
		@Override
		public boolean tryReleaseShared(int returnCount){
			
			while(true){
				
				int current=getState();
				int newCount=current+returnCount;
				if(compareAndSetState(current, newCount)){
					return true;
				}
			}
			
		}
		
		
		
	}
	
	
	@Override
	public void lock() {
		// TODO Auto-generated method stub
		
		sync.acquireShared(1);
	}

	@Override
	public void lockInterruptibly() throws InterruptedException {
		// TODO Auto-generated method stub
		
	}

	@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;
	}

	@Override
	public void unlock() {
		// TODO Auto-generated method stub
		
		
		sync.releaseShared(1);
		
	}

	@Override
	public Condition newCondition() {
		// TODO Auto-generated method stub
		return null;
	}
	
	
	

}

  可以看到,无论是共享锁合适独占锁,在自定义的时候只需要重写tryAcquire(或者tryAcquireShare)方法和tryRelease(或者tryReleaseShared)方法即可,独占锁因为“互斥量”为1所以不需要初始化,共享锁则可以自定义互斥量的多少,也就是定义多少个线程能够同时进入同步区。

 

另外我们也可以看到,锁和同步器的分离降低了两者之间的耦合度,也方便程序开发人员进行模块化定义和分工,这符合软件工程的思维

 

 

分享到:
评论

相关推荐

    java并发编程之同步器代码示例

    主要介绍了java并发编程之同步器代码示例,分享了相关代码,具有一定参考价值,需要的朋友可以了解下。

    Java并发编程实战

    4.2.1 Java监视器模式 4.2.2 示例:车辆追踪 4.3 线程安全性的委托 4.3.1 示例:基于委托的车辆追踪器 4.3.2 独立的状态变量 4.3.3 当委托失效时 4.3.4 发布底层的状态变量 4.3.5 示例:发布状态的车辆追踪...

    Java 并发编程实战

    4.2.1 Java监视器模式 4.2.2 示例:车辆追踪 4.3 线程安全性的委托 4.3.1 示例:基于委托的车辆追踪器 4.3.2 独立的状态变量 4.3.3 当委托失效时 4.3.4 发布底层的状态变量 4.3.5 示例:发布状态的车辆追踪...

    Java并发编程解析 | 解析AQS基础同步器的设计与实现

    Java并发编程解析 | 解析AQS基础同步器的设计与实现

    Java 7并发编程实战手册

    如果你是一名Java开发人员,并且想进一步掌握并发编程和多线程技术,并挖掘Java 7并发的新特性,那么本书是你的合适之选。 《Java 7并发编程实战手册》 第1章 线程管理 1 1.1 简介 1 1.2 线程的创建和运行...

    java并发编程:juc、aqs

    Java 并发编程中的 JUC(java.util.concurrent)库以及其核心组件 AQS(AbstractQueuedSynchronizer)在构建高性能、可伸缩性的多线程应用方面具有重要的地位。 AQS 是 JUC 中的核心组件,它提供了一个框架,让...

    java 并发编程

    Java7在并发编程方面,带来了很多令人激动的新功能,这将使你的应用...如果你是一名Java开发人员,并且想进一步掌握并发编程和多线程技术,并挖掘Java7并发的新特性,那么《Java7并发编程实战手册》是你的合适之选。

    java并发编程理论基础精讲

    本资源为您提供了关于 Java 并发编程理论基础的精讲,涵盖了多线程编程的核心概念、基本原理以及在 Java 中的应用。通过深入学习,您将建立坚实的并发编程基础,能够更好地理解和应对多线程编程中的挑战。 并发编程...

    汪文君高并发编程实战视频资源下载.txt

    │ Java并发编程.png │ ppt+源码.rar │ 高并发编程第二阶段01讲、课程大纲及主要内容介绍.wmv │ 高并发编程第二阶段02讲、介绍四种Singleton方式的优缺点在多线程情况下.wmv │ 高并发编程第二阶段03讲、...

    Java并发编程(学习笔记).xmind

    Java并发编程 背景介绍 并发历史 必要性 进程 资源分配的最小单位 线程 CPU调度的最小单位 线程的优势 (1)如果设计正确,多线程程序可以通过提高处理器资源的利用率来提升系统吞吐率 ...

    java并非编程,合集(各种锁、并发集合、障碍器、线程同步).zip

    java并非编程,合集(各种锁、并发集合、障碍器、线程同步)

    Java并发编程之美_部分71

    第 10章Java并发包中线程同步器原理剖析263工 f (compareAndSetState(c, nextc))如上代码首先获取当前状态值(计数器值) 。

    汪文君高并发编程实战视频资源全集

    │ Java并发编程.png │ ppt+源码.rar │ 高并发编程第二阶段01讲、课程大纲及主要内容介绍.wmv │ 高并发编程第二阶段02讲、介绍四种Singleton方式的优缺点在多线程情况下.wmv │ 高并发编程第二阶段03讲、...

    java编发编程:JUC综合讲解

    Java 并发编程在现代软件开发中占据重要地位,尤其是在多核处理器的时代。JUC(java.util.concurrent)库是 Java 标准库的一部分,提供了丰富的多线程并发工具,旨在帮助开发者编写高性能、高可伸缩性的并发程序。...

    java并发编程

    主要介绍java常用并发API,内容有: 基于String构建自己的锁管理器、 Collections构建不可修改的集合对象、 CopyOnWriteArrayList的应用场景、 可堵塞队列的功能及行为、 使用API实现压力测试、 CyclicBarrier与...

    java多线程编程总结

    详细的讲述了多线程的各种用法 Java线程:概念与原理 Java线程:创建与启动 Java线程:线程栈模型与线程的变量 Java线程:线程状态的转换 Java线程:线程的同步与锁 ...Java线程:新特征-障碍器 Java线程:大总结

    Java多线程编程总结

    Java 线程系列博文总结word化,编目如下,欢迎互相学习交流: Java线程:概念与原理 Java线程:创建与启动 Java线程:线程栈模型与线程的变量 Java线程:线程状态的转换 ...Java线程:新特征-障碍器

Global site tag (gtag.js) - Google Analytics