`
Donald_Draper
  • 浏览: 996725 次
社区版块
存档分类
最新评论

SelectorImpl分析

    博客分类:
  • NIO
阅读更多
Channel接口定义:http://donald-draper.iteye.com/blog/2369111
AbstractInterruptibleChannel接口定义:http://donald-draper.iteye.com/blog/2369238
SelectableChannel接口定义:http://donald-draper.iteye.com/blog/2369317
SelectionKey定义:http://donald-draper.iteye.com/blog/2369499
SelectorProvider定义:http://donald-draper.iteye.com/blog/2369615
AbstractSelectableChannel定义:http://donald-draper.iteye.com/blog/2369742
NetworkChannel接口定义:http://donald-draper.iteye.com/blog/2369773
ServerSocketChannel定义:http://donald-draper.iteye.com/blog/2369836
Selector定义:http://donald-draper.iteye.com/blog/2370015
AbstractSelector定义:http://donald-draper.iteye.com/blog/2370138
上一篇我们看了一下AbstractSelector,主要是维护取消key集合,和key的反注册。
取消的key放在一个set集合中,对集合进行添加操作时,必须同步取消key set集合。
反注册选择key完成的实际工作是,将key,从key对应的通道的选择key数组(这个我们在选择通道相关文章中有讲)中移除。
今天来看一下SelectorImpl
abstract class SelectorImpl extends AbstractSelector
{
    protected Set selectedKeys;//就绪key集合,即已经操作事件准备就绪的选择key
    protected HashSet keys;//与选择器关联的key集合
    private Set publicKeys;//外部访问key集合的代理
    private Set publicSelectedKeys;//外部访问就绪key集合代理
        protected SelectorImpl(SelectorProvider selectorprovider)
    {
        super(selectorprovider);
	//初始化就绪key集合和key集合
        keys = new HashSet();
        selectedKeys = new HashSet();
        if(Util.atBugLevel("1.4"))
        {
            publicKeys = keys;
            publicSelectedKeys = selectedKeys;
        } else
        {
	    //将当前key集合包装成不可修改的集合publicKes
            publicKeys = Collections.unmodifiableSet(keys);
	    //将就绪key集合包装成容量固定的集合
            publicSelectedKeys = Util.ungrowableSet(selectedKeys);
        }
    }
}

再来看构造的在bugLevel为1.4的情况下,就绪key和key集合的代理集合初始化分2步看:
1.BugLevel为1.4
if(Util.atBugLevel("1.4"))
    {
        publicKeys = keys;
        publicSelectedKeys = selectedKeys;
    }

2.BugLevel不为1.4
 else
        {
	    //将当前key集合包装成不可修改的集合publicKes
            publicKeys = Collections.unmodifiableSet(keys);
	    //将就绪key集合包装成容量固定的集合
            publicSelectedKeys = Util.ungrowableSet(selectedKeys);
        }


//Util,nio通道工具类,从定义来看应该是缓冲区工具
class Util
{
    private static ThreadLocal localSelector = new ThreadLocal();
    private static ThreadLocal localSelectorWrapper = new ThreadLocal();
    private static Unsafe unsafe = Unsafe.getUnsafe();
    private static int pageSize = -1;
    private static volatile Constructor directByteBufferConstructor = null;
    private static volatile Constructor directByteBufferRConstructor = null;
    private static volatile String bugLevel = null;
    private static boolean loaded = false;
    static final boolean $assertionsDisabled = !sun/nio/ch/Util.desiredAssertionStatus();
    static 
    {
        //通道IO工具
        TEMP_BUF_POOL_SIZE = IOUtil.IOV_MAX;
    }
}




//通道IO工具
class IOUtil
{
    ...,这里省略一些方法,用到的时候再讲,主要是读写Socket
    static native boolean randomBytes(byte abyte0[]);
    static native long makePipe(boolean flag);
    static native boolean drain(int i)
        throws IOException;
    //配置阻塞模式
    static native void configureBlocking(FileDescriptor filedescriptor, boolean flag)
        throws IOException;
   //获取文件描述(Socket)的值
    static native int fdVal(FileDescriptor filedescriptor);
    //设置文件描述的值
    static native void setfdVal(FileDescriptor filedescriptor, int i);
    static native int iovMax();
    static native void initIDs();
    static final int IOV_MAX = iovMax();
    static final boolean $assertionsDisabled = !sun/nio/ch/IOUtil.desiredAssertionStatus();
    static 
    {
        Util.load();
    }
}




上面两个工具类我们在以后遇到的时候再讲,粗略地看一了,Util为nio的缓冲区工具,IOUtil为通道IO工具。
再回到就绪key和key集合的代理集合初始化的第一点:
if(Util.atBugLevel("1.4"))
    {
        publicKeys = keys;
        publicSelectedKeys = selectedKeys;
    } 

//Util
static boolean atBugLevel(String s)
    {
        if(bugLevel == null)
        {
            if(!VM.isBooted())
	        //如果虚拟器没启动,则返回false
                return false;
	    //在当前线程访问控制权限的环境下,获取系统属性sun.nio.ch.bugLevel
            String s1 = (String)AccessController.doPrivileged(new GetPropertyAction("sun.nio.ch.bugLevel"));
            bugLevel = s1 == null ? "" : s1;
        }
        return bugLevel.equals(s);
    }

关于bugLevel的相关连接:
Sun GlassFish Enterprise Server v3 Release Notes:
https://docs.oracle.com/cd/E19226-01/820-7688/6niu9p8i3/index.html
Use of the bug level variable  -Dsun.nio.ch.bugLevel=1.4:
https://community.oracle.com/thread/1240510
从上面来看bugLevel对应的是虚拟机启动的参数配置sun.nio.ch.bugLevel,
由于在nio包在1.4时加入,包中有一个bug问题,
"java.lang.NullPointerException
at sun.nio.ch.Util.atBugLevel(Util.java:326)
at sun.nio.ch.SelectorImpl.<init>(SelectorImpl.java:40)
at sun.nio.ch.WindowsSelectorImpl.<init>(WindowsSelectorImpl.java:104)
at sun.nio.ch.WindowsSelectorProvider.openSelector(WindowsSelectorProvider.java:26)
at java.nio.channels.Selector.open(Selector.java:209)

这个bug在jdk1.5中存在,直到jdk1.7才修复。
从上面的这些信息来看bugLevel应该是标记nio存在bug情况的jdk版本,
如果有不同的理解,可以给我留言。

atBugLevel方法有两点关注:
a.判断虚拟机是否启动
b.获取虚拟机参数sun.nio.ch.bugLevel
先看第一点
a.判断虚拟机是否启动
package sun.misc;
import java.util.Properties;

// Referenced classes of package sun.misc:
//            OSEnvironment, VMNotification

public class VM
{
    public VM()
    {
    }
    //下面这些变量,暂时不选关注,以后有时间,
    //我们在看,只需要看到的虚拟机是否启动booted
    private static boolean suspended = false;
    /**
     * @deprecated Field STATE_GREEN is deprecated
     */
    public static final int STATE_GREEN = 1;
    /**
     * @deprecated Field STATE_YELLOW is deprecated
     */
    public static final int STATE_YELLOW = 2;
    /**
     * @deprecated Field STATE_RED is deprecated
     */
    public static final int STATE_RED = 3;
    private static volatile boolean booted = false;
    private static long directMemory = 67108864L;/64M
    private static boolean pageAlignDirectMemory;
    private static boolean defaultAllowArraySyntax;
    private static boolean allowArraySyntax;
    private static final Properties savedProps = new Properties();
    private static volatile int finalRefCount = 0;
    private static volatile int peakFinalRefCount = 0;
    private static final int JVMTI_THREAD_STATE_ALIVE = 1;
    private static final int JVMTI_THREAD_STATE_TERMINATED = 2;
    private static final int JVMTI_THREAD_STATE_RUNNABLE = 4;
    private static final int JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER = 1024;
    private static final int JVMTI_THREAD_STATE_WAITING_INDEFINITELY = 16;
    private static final int JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT = 32;
    static 
    {
        defaultAllowArraySyntax = false;
        allowArraySyntax = defaultAllowArraySyntax;
        initialize();
    }
    private static native void initialize();
    public static void booted()
    {
        booted = true;
    }
    //VM是否启动
    public static boolean isBooted()
    {
        return booted;
    }
}

b.获取虚拟机参数sun.nio.ch.bugLevel
//GetPropertyAction,获取系统属性Action
package sun.security.action;
import java.security.PrivilegedAction;
public class GetPropertyAction
    implements PrivilegedAction
{
    private String theProp;
    private String defaultVal;
    public GetPropertyAction(String s)
    {
        theProp = s;
    }
    public GetPropertyAction(String s, String s1)
    {
        theProp = s;
        defaultVal = s1;
    }
    //获取系统属性,为空返回默认属性值
    public String run()
    {
        String s = System.getProperty(theProp);
        return s != null ? s : defaultVal;
    }
    public volatile Object run()
    {
        return run();
    }
}

从上面一段分析可以看出,如果nio包的JDK版本存在bug问题,则就绪key和key集合的代理集合直接引用就绪key和key集合。
再回到就绪key和key集合的代理集合初始化的第二点:
2.BugLevel不为1.4
else
   {
      //将当前key集合包装成不可修改的集合publicKes
       publicKeys = Collections.unmodifiableSet(keys);
      //将就绪key集合包装成容量固定的集合
       publicSelectedKeys = Util.ungrowableSet(selectedKeys);
   }

将当前key集合包装成不可修改的集合publicKes,这个就不用说了,我们以前在java的集合综述篇中有说。我们主要将下一点将就绪key集合包装成容量固定的集合,
//Util
 static Set ungrowableSet(Set set)
    {
        return new Set(set) {
             final Set val$s;
            {
                s = set;
                super();
            }
            public int size()
            {
                return s.size();
            }
            public boolean isEmpty()
            {
                return s.isEmpty();
            }
            public boolean contains(Object obj)
            {
                return s.contains(obj);
            }
            ...
            public Iterator iterator()
            {
                return s.iterator();
            }
            ...
            public void clear()
            {
                s.clear();
            }

            public boolean remove(Object obj)
            {
                return s.remove(obj);
            }

            public boolean containsAll(Collection collection)
            {
                return s.containsAll(collection);
            }

            public boolean removeAll(Collection collection)
            {
                return s.removeAll(collection);
            }

            public boolean retainAll(Collection collection)
            {
                return s.retainAll(collection);
            }
	    //集合不可添加元素
            public boolean add(Object obj)
            {
                throw new UnsupportedOperationException();
            }
            public boolean addAll(Collection collection)
            {
                throw new UnsupportedOperationException();
            }
        };
    }

从上面来看
Util.ungrowableSet(Set set)方法,对集合Set进行简单的封装,移除迭代,比较等操作
直接委托给原始的Set集合,只是封装后的集合不允许添加元素,但可以移除,查询操作。
这段话是不是很熟悉,在Selector定义的文章,Java Doc有说就绪key集合SelectedKeys的
这些属性。
小节一下就绪key和key集合的初始化:
如果nio包的JDK版本存在bug问题,则就绪key和key集合的代理集合直接引用就绪key和key集合。否则将当前key集合包装成不可修改的代理集合publicKes,将就绪key集合包装成容量固定的集合publicSelectedKeys

再来看获取就绪key和key集合
//key集合
public Set keys()
 {
     if(!isOpen() && !Util.atBugLevel("1.4"))
         throw new ClosedSelectorException();
     else
         return publicKeys;
 }

//就绪key
 public Set selectedKeys()
 {
     if(!isOpen() && !Util.atBugLevel("1.4"))
         throw new ClosedSelectorException();
     else
         return publicSelectedKeys;
 }

从上面来看,其他线程获取选择器的就绪key和key集合,实际上返回的是
key集合的代理publicKeys和就绪key集合的代理publicSelectedKeys。

再来看几个选择操作:
 public int select()
        throws IOException
    {
        //委托给select(long l)
        return select(0L);
    }
 public int select(long l)
        throws IOException
    {
        if(l < 0L)
	    //负数抛出异常
            throw new IllegalArgumentException("Negative timeout");
        else
	    //委托给lockAndDoSelect(long l)
            return lockAndDoSelect(l != 0L ? l : -1L);
    }
 public int selectNow()
        throws IOException
    {
         //委托给lockAndDoSelect(long l)
        return lockAndDoSelect(0L);
    }

再来看lockAndDoSelect方法:
private int lockAndDoSelect(long l)
        throws IOException
    {
        SelectorImpl selectorimpl = this;
        JVM INSTR monitorenter ;
        if(!isOpen())
            throw new ClosedSelectorException();
	//取得key集合代理
        Set set = publicKeys;
        JVM INSTR monitorenter ;
	//取得就绪key代理
        Set set1 = publicSelectedKeys;
        JVM INSTR monitorenter ;
	//实际选择操作代理
        return doSelect(l);
        Exception exception;
        exception;
        throw exception;
        Exception exception1;
        exception1;
        throw exception1;
        Exception exception2;
        exception2;
        throw exception2;
    }

在上面的方法中有一些:
 JVM INSTR monitorenter ;
 ...
 Exception exception;
 exception;
 throw exception;

这个是什么意思,不是很理解,找了一下资料
JVM INSTR:
https://coderanch.com/t/385088/java/JVM-INSTR
JVM INSTR monitorenter and JVM INSTR monitorexit:
http://stackoverflow.com/questions/9547975/jvm-instr-monitorenter-and-jvm-instr-monitorexit
按照资料的说法,上述的这标记是JVM规范,实际相当与同步语句块(synchronized);
JVM INSTR monitorenter进入同步,JVM INSTR monitorexit退出同步;
Exception exception;
exception;
throw exception;

相等于
catch(Exception exception)
{
    throw exception;
}

再来看实际选择操作
//实际选择操作
return doSelect(l);

//待父类扩展,我们在下一篇文章中再看
protected abstract int doSelect(long l)
        throws IOException;

select方法的3中操作形式,实际上委托给为lockAndDoSelect方法,方法实际上是同步的,
可安全访问,获取key集合代理publicKeys和就绪key代理集合publicSelectedKeys,然后交给
doSelect(long l)方法,这个方法为抽象方法,待子类扩展。
在AbstractSelector的close方法,最有调用了implCloseSelector;
下面来看关闭选择器的实际操作implCloseSelector
 public void implCloseSelector()
        throws IOException
    {
        wakeup();
        synchronized(this)
        {
            synchronized(publicKeys)
            {
                synchronized(publicSelectedKeys)
                {
                    implClose();
                }
            }
        }
    }

  
 //唤醒等待选择操作的线程,待子类扩展
    public abstract Selector wakeup();

   
//完成实际的关闭选择器工作
    protected abstract void implClose()
        throws IOException;

从implCloseSelector方法来看,首先唤醒等待选择操作的线程,唤醒方法wakeup待实现,
同步选择器,就绪key和key集合的代理publicKeys,publicSelectedKeys,调用implClose完成实际的关闭通道工作,待子类实现。
再来看注册通道到选择器:
 protected final SelectionKey register(AbstractSelectableChannel abstractselectablechannel, int i, Object obj)
    {
        if(!(abstractselectablechannel instanceof SelChImpl))
	    //如果可选择通道不是SelChImpl的实例,则抛出IllegalSelectorException
            throw new IllegalSelectorException();
	//更具可选择通道和选择器创建选择key
        SelectionKeyImpl selectionkeyimpl = new SelectionKeyImpl((SelChImpl)abstractselectablechannel, this);
        //设置key的附加物
	selectionkeyimpl.attach(obj);
	//同步key集合代理
        synchronized(publicKeys)
        {
	    //完成实际的注册工作
            implRegister(selectionkeyimpl);
        }
	//设置key的兴趣事件集
        selectionkeyimpl.interestOps(i);
        return selectionkeyimpl;
    }

  
 //待子类实现
    protected abstract void implRegister(SelectionKeyImpl selectionkeyimpl);

从可选通道注册方法来看,首先注册的通道必须是AbstractSelectableChannel类型,并且是SelChImpl实例。更具可选择通道和选择器构造选择key,设置选择key的附加物,同步key集合代理,调用implRegister方法完成实际的注册工作,implRegister方法待子类实现。
//再来看处理反注册队列,现在看,还不能完全理解此方法的意思,在后面的文章,
我们会继续说,现在不能能完全看到,只以目前的能力,阅读以下代码,理解多少是多少,
因为里面牵涉到JVM规范,不知道说的正不正确,我只以目前的能力来阅读代码。
 void processDeregisterQueue()
        throws IOException
    {
        Set set = cancelledKeys();//获取取消key集合
        Set set1 = set;
        JVM INSTR monitorenter ;//进入同步语句块
        Iterator iterator;
        if(set.isEmpty())
            break MISSING_BLOCK_LABEL_110;
        iterator = set.iterator();
_L2://遍历取消key集合
        SelectionKeyImpl selectionkeyimpl;
        if(!iterator.hasNext())
            break; /* Loop/switch isn't completed */
        selectionkeyimpl = (SelectionKeyImpl)iterator.next();
        try
        {
	    //完成实际取消选择key的反注册
            implDereg(selectionkeyimpl);
        }
        catch(SocketException socketexception)
        {
            IOException ioexception = new IOException("Error deregistering key");
            ioexception.initCause(socketexception);
            throw ioexception;
        }
	//从取消key集合中移除已经反注册的取消选择key
        iterator.remove();
        if(true) goto _L2; else goto _L1
_L1:
        break MISSING_BLOCK_LABEL_110;
        Exception exception;
        exception;
        iterator.remove();
        throw exception;
        Exception exception1;
        exception1;
        throw exception1;
    }

 
 //完成SelectionKey的实际反注册工作
    protected abstract void implDereg(SelectionKeyImpl selectionkeyimpl)
        throws IOException;

从processDeregisterQueue方法来看,主要是遍历取消key集合,反注册取消key,实际的
反注册工作由implDereg方法,implDereg方法待子类扩展。
成功,则从集合中移除。

这个方法,待子类实现,我们以后再看
void putEventOps(SelectionKeyImpl selectionkeyimpl, int i)
{
   }

总结:
     SelectorImpl有4个集合分别为就绪key集合,key集合,key集合的代理publicKeys及就绪key集合的代理publicSelectedKeys;实际是两个集合就绪key集合和key集合,publicSelectedKeys和publicKeys是其他线程访问上述两个集合的代理。
     SelectorImpl构造的时候,初始化选择器提供者SelectorProvider,创建就绪key集合和key集合,然后初始化就绪key和key集合的代理,初始化过程为,如果nio包的JDK版本存在bug问题,则就绪key和key集合的代理集合直接引用就绪key和key集合。否则将当前key集合包装成不可修改的代理集合publicKes,将就绪key集合包装成容量固定的集合publicSelectedKeys。
其他线程获取选择器的就绪key和key集合,实际上返回的是key集合的代理publicKeys和就绪key集合的代理publicSelectedKeys。
     select方法的3中操作形式,实际上委托给为lockAndDoSelect方法,方法实际上是同步的,可安全访问,获取key集合代理publicKeys和就绪key代理集合publicSelectedKeys,然后交给doSelect(long l)方法,这个方法为抽象方法,待子类扩展。实际的关闭选择器操作implCloseSelector方法,首先唤醒等待选择操作的线程,唤醒方法wakeup待实现,同步选择器,就绪key和key集合的代理publicKeys,publicSelectedKeys,调用implClose完成实际的关闭通道工作,待子类实现。
     可选通道注册方法,首先注册的通道必须是AbstractSelectableChannel类型,并且是SelChImpl实例。更具可选择通道和选择器构造选择key,设置选择key的附加物,同步key集合代理,调用implRegister方法完成实际的注册工作,implRegister方法待子类实现。
     processDeregisterQueue方法,主要是遍历取消key集合,反注册取消key,实际的反注册工作由implDereg方法,implDereg方法待子类扩展。成功,则从集合中移除。


附:这部分只作为扩展,没有特别的解析,设计,只是贴出代码,有兴趣可以看一下
//VM
package sun.misc;

import java.util.Properties;

// Referenced classes of package sun.misc:
//            OSEnvironment, VMNotification

public class VM
{ 
     private static boolean suspended = false;
    /**
     * @deprecated Field STATE_GREEN is deprecated
     */
    public static final int STATE_GREEN = 1;
    /**
     * @deprecated Field STATE_YELLOW is deprecated
     */
    public static final int STATE_YELLOW = 2;
    /**
     * @deprecated Field STATE_RED is deprecated
     */
    public static final int STATE_RED = 3;
    private static volatile boolean booted = false;
    private static long directMemory = 67108864L;
    private static boolean pageAlignDirectMemory;
    private static boolean defaultAllowArraySyntax;
    private static boolean allowArraySyntax;
    private static final Properties savedProps = new Properties();
    private static volatile int finalRefCount = 0;
    private static volatile int peakFinalRefCount = 0;
    private static final int JVMTI_THREAD_STATE_ALIVE = 1;
    private static final int JVMTI_THREAD_STATE_TERMINATED = 2;
    private static final int JVMTI_THREAD_STATE_RUNNABLE = 4;
    private static final int JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER = 1024;
    private static final int JVMTI_THREAD_STATE_WAITING_INDEFINITELY = 16;
    private static final int JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT = 32;
    static 
    {
        defaultAllowArraySyntax = false;
        allowArraySyntax = defaultAllowArraySyntax;
        initialize();
    }
    public VM()
    {
    } 
    private static native void initialize();
     public static void booted()
    {
        booted = true;
    }
    public static boolean isBooted()
    {
        return booted;
    }
    public static long maxDirectMemory()
    {
        return directMemory;
    }
    public static boolean isDirectMemoryPageAligned()
    {
        return pageAlignDirectMemory;
    }
     public static void initializeOSEnvironment()
    {
        if(!booted)
            OSEnvironment.initialize();
    }
    public static int getFinalRefCount()
    {
        return finalRefCount;
    }
    public static int getPeakFinalRefCount()
    {
        return peakFinalRefCount;
    }
    public static void addFinalRefCount(int i)
    {
        finalRefCount += i;
        if(finalRefCount > peakFinalRefCount)
            peakFinalRefCount = finalRefCount;
    }
    public static Thread.State toThreadState(int i)
    {
        if((i & 4) != 0)
            return Thread.State.RUNNABLE;
        if((i & 1024) != 0)
            return Thread.State.BLOCKED;
        if((i & 16) != 0)
            return Thread.State.WAITING;
        if((i & 32) != 0)
            return Thread.State.TIMED_WAITING;
        if((i & 2) != 0)
            return Thread.State.TERMINATED;
        if((i & 1) == 0)
            return Thread.State.NEW;
        else
            return Thread.State.RUNNABLE;
    }
    public static boolean allowArraySyntax()
    {
        return allowArraySyntax;
    }
    /**
     * @deprecated Method threadsSuspended is deprecated
     */
    public static boolean threadsSuspended()
    {
        return suspended;
    }
    public static boolean allowThreadSuspension(ThreadGroup threadgroup, boolean flag)
    {
        return threadgroup.allowThreadSuspension(flag);
    }
    /**
     * @deprecated Method suspendThreads is deprecated
     */
    public static boolean suspendThreads()
    {
        suspended = true;
        return true;
    }
    /**
     * @deprecated Method unsuspendThreads is deprecated
     */
    public static void unsuspendThreads()
    {
        suspended = false;
    }
    /**
     * @deprecated Method unsuspendSomeThreads is deprecated
     */
    public static void unsuspendSomeThreads()
    {
    }
    /**
     * @deprecated Method getState is deprecated
     */
    public static final int getState()
    {
        return 1;
    }
    /**
     * @deprecated Method registerVMNotification is deprecated
     */
    public static void registerVMNotification(VMNotification vmnotification)
    {
    
    /**
     * @deprecated Method asChange is deprecated
     */
    public static void asChange(int i, int j)
    {
    }
    /**
     * @deprecated Method asChange_otherthread is deprecated
     */
    public static void asChange_otherthread(int i, int j)
    {
    }
    public static String getSavedProperty(String s)
    {
        if(savedProps.isEmpty())
            throw new IllegalStateException("Should be non-empty if initialized");
        else
            return savedProps.getProperty(s);
    }
    public static void saveAndRemoveProperties(Properties properties)
    {
        if(booted)
            throw new IllegalStateException("System initialization has completed");
        savedProps.putAll(properties);
        String s = (String)properties.remove("sun.nio.MaxDirectMemorySize");
        if(s != null)
            if(s.equals("-1"))
            {
                directMemory = Runtime.getRuntime().maxMemory();
            } else
            {
                long l = Long.parseLong(s);
                if(l > -1L)
                    directMemory = l;
            }
        s = (String)properties.remove("sun.nio.PageAlignDirectMemory");
        if("true".equals(s))
            pageAlignDirectMemory = true;
        s = properties.getProperty("sun.lang.ClassLoader.allowArraySyntax");
        allowArraySyntax = s != null ? Boolean.parseBoolean(s) : defaultAllowArraySyntax;
        properties.remove("java.lang.Integer.IntegerCache.high");
        properties.remove("sun.zip.disableMemoryMapping");
        properties.remove("sun.java.launcher.diag");
    }
}




在代码中经常看到这个语句JVM INSTR monitorenter ;来看一下JVM:
只贴出源码,暂时放在这以后再啃。
class JVM
{
    JVM()
    {
    }
    static long activate(String s, DTraceProvider adtraceprovider[])
    {
        return activate0(s, adtraceprovider);
    }
    static void dispose(long l)
    {
        dispose0(l);
    }
    static boolean isEnabled(Method method)
    {
        return isEnabled0(method);
    }
    static boolean isSupported()
    {
        return isSupported0();
    }
    static Class defineClass(ClassLoader classloader, String s, byte abyte0[], int i, int j)
    {
        return defineClass0(classloader, s, abyte0, i, j);
    }
    private static native long activate0(String s, DTraceProvider adtraceprovider[]);
    private static native void dispose0(long l);
    private static native boolean isEnabled0(Method method);
    private static native boolean isSupported0();
    private static native Class defineClass0(ClassLoader classloader, String s, byte abyte0[], int i, int j);
    static 
    {
        AccessController.doPrivileged(new LoadLibraryAction("jsdt"));
    }
}

来看这一句:
 static 
    {
        AccessController.doPrivileged(new LoadLibraryAction("jsdt"));
    }

jsdt:JavaScript Development Tools (JSDT):
http://www.eclipse.org/webtools/jsdt/
//LoadLibraryAction
package sun.security.action;
import java.security.PrivilegedAction;
public class LoadLibraryAction
    implements PrivilegedAction
{

    public LoadLibraryAction(String s)
    {
        theLib = s;
    }

    public Void run()
    {

       //系统加载lib库
        System.loadLibrary(theLib);
        return null;
    }

    public volatile Object run()
    {
        return run();
    }

    private String theLib;
}

//System
/**
     * Loads the system library specified by the <code>libname</code>
     * argument. The manner in which a library name is mapped to the
     * actual system library is system dependent.
     * <p>
     * The call <code>System.loadLibrary(name)</code> is effectively
     * equivalent to the call
     * <blockquote><pre>
     * Runtime.getRuntime().loadLibrary(name)
     * </pre></blockquote>
     *
     * @param      libname   the name of the library.
     * @exception  SecurityException  if a security manager exists and its
     *             <code>checkLink</code> method doesn't allow
     *             loading of the specified dynamic library
     * @exception  UnsatisfiedLinkError  if the library does not exist.
     * @exception  NullPointerException if <code>libname</code> is
     *             <code>null</code>
     * @see        java.lang.Runtime#loadLibrary(java.lang.String)
     * @see        java.lang.SecurityManager#checkLink(java.lang.String)
     */
    public static void loadLibrary(String libname) {
        Runtime.getRuntime().loadLibrary0(getCallerClass(), libname);
    }








//Runtime
synchronized void loadLibrary0(Class fromClass, String libname) {
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkLink(libname);
        }
        if (libname.indexOf((int)File.separatorChar) != -1) {
            throw new UnsatisfiedLinkError(
    "Directory separator should not appear in library name: " + libname);
        }
        ClassLoader.loadLibrary(fromClass, libname, false);
    }





//ClassLoader
// Invoked in the java.lang.Runtime class to implement load and loadLibrary.
    static void loadLibrary(Class fromClass, String name,
                            boolean isAbsolute) {
        ClassLoader loader =
            (fromClass == null) ? null : fromClass.getClassLoader();
        if (sys_paths == null) {
            usr_paths = initializePath("java.library.path");
            sys_paths = initializePath("sun.boot.library.path");
        }
        if (isAbsolute) {
            if (loadLibrary0(fromClass, new File(name))) {
                return;
            }
            throw new UnsatisfiedLinkError("Can't load library: " + name);
        }
        if (loader != null) {
            String libfilename = loader.findLibrary(name);
            if (libfilename != null) {
                File libfile = new File(libfilename);
                if (!libfile.isAbsolute()) {
                    throw new UnsatisfiedLinkError(
    "ClassLoader.findLibrary failed to return an absolute path: " + libfilename);
                }
                if (loadLibrary0(fromClass, libfile)) {
                    return;
                }
                throw new UnsatisfiedLinkError("Can't load " + libfilename);
            }
        }
        for (int i = 0 ; i < sys_paths.length ; i++) {
            File libfile = new File(sys_paths[i], System.mapLibraryName(name));
            if (loadLibrary0(fromClass, libfile)) {
                return;
            }
        }
        if (loader != null) {
            for (int i = 0 ; i < usr_paths.length ; i++) {
                File libfile = new File(usr_paths[i],
                                        System.mapLibraryName(name));
                if (loadLibrary0(fromClass, libfile)) {
                    return;
                }
            }
        }
        // Oops, it failed
        throw new UnsatisfiedLinkError("no " + name + " in java.library.path");
    }









  • 大小: 60.7 KB
  • 大小: 38.5 KB
  • 大小: 54 KB
  • 大小: 31.1 KB
  • 大小: 10.8 KB
  • 大小: 44.9 KB
  • 大小: 60 KB
  • 大小: 54.9 KB
  • 大小: 64.1 KB
1
0
分享到:
评论

相关推荐

    Java NIO——Selector机制解析三(源码分析)

    Java NIO的Selector实现主要由`sun.nio.ch.SelectorImpl`类完成,其内部使用了操作系统提供的多路复用I/O机制,如Linux的epoll、Windows的IOCP等。`select()`方法实际上会调用操作系统API,阻塞等待直到有事件发生。...

    (源码)基于C语言的SmartPlugModbus固件项目.zip

    # 基于C语言的SmartPlugModbus固件项目 ## 项目简介 该项目是一个基于C语言的固件项目,旨在实现一个支持Modbus RTU通信协议的智能设备固件。该固件被设计为与SmartPlugModbus设备配合使用,用于控制和管理多个电源插座,提供过流、欠流、过压、欠压和过热保护,同时监控插座状态和电压、电流等参数。 ## 项目的主要特性和功能 1. Modbus RTU通信协议支持固件实现了Modbus RTU通信协议,允许通过Modbus协议与设备进行通信,包括读取和写入设备参数、状态和控制命令。 2. 多插座控制固件支持控制多个电源插座,包括开启、关闭、查询状态等。 3. 保护功能设备提供过流、欠流、过压、欠压和过热保护,防止设备损坏和安全事故。 4. 参数配置通过Modbus协议,用户可以配置设备的保护参数,如电流、电压限制等。

    毕设单片机实战项目基于ESP8266 Mesh SDK开发,通过HSPI与STM32通讯.zip

    【项目资源】: 单片机项目适用于从基础到高级的各种项目,特别是在性能要求较高的场景中,比如操作系统开发、嵌入式编程和底层系统编程。如果您是初学者,可以从简单的控制台程序开始练习;如果是进阶开发者,可以尝试涉及硬件或网络的项目。 【项目质量】: 所有源码都经过严格测试,可以直接运行。 功能在确认正常工作后才上传。 【适用人群】: 适用于希望学习不同技术领域的小白或进阶学习者。 可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【附加价值】: 项目具有较高的学习借鉴价值,也可直接拿来修改复刻。 对于有一定基础或热衷于研究的人来说,可以在这些基础代码上进行修改和扩展,实现其他功能。 【沟通交流】: 有任何使用上的问题,欢迎随时与博主沟通,博主会及时解答。 鼓励下载和使用,并欢迎大家互相学习,共同进步。 # 注意 1. 本资源仅用于开源学习和技术交流。不可商用等,一切后果由使用者承担。 2. 部分字体以及插图等来自网络,若是侵权请联系删除。

    毕业设计物联网实战项目基于龙芯派的物联网食品仓储监测系统.zip

    【项目资源】: 物联网项目适用于从基础到高级的各种项目,特别是在性能要求较高的场景中,比如操作系统开发、嵌入式编程和底层系统编程。如果您是初学者,可以从简单的控制台程序开始练习;如果是进阶开发者,可以尝试涉及硬件或网络的项目。 【项目质量】: 所有源码都经过严格测试,可以直接运行。 功能在确认正常工作后才上传。 【适用人群】: 适用于希望学习不同技术领域的小白或进阶学习者。 可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【附加价值】: 项目具有较高的学习借鉴价值,也可直接拿来修改复刻。 对于有一定基础或热衷于研究的人来说,可以在这些基础代码上进行修改和扩展,实现其他功能。 【沟通交流】: 有任何使用上的问题,欢迎随时与博主沟通,博主会及时解答。 鼓励下载和使用,并欢迎大家互相学习,共同进步。 # 注意 1. 本资源仅用于开源学习和技术交流。不可商用等,一切后果由使用者承担。 2. 部分字体以及插图等来自网络,若是侵权请联系删除。

    (源码)基于嵌入式系统的StackAttack游戏项目.zip

    # 基于嵌入式系统的StackAttack游戏项目 ## 项目简介 StackAttack是一个基于嵌入式系统的游戏项目,设计用于SPI TFT彩色液晶显示面板上运行。游戏的核心玩法是操控一个名为“Claw”(爪子)的游戏角色,在由格子组成的地图上移动并抓取箱子。玩家通过操纵杆控制游戏角色,成功抓取并移动箱子到目标位置后得分。游戏地图由二维数组表示,每个格子代表一个位置。当玩家成功将所有箱子移动到目标行时,游戏结束。 ## 项目的主要特性和功能 1. 游戏角色控制玩家通过操纵杆控制Claw(爪子)角色移动。 2. 地图和箱子管理游戏地图由二维数组表示,每个格子代表一个位置。箱子在游戏地图上的位置由数组中的值表示。 3. 游戏逻辑包括角色的移动、箱子的抓取和移动、得分计算等。 4. 图形显示使用SPITFTILI9341图形库控制SPI TFT显示屏,实现游戏的图形输出。 5. 暂停功能游戏支持暂停功能,方便玩家随时暂停游戏。

    【嵌入式系统与计算机视觉】基于STM32、OpenCV和CNN的车牌识别系统:社区车辆管理与收费应用

    内容概要:本文档提供了基于STM32、OpenCV和卷积神经网络的车牌识别系统的完整代码示例。系统通过摄像头捕捉视频流,利用OpenCV进行图像处理(如灰度化、二值化、轮廓检测等)以定位车牌区域,并使用预训练的ONNX模型对车牌字符进行识别。之后,系统将识别到的车牌号与预先存储在CSV文件中的居民车牌数据库进行匹配,以判断车辆是否为小区居民所有,从而实现对外来车辆的收费管理。; 适合人群:对嵌入式系统开发、计算机视觉和深度学习感兴趣的开发者,尤其是有一定C++编程基础和技术背景的研究人员或工程师。; 使用场景及目标:①适用于社区、停车场等场所的车辆管理;②帮助开发者理解车牌识别的基本流程,包括图像预处理、车牌定位、字符识别以及与数据库的交互;③提供一个可扩展的基础框架,便于后续优化和功能增加。; 阅读建议:读者应确保具备基本的OpenCV库使用经验和C++编程能力。在学习过程中,建议同时参考相关文献资料,深入理解每个步骤背后的原理,并尝试调整参数或替换模型以提高识别精度。此外,还需准备相应的硬件设备(如摄像头)和软件环境(如安装OpenCV库),以便实际运行代码并观察效果。

    fregefffewfw

    efwfw

    基于S7-200 PLC与MCGS组态的智能交通灯控制系统设计与实现

    内容概要:本文详细介绍了利用西门子S7-200 PLC和MCGS组态软件构建智能交通灯控制系统的方法。首先阐述了系统的硬件配置,包括PLC的选择、IO分配、光电开关的应用等。接着深入探讨了梯形图编程的核心逻辑,如定时器嵌套、车流判断、紧急模式处理等。同时,还讲解了MCGS组态界面的设计要点,如动态指示灯、车流统计曲线、急停按钮等功能的实现。此外,文中分享了一些调试经验和优化技巧,如信号隔离、通信参数设置、夜间模式优化等。 适合人群:对PLC编程和工业自动化感兴趣的工程技术人员、高校相关专业学生。 使用场景及目标:适用于城市交通管理部门进行智能交通灯系统的规划与实施,旨在提高交通效率,减少拥堵。通过学习本文,读者能够掌握PLC编程的基本方法和MCGS组态软件的使用技巧。 其他说明:文中提供了详细的接线图、梯形图代码片段和组态界面截图,便于读者理解和实践。同时,作者还分享了许多实际操作中的注意事项和经验教训,有助于初学者少走弯路。

    毕业设计物联网实战项目基于物联网的气象台站系统.zip

    【项目资源】: 物联网项目适用于从基础到高级的各种项目,特别是在性能要求较高的场景中,比如操作系统开发、嵌入式编程和底层系统编程。如果您是初学者,可以从简单的控制台程序开始练习;如果是进阶开发者,可以尝试涉及硬件或网络的项目。 【项目质量】: 所有源码都经过严格测试,可以直接运行。 功能在确认正常工作后才上传。 【适用人群】: 适用于希望学习不同技术领域的小白或进阶学习者。 可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【附加价值】: 项目具有较高的学习借鉴价值,也可直接拿来修改复刻。 对于有一定基础或热衷于研究的人来说,可以在这些基础代码上进行修改和扩展,实现其他功能。 【沟通交流】: 有任何使用上的问题,欢迎随时与博主沟通,博主会及时解答。 鼓励下载和使用,并欢迎大家互相学习,共同进步。 # 注意 1. 本资源仅用于开源学习和技术交流。不可商用等,一切后果由使用者承担。 2. 部分字体以及插图等来自网络,若是侵权请联系删除。

    VB珠宝首饰店管理系统设计(源代码+系统+开题报告+答辩PPT).zip

    摘 要 面对信息时代的机遇与挑战,利用高科技手段来提高企业的管理水平无疑是一条行之有效的途径。利用计算机管理可以最大限度的发挥准确、快捷、高效等作用, 在越来越激烈的珠宝行业中,计算机管理技术对珠宝首饰公司的服务管理提供强有力的支持。因此,利用全新的计算机网络和珠宝首饰管理系统,已成为提高珠宝首饰公司的管理效率,改进服务水准的重要手段之一。本系统应用Visual Basic 6.0 中文版开发前台,用Microsoft Access 作后台服务器,采用客户机/服务器(C/S)管理思想来对珠宝首饰进销存管理。 关键词:管理水平, 管理效率,服务水准,珠宝首饰管理系统,客户机/服务器,管理思想

    稀疏分解方法在信号去噪中的应用研究_内含源码数据论文.zip

    稀疏分解方法在信号去噪中的应用研究_内含源码数据论文.zip

    2008年领导力发展年度报告

    本书由吉姆·诺埃尔和大卫·多蒂奇编辑,旨在探讨领导力发展领域的最新趋势和实践。书中不仅提供了领导力发展领域的历史回顾,还挑战了组织对领导力发展的战略视角,详细介绍了如何培养全球领导者,并提供了关于领导力发展方法、策略和系统、高潜力人才发展、高层管理参与、有效学习方法以及领导力指标等方面的深入案例研究和理论分析。此外,书中还探讨了创新的领导力发展方法,并对未来的发展趋势进行了展望。

    一种基于 QR 二维码的彩色二维码编码译码设计及其软件实现.zip

    一种基于 QR 二维码的彩色二维码编码译码设计及其软件实现.zip

    毕设单片机实战项目基于机智云和 esp8266-12F WIFI 模块的智能插座控制安卓APP.zip

    【项目资源】: 单片机项目适用于从基础到高级的各种项目,特别是在性能要求较高的场景中,比如操作系统开发、嵌入式编程和底层系统编程。如果您是初学者,可以从简单的控制台程序开始练习;如果是进阶开发者,可以尝试涉及硬件或网络的项目。 【项目质量】: 所有源码都经过严格测试,可以直接运行。 功能在确认正常工作后才上传。 【适用人群】: 适用于希望学习不同技术领域的小白或进阶学习者。 可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【附加价值】: 项目具有较高的学习借鉴价值,也可直接拿来修改复刻。 对于有一定基础或热衷于研究的人来说,可以在这些基础代码上进行修改和扩展,实现其他功能。 【沟通交流】: 有任何使用上的问题,欢迎随时与博主沟通,博主会及时解答。 鼓励下载和使用,并欢迎大家互相学习,共同进步。 # 注意 1. 本资源仅用于开源学习和技术交流。不可商用等,一切后果由使用者承担。 2. 部分字体以及插图等来自网络,若是侵权请联系删除。

    毕业设计物联网实战项目基于mqttd-centos7-v2.3.11.zip 配置的emqtt服务器,配套金大万翔物联网管理平台.zip

    【项目资源】: 物联网项目适用于从基础到高级的各种项目,特别是在性能要求较高的场景中,比如操作系统开发、嵌入式编程和底层系统编程。如果您是初学者,可以从简单的控制台程序开始练习;如果是进阶开发者,可以尝试涉及硬件或网络的项目。 【项目质量】: 所有源码都经过严格测试,可以直接运行。 功能在确认正常工作后才上传。 【适用人群】: 适用于希望学习不同技术领域的小白或进阶学习者。 可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【附加价值】: 项目具有较高的学习借鉴价值,也可直接拿来修改复刻。 对于有一定基础或热衷于研究的人来说,可以在这些基础代码上进行修改和扩展,实现其他功能。 【沟通交流】: 有任何使用上的问题,欢迎随时与博主沟通,博主会及时解答。 鼓励下载和使用,并欢迎大家互相学习,共同进步。 # 注意 1. 本资源仅用于开源学习和技术交流。不可商用等,一切后果由使用者承担。 2. 部分字体以及插图等来自网络,若是侵权请联系删除。

    【光子晶体模拟】基于COMSOL弱形式PDE的三维光子晶体能带结构计算与优化:电磁场切向连续性处理及带隙分析系统设计使用COMSOL

    内容概要:本文详细介绍了使用COMSOL Multiphysics的弱形式接口对三维光子晶体进行数值模拟的方法和技巧。文章通过具体的代码示例,解释了如何构建光子晶体的介电常数分布、设置弱形式PDE、处理电磁场切向连续性、应用Floquet周期边界条件以及特征值求解等关键步骤。特别强调了弱形式接口相比传统物理场接口的优势,如灵活性和对复杂边界的处理能力。文中还分享了一些实用的经验和注意事项,如布洛赫边界条件的实现、特征值求解器参数的优化配置以及网格划分的技巧。 适合人群:具备一定电磁学和数值模拟基础的研究人员或工程师,尤其是对光子晶体仿真感兴趣的读者。 使用场景及目标:①理解并掌握COMSOL弱形式接口在光子晶体仿真中的应用;②学习如何通过弱形式设置处理复杂的电磁场问题;③提高对光子晶体能带结构和带隙特性的认识;④掌握特征值求解和网格划分的最佳实践。 阅读建议:由于本文涉及较多的具体代码和物理概念,建议读者在阅读过程中结合COMSOL软件进行实际操作,同时查阅相关电磁理论书籍以加深理解。此外,对于文中提到的一些具体参数设置和技巧,可以通过尝试不同的配置来巩固所学知识。

    机械工程PT5000汽轮机滑动轴承系统模拟试验台:动态行为与振动控制研究

    内容概要:PT5000汽轮机滑动轴承系统模拟试验台是一个类似于电厂汽轮机发电机的缩小模型,旨在帮助用户获取汽轮机转子动态行为和滑动轴承油膜现象的实际经验,并研究振动控制方法。该试验台模拟两级涡轮机(低压和中压),每级转子两侧各有8个叶片,共计16个叶片。通过电机驱动而非涡轮发电机,可以进行启停机测试,识别共振现象。试验台还支持多种实验,如不平衡/现场动平衡、轴不对中实验、摩擦实验、油膜故障试验、轴颈轴承实验以及根据油压和温度进行的转子动力学试验。试验台配备了多种传感器和控制系统,包括电涡流传感器、温度传感器、压力传感器等,用于监测和记录实验数据。 适合人群:从事汽轮机设计、制造、维护的技术人员,以及相关专业的高校师生和研究人员。 使用场景及目标:①研究汽轮机转子的动态行为和滑动轴承的油膜现象;②进行振动控制方法的研究;③模拟再现油膜涡动转和油膜震荡,研究其控制条件;④进行不平衡、不对中、摩擦等常见故障的模拟和分析;⑤通过调整油压、温度和预加载力,研究轴的行为变化。 其他说明:该试验台不仅适用于教学和科研,还可用于工业领域的培训和技术验证。试验台具有丰富的配置和可选配件,可以根据具体需求进行定制。试验台的机械和电气参数详细列出,确保用户能够全面了解设备性能。

    知识图谱,电影领域,知识图谱构建

    电影类型知识图谱构建,包含相关数据集

    (源码)基于C++的Minimal BASIC解释器.zip

    # 基于C++的Minimal BASIC解释器 ## 项目简介 本项目是一个C++实现的Minimal BASIC解释器。该解释器能够解释并执行一些基本的BASIC语言命令,如赋值、打印、输入、条件跳转等。用户可以通过命令行交互地输入命令,或者编写一个按行数升序依次运行的大程序。 ## 项目的主要特性和功能 1. 解释执行能够解释并执行简单的BASIC语言命令。 2. 变量定义与赋值支持定义变量并为其赋值。 3. 打印输出支持将表达式的值打印到控制台。 4. 输入支持从用户获取输入值并赋值给变量。 5. 条件跳转支持基于条件的跳转语句。 6. 注释支持注释语句,使程序更加易读。 ## 安装使用步骤 1. 准备环境确保你的开发环境已经安装了C++编译器,如GCC。 3. 编译使用CMake工具编译源代码。 4. 运行编译成功后,运行可执行文件,即可与解释器交互。 ## 注意事项

    自适应神经进化编程解决暂态稳定性最优潮流问题

    本文提出了一种结合自适应进化编程(AEP)与神经网络的方法,用于解决暂态稳定性约束最优潮流(TSCOPF)问题。AEP在优化过程中能够自动调整种群大小,以获得TSCOPF问题的解决方案。神经网络的嵌入能够降低由暂态稳定性约束引起的计算负担。文章通过在IEEE 30节点系统上测试,使用两种不同的燃料成本函数,验证了AEP方法在搜索全局解方面的有效性,并且当结合神经网络后,显著提高了计算速度。此外,本文还对神经网络的架构进行了研究和讨论。

Global site tag (gtag.js) - Google Analytics