Java多线程基础总结九:Mina窥探(1)

一直以来的多线程的基础总结都是脱离应用的,但是要说多线程的应用就不能不说Mina。Apache Mina作为一个高性能的Java异步并发网 络通讯框架,其内部的多线程的设计和实现可谓是学习多线程的良药。手上的Mina源码是svn剪下来的最新的代码,mvn转化成eclipse项目 后导入mina-core的源码看看多线程的应用吧。

首先简单的介绍在org.apache.mina.core.service包里的核心接口之一:IoService。这个接口是对于服务器端接收连接和客户端发起连 接这两种服务的顶层抽象,所以就有了IoAcceptor和IoConnector两个子接口的继承与隔离。很拍马屁的说,从这个小细节可以看到mina架 构的精细。这种程度的接口的隔离最重要的就是对接口内抽象行为的准确划分,错误的划分接口的职责将使得后面得实现显得不合理甚至是 错误。只是不知道负责抽象的设计人员是否是一次性的抽象成功,如果是只能说牛x。至于交互会话IoSession和实际的I/O操作处理器 IoProcessor 以及底层处理I/O事件的IoHandle这些接口就不废话了,今天看的是与IoServiceListener有关的多线程应用。 IoServiceListener主要是用来监听IoService相关的事件,而今日主角--IoServiceListenerSupport则是用来把IoService和对应的 IoServiceListener包装在一起进行管理的辅助类。先看看其源码:

Java代码

public class IoServiceListenerSupport {
   /** The {@link IoService} that this instance manages. */
   private final IoService service;

   /** A list of {@link IoServiceListener}s. */
   private final List<IoServiceListener> listeners = new CopyOnWriteArrayList<IoServiceListener> ();

   /** Tracks managed sessions. */
   private final ConcurrentMap<Long, IoSession> managedSessions = new ConcurrentHashMap<Long,  IoSession>();

   /** Read only version of {@link #managedSessions}. */
   private final Map<Long, IoSession> readOnlyManagedSessions = Collections.unmodifiableMap (managedSessions);

   private final AtomicBoolean activated = new AtomicBoolean();

   /** Time this listenerSupport has been activated */
   private volatile long activationTime;

   /** A counter used to store the maximum sessions we managed since the listenerSupport has been  activated */
   private volatile int largestManagedSessionCount = 0;

   /** A global counter to count the number of sessions managed since the start */
   private volatile long cumulativeManagedSessionCount = 0;

   /**
    * Adds a new listener.
    *
    * @param listener The added listener
    */
   public void add(IoServiceListener listener) {
     if (listener != null) {
       listeners.add(listener);
     }
   }

   /**
    * @return true if the instance is active
    */
   public boolean isActive() {
     return activated.get();
   }

   /**
    * Calls {@link IoServiceListener#serviceActivated(IoService)}
    * for all registered listeners.
    */
   public void fireServiceActivated() {
     if (!activated.compareAndSet(false, true)) {
       // The instance is already active
       return;
     }

     activationTime = System.currentTimeMillis();

     // Activate all the listeners now
     for (IoServiceListener listener : listeners) {
       try {
         listener.serviceActivated(service);
       } catch (Throwable e) {
         ExceptionMonitor.getInstance().exceptionCaught(e);
       }
     }
   }

   /**
    * Calls {@link IoServiceListener#sessionCreated(IoSession)} for all registered listeners.
    *
    * @param session The session which has been created
    */
   public void fireSessionCreated(IoSession session) {
     boolean firstSession = false;

     if (session.getService() instanceof IoConnector) {
       synchronized (managedSessions) {
         firstSession = managedSessions.isEmpty();
       }
     }
   ...

     cumulativeManagedSessionCount ++;
   ...
   }
}

时间: 2024-08-04 00:33:08

Java多线程基础总结九:Mina窥探(1)的相关文章

Java多线程基础总结七:ReentrantLock

之前总结了部分无锁机制的多线程基础,理想的状态当然是利用无锁同步解决多线程程序设计的问题.但是实际碰到的问题使得很多情 况下,我们不得不借助锁同步来保证线程安全.自从JDK5开始,有两种机制来屏蔽代码块在并行访问的干扰,synchronized关键字已经介绍 过了部分内容,所以这次简单的说说另一种锁机制:ReentrantLock. 对于synchronized的缺点之前也简单的说了一些,实际使用中比较烦扰的几点是:a.只有一个"条件"与锁相关联,这对于大量并发线程 的情况是很难管理(

Java多线程基础总结八:ReentrantReadWriteLock

说到ReentrantReadWriteLock,首先要做的是与ReentrantLock划清界限.它和后者都是单独的实现,彼此之间没有继承或实现的关系. 然后就是总结这个锁机制的特性了: (a).重入方面其内部的WriteLock可以获取ReadLock,但是反过来ReadLock想要获得WriteLock则永远都不要想. (b).WriteLock可以降级为ReadLock,顺序是:先获得WriteLock再获得ReadLock,然后释放WriteLock,这时候线程将保持Readlock的

Java多线程基础总结三: volatile

前面的两篇总结简单的说明了同步的一些问题,在使用基础的同步机制中还有两个可以分享的技术:volatile关键字和ThreadLocal.合 理的根据场景利用这些技术,可以有效的提高并发的性能,下面尝试结合自己的理解叙述这部分的内容,应该会有理解的偏差,我也会尽量 的在完善自己理解的同时同步更新文章的错误. 或许在知道synchronized配和对象内部锁的机制以后,可以提高写出正确同步的并发程序成功率,但是这时候会遇到另一个大问题:性 能!是的,对于 synchronized带来的可能庞大的性能

Java多线程基础总结一: synchronized(1)

最近写关于并发的小应用,才发现真的该好好的正视java的多线程了.之前没有深入的掌握,用起来也是那么的吃力.作为J2SE里面为 数不多的重要难点之一,多线程应用一直是我以敬畏的心态去尽量避开的,只是通过一些实例掌握一些简单的应用.这段时间会多用点时间 去掌握,有需要写下来的我也会通过这种方式既分享又加深理解. 首先这篇只涉及基础的知识整理,对于并发包java.util.concurrent内的线程池和锁我会看情况在之后的总结中写点东西.对于进程的 概念我们都很熟悉,它是应用程序级的隔离,不同的应

Java多线程基础总结四:ThreadLocal

说到ThreadLocal,首先说说这个类的命名.直观上看好像是个Thread的什么亲戚,但其实它想表达的意思是线程本地变量,也就是说每 个线程自己的变量.它作为一个JDK5以后支持范型的类,主要是想利用范型把非线程安全的共享变量,封装成绑定线程的安全不共享变量. 这样的解释我想我们多半能猜出它的实现思路:把一个共享变量在每个线程使用时,初始化一个副本,并且和线程绑定.以后所有的线程对 共享变量的操作都是对线程内部那个副本,完全的线程内部变量的操作. 要实现这样功能类的设计,主要技术点是要能把副

java多线程基础(synchronize关键字)

基础知识 多线程实现方法 使用Thread创建线并启动线程 使用Runnable创建并启动线程 使用内部类创建线程 线程的方法 线程优先级 守护线程 sleep方法 yield方法 join方法 线程同步 基础知识 线程:进程(process)就是一块包含了某些资源的内存区域.操作系统利用进程把它的工作划分为一些功能单元. 线程:进程中所包含的一个或多个执行单元称为线程(thread).进程还拥有一个私有的虚拟地址空间,该空间仅能被它所包含的线程访问. 线程和进程的区别如下: 1)一个进程至少有

java:多线程基础之Runnable、Callable与Thread

java.lang包下有二个非常有用的东西:Runnable接口与Thread类,Thread实现了Runnable接口(可以认为Thread是Runnable的子类),利用它们可以实现最基本的多线程开发. 一.Runnable入门示例 1 public class RunnableDemo1 { 2 3 public static void main(String[] args) { 4 new Runnable() { 5 public void run() { 6 for (int i =

Java多线程基础总结六:synchronized(2)

早在总结一时,我就尽量的把synchronized的重点说的简单:它就是配和对象的隐式锁使用的,注意一定是对象的隐式锁!那么下面的 这个例子又怎么解释呢? Java代码 /** * User: yanxuxin * Date: Dec 17, 2009 * Time: 9:38:27 PM */ public class ImplicitLockSample { public static void main(String[] args) { final ImplicitLock sample

Java多线程基础总结五:atomic

在简单介绍java.util.concurrent.atomic包之前,有个概念要先抄袭熟悉一遍:CAS(比较并交换).现在大多数的处理器都提供对并发 访问的支持,这个支持的反映方式就是提供硬件的指令支持多处理的特殊需求.比如检测或者阻止其它处理器的并发访问来更新共享变量的 指令.对于 Intel x86架构的处理器来说就是通过提供实现CAS或者比较并设置的硬件原语指令集.CAS操作的三个操作数:内存位置(V) ,预期原值(A)和新值(B).执行的过程通常是:预测内存地址V应该包含值A,如果包含