文件通道创建方式综述

最新推荐文章于 2022-02-02 12:43:06 发布
最新推荐文章于 2022-02-02 12:43:06 发布
阅读量224 收藏
点赞数
分类专栏： NIO 文章标签： nio
Reference定义（PhantomReference，Cleaner）:[url]http://donald-draper.iteye.com/blog/2371661[/url]
FileChanne定义：[url]http://donald-draper.iteye.com/blog/2374149[/url]
文件读写方式简单综述:[url]http://donald-draper.iteye.com/blog/2374237[/url]
文件读写方式简单综述后续（文件，流构造）:[url]http://donald-draper.iteye.com/blog/2374294[/url]
在看了FileChanne定义后，为了更好了理解FileChanne，我们简单的看了文件File，路径Path ，文件系统FileSystem，文件系统提供者FileSystemProvider。我们先回顾下相关概念：
File内部关联一个文件系统FileSystem，用于操作底层的系统，file的文件分隔符和路径分隔符都是从FileSystem获取，windows（\\,;）和unix(\,:)有所不同，FileSystem根据底层操作获取不同文件系统实现，windows默认为Win32FileSystem。file的创建，删除，list当前目录文件等待操作，实际是委托给Win32FileSystem。获取文件Path，首先获取文件的默认文件系统提供者，默认为WindowsFileSystemProvider，WindowsFileSystemProvider通过文件path（URI），创建文件Path（WindowsPath），这个主要用于创建文件通达需要。
今天我们来看一下通道的具体实现，从获取通道开始，获取通道有4中方法：
1.从FileOutputStream获取可写不可读文件通道
//FileOutputStream 
 public FileChannel getChannel() {
        synchronized (this) {
            if (channel == null) {
	        //可写不可读
                channel = FileChannelImpl.open(fd, false, true, append, this);

                /*
                 * Increment fd's use count. Invoking the channel's close()
                 * method will result in decrementing the use count set for
                 * the channel.
                 */
                fd.incrementAndGetUseCount();
            }
            return channel;
        }
    }

2.从FileInputStream获取可读不可写文件通道
//FileInputStream 
public FileChannel getChannel() {
        synchronized (this) {
            if (channel == null) {
	        //可读不可写
                channel = FileChannelImpl.open(fd, true, false, this);

                /*
                 * Increment fd's use count. Invoking the channel's close()
                 * method will result in decrementing the use count set for
                 * the channel.
                 */
                fd.incrementAndGetUseCount();
            }
            return channel;
        }
    }

3.从RandomAccessFile获取可读可写文件通道
//RandomAccessFile 
public class RandomAccessFile implements DataOutput, DataInput, Closeable {

    private FileDescriptor fd;
    private FileChannel channel = null;
    private boolean rw;//是否读写

    private Object closeLock = new Object();
    private volatile boolean closed = false;

    private static final int O_RDONLY = 1;
    private static final int O_RDWR =   2;
    private static final int O_SYNC =   4;
    private static final int O_DSYNC =  8;
 /* @since 1.4
  * @spec JSR-51
  */
 public final FileChannel getChannel() {
     synchronized (this) {
         if (channel == null) {
	     //默认可读，在根据rw判断是否可写
             channel = FileChannelImpl.open(fd, true, rw, this);

             /*
              * FileDescriptor could be shared by FileInputStream or
              * FileOutputStream.
              * Ensure that FD is GC'ed only when all the streams/channels
              * are done using it.
              * Increment fd's use count. Invoking the channel's close()
              * method will result in decrementing the use count set for
              * the channel.
              */
             fd.incrementAndGetUseCount();
         }
         return channel;
     }
 }
 ...
 }

//FileChannelImpl 
  public static FileChannel open(FileDescriptor filedescriptor, boolean flag, boolean flag1, Object obj)
    {
        return new FileChannelImpl(filedescriptor, flag, flag1, false, obj);
    }
    public static FileChannel open(FileDescriptor filedescriptor, boolean flag, boolean flag1, boolean flag2, Object obj)
    {
        return new FileChannelImpl(filedescriptor, flag, flag1, flag2, obj);
    }
    private FileChannelImpl(FileDescriptor filedescriptor, boolean flag, boolean flag1, boolean flag2, Object obj)
    {
        fd = filedescriptor;
        readable = flag;//可读标志
        writable = flag1;//可写标志
        append = flag2;//是否尾部追加文件，默认为fasle
	//创建文件通道的对象，为FileInput/OutputStream，
	//RandomAccessFile获取FileSystemProvider(WindowsFileSystemProvider)
        parent = obj;
        nd = new FileDispatcherImpl(flag2);
    }

4.从文件系统提供者获取文件通道(FileChannel#open)
//FileChannel 
//根据文件Path和打开选项创建文件通道
public static FileChannel open(Path path, OpenOption... options)
        throws IOException
    {
        Set<OpenOption> set = new HashSet<OpenOption>(options.length);
        Collections.addAll(set, options);
	//委托给 FileChannel open(Path path, Set<? extends OpenOption> options,FileAttribute<?>... attrs)
        return open(path, set, NO_ATTRIBUTES);
    }
//根据文件Path，打开选项，及文件属性创建文件通道
public static FileChannel open(Path path,
                                   Set<? extends OpenOption> options,
                                   FileAttribute<?>... attrs)
        throws IOException
    {
        //这一步我们在前面一篇文章已讲，文件系统提供者为WindowsFileSystemProvider
        FileSystemProvider provider = path.getFileSystem().provider();
        return provider.newFileChannel(path, options, attrs);
    }

//WindowsFileSystemProvider 
public transient FileChannel newFileChannel(Path path, Set set, FileAttribute afileattribute[])
        throws IOException
    {
        WindowsPath windowspath;//文件Path
        WindowsSecurityDescriptor windowssecuritydescriptor;//文件属性描述
        if(path == null)
            throw new NullPointerException();
        if(!(path instanceof WindowsPath))
            throw new ProviderMismatchException();
        windowspath = (WindowsPath)path;
        windowssecuritydescriptor = WindowsSecurityDescriptor.fromAttribute(afileattribute);
	我们需要关注的是这一点
        FileChannel filechannel = WindowsChannelFactory.newFileChannel(windowspath.getPathForWin32Calls(), windowspath.getPathForPermissionCheck(), set, windowssecuritydescriptor.address());
        if(windowssecuritydescriptor != null)
            windowssecuritydescriptor.release();
        return filechannel;
        ...
        windowsexception.rethrowAsIOException(windowspath);
        ...
        Exception exception;
        exception;
        if(windowssecuritydescriptor != null)
            windowssecuritydescriptor.release();
        throw exception;
    }

再来看WindowsChannelFactory创建文件通道： 
class WindowsChannelFactory
{
    private static final JavaIOFileDescriptorAccess fdAccess = SharedSecrets.getJavaIOFileDescriptorAccess();
    static final OpenOption OPEN_REPARSE_POINT = new OpenOption() {};
    private WindowsChannelFactory()
    {
    }
    static FileChannel newFileChannel(String s, String s1, Set set, long l)
        throws WindowsException
    {
        //转换打开选项集为Flags
        Flags flags = Flags.toFlags(set);
        if(!flags.read && !flags.write)
            if(flags.append)
                flags.write = true;
            else
                flags.read = true;
        //可读可append，抛出选项配置错误
        if(flags.read && flags.append)
            throw new IllegalArgumentException("READ + APPEND not allowed");
	//可append，存在压缩抛出选项配置错误
        if(flags.append && flags.truncateExisting)
        {
            throw new IllegalArgumentException("APPEND + TRUNCATE_EXISTING not allowed");
        } else
        {
	    //创建文件描述符
            FileDescriptor filedescriptor = open(s, s1, flags, l);
	    //委托给FileChannelImpl
            return FileChannelImpl.open(filedescriptor, flags.read, flags.write, flags.append, null);
        }
    }
}

上述过程我们需要关注的有以下几点：
1. 
//转换打开选项集为Flags
Flags flags = Flags.toFlags(set);

2. 
//创建文件描述符
FileDescriptor filedescriptor = open(s, s1, flags, l);

3. 
 //委托给FileChannelImpl
return FileChannelImpl.open(filedescriptor, flags.read, flags.write, flags.append, null);

下面分别来看：
1. 
//转换打开选项集为Flags
Flags flags = Flags.toFlags(set);

//WindowsChannelFactory - Flags
 private static class Flags
    {
        boolean read;//是否可读
        boolean write;//是否可写
        boolean append;//追加文件
        boolean truncateExisting;//存在，则压缩
        boolean create;//文件不存在，则创建
        boolean createNew;//无论文件不在与否，创建文件
        boolean deleteOnClose;//关闭文件删除，可用于创建临时文件
        boolean sparse;//是否稀疏文件
        boolean overlapped;
        boolean sync;//同步文件更新（内容及元数据）到底层文件
        boolean dsync;同步文件更新（内容）到底层文件
        boolean shareRead;//共享读
        boolean shareWrite;//贡献写
        boolean shareDelete;//共享删除
        boolean noFollowLinks;
        boolean openReparsePoint;

        private Flags()
        {
            shareRead = true;
            shareWrite = true;
            shareDelete = true;
        }
	//将打开选项集转化为Flags
        static Flags toFlags(Set set)
        {

            Flags flags = new Flags();
	    //遍历打开选项集，转化选项配置为Flags对应的field
            for(Iterator iterator = set.iterator(); iterator.hasNext();)
            {
                OpenOption openoption = (OpenOption)iterator.next();
		//标准打开选项和拓展打开选项的配置转化类，将配置转化为Int，类型
                static class _cls2
                {

                    static final int $SwitchMap$java$nio$file$StandardOpenOption[];
                    static final int $SwitchMap$com$sun$nio$file$ExtendedOpenOption[];

                    static 
                    {
                        $SwitchMap$com$sun$nio$file$ExtendedOpenOption = new int[ExtendedOpenOption.values().length];
                        try
                        {
                            $SwitchMap$com$sun$nio$file$ExtendedOpenOption[ExtendedOpenOption.NOSHARE_READ.ordinal()] = 1;
                        }
                        catch(NoSuchFieldError nosuchfielderror) { }
                        try
                        {
                            $SwitchMap$com$sun$nio$file$ExtendedOpenOption[ExtendedOpenOption.NOSHARE_WRITE.ordinal()] = 2;
                        }
                        catch(NoSuchFieldError nosuchfielderror1) { }
                        try
                        {
                            $SwitchMap$com$sun$nio$file$ExtendedOpenOption[ExtendedOpenOption.NOSHARE_DELETE.ordinal()] = 3;
                        }
                        catch(NoSuchFieldError nosuchfielderror2) { }
                        $SwitchMap$java$nio$file$StandardOpenOption = new int[StandardOpenOption.values().length];
                        try
                        {
                            $SwitchMap$java$nio$file$StandardOpenOption[StandardOpenOption.READ.ordinal()] = 1;
                        }
                        catch(NoSuchFieldError nosuchfielderror3) { }
                        try
                        {
                            $SwitchMap$java$nio$file$StandardOpenOption[StandardOpenOption.WRITE.ordinal()] = 2;
                        }
                        catch(NoSuchFieldError nosuchfielderror4) { }
                        try
                        {
                            $SwitchMap$java$nio$file$StandardOpenOption[StandardOpenOption.APPEND.ordinal()] = 3;
                        }
                        catch(NoSuchFieldError nosuchfielderror5) { }
                        try
                        {
                            $SwitchMap$java$nio$file$StandardOpenOption[StandardOpenOption.TRUNCATE_EXISTING.ordinal()] = 4;
                        }
                        catch(NoSuchFieldError nosuchfielderror6) { }
                        try
                        {
                            $SwitchMap$java$nio$file$StandardOpenOption[StandardOpenOption.CREATE.ordinal()] = 5;
                        }
                        catch(NoSuchFieldError nosuchfielderror7) { }
                        try
                        {
                            $SwitchMap$java$nio$file$StandardOpenOption[StandardOpenOption.CREATE_NEW.ordinal()] = 6;
                        }
                        catch(NoSuchFieldError nosuchfielderror8) { }
                        try
                        {
                            $SwitchMap$java$nio$file$StandardOpenOption[StandardOpenOption.DELETE_ON_CLOSE.ordinal()] = 7;
                        }
                        catch(NoSuchFieldError nosuchfielderror9) { }
                        try
                        {
                            $SwitchMap$java$nio$file$StandardOpenOption[StandardOpenOption.SPARSE.ordinal()] = 8;
                        }
                        catch(NoSuchFieldError nosuchfielderror10) { }
                        try
                        {
                            $SwitchMap$java$nio$file$StandardOpenOption[StandardOpenOption.SYNC.ordinal()] = 9;
                        }
                        catch(NoSuchFieldError nosuchfielderror11) { }
                        try
                        {
                            $SwitchMap$java$nio$file$StandardOpenOption[StandardOpenOption.DSYNC.ordinal()] = 10;
                        }
                        catch(NoSuchFieldError nosuchfielderror12) { }
                    }
                }
               //标准打开选项
                if(openoption instanceof StandardOpenOption)
                    switch(_cls2..SwitchMap.java.nio.file.StandardOpenOption[((StandardOpenOption)openoption).ordinal()])
                    {
                    case 1: // '\001'
                        flags.read = true;
                        break;

                    case 2: // '\002'
                        flags.write = true;
                        break;

                    case 3: // '\003'
                        flags.append = true;
                        break;

                    case 4: // '\004'
                        flags.truncateExisting = true;
                        break;

                    case 5: // '\005'
                        flags.create = true;
                        break;

                    case 6: // '\006'
                        flags.createNew = true;
                        break;

                    case 7: // '\007'
                        flags.deleteOnClose = true;
                        break;

                    case 8: // '\b'
                        flags.sparse = true;
                        break;

                    case 9: // '\t'
                        flags.sync = true;
                        break;

                    case 10: // '\n'
                        flags.dsync = true;
                        break;

                    default:
                        throw new UnsupportedOperationException();
                    }
                else
		//拓展打开选项
                if(openoption instanceof ExtendedOpenOption)
                    switch(_cls2..SwitchMap.com.sun.nio.file.ExtendedOpenOption[((ExtendedOpenOption)openoption).ordinal()])
                    {
                    case 1: // '\001'
                        flags.shareRead = false;
                        break;

                    case 2: // '\002'
                        flags.shareWrite = false;
                        break;

                    case 3: // '\003'
                        flags.shareDelete = false;
                        break;

                    default:
                        throw new UnsupportedOperationException();
                    }
                else
                if(openoption == LinkOption.NOFOLLOW_LINKS)
                    flags.noFollowLinks = true;
                else
                if(openoption == WindowsChannelFactory.OPEN_REPARSE_POINT)
                    flags.openReparsePoint = true;
                else
                if(openoption == null)
                    throw new NullPointerException();
                else
                    throw new UnsupportedOperationException();
            }

            return flags;
        }
    }

2. 
//创建文件描述符
FileDescriptor filedescriptor = open(s, s1, flags, l);


private static FileDescriptor open(String s, String s1, Flags flags, long l)
        throws WindowsException
    {
        boolean flag = false;
        int i = 0;//标准配置项，读写配置
        if(flags.read)
            i |= -2147483648;
        if(flags.write)
            i |= 1073741824;
        int j = 0;//扩展配置项共享读写删除配置
        if(flags.shareRead)
            j |= 1;
        if(flags.shareWrite)
            j |= 2;
        if(flags.shareDelete)
            j |= 4;
        int k = 128;//记录createNew，create，truncateExisting，dsync，sync，overlapped，deleteOnClose
        byte byte0 = 3;
        if(flags.write)
            if(flags.createNew)
            {
                byte0 = 1;
                k |= 2097152;
            } else
            {
                if(flags.create)
                    byte0 = 4;
                if(flags.truncateExisting)
                    if(byte0 == 4)
                        flag = true;
                    else
                        byte0 = 5;
            }
        if(flags.dsync || flags.sync)
            k |= -2147483648;
        if(flags.overlapped)
            k |= 1073741824;
        if(flags.deleteOnClose)
            k |= 67108864;
        boolean flag1 = true;//记录noFollowLinks，openReparsePoint，deleteOnClose
        if(byte0 != 1 && (flags.noFollowLinks || flags.openReparsePoint || flags.deleteOnClose))
        {
            if(flags.noFollowLinks || flags.deleteOnClose)
                flag1 = false;
            k |= 2097152;
        }
        if(s1 != null)
        {
            SecurityManager securitymanager = System.getSecurityManager();
            if(securitymanager != null)
            {
	       //检查读写删除权限
                if(flags.read)
                    securitymanager.checkRead(s1);
                if(flags.write)
                    securitymanager.checkWrite(s1);
                if(flags.deleteOnClose)
                    securitymanager.checkDelete(s1);
            }
        }
	//创建文件
        long l1 = WindowsNativeDispatcher.CreateFile(s, i, j, l, byte0, k);
        ...
        FileDescriptor filedescriptor = new FileDescriptor();
	//设置文件描述的处理器
        fdAccess.setHandle(filedescriptor, l1);
        return filedescriptor;
    }

来看这一步的关键点： 
//创建文件
long l1 = WindowsNativeDispatcher.CreateFile(s, i, j, l, byte0, k);

//WindowsNativeDispatcher 
  static long CreateFile(String s, int i, int j, int k, int l)
        throws WindowsException
    {
        return CreateFile(s, i, j, 0L, k, l);
    }
static long CreateFile(String s, int i, int j, long l, int k, int i1)
        throws WindowsException
    {
        //将文件Path信息，放在本地buffer中
        NativeBuffer nativebuffer = asNativeBuffer(s);
        long l1 = CreateFile0(nativebuffer.address(), i, j, l, k, i1);
        //释放nativebuffer，放入线程本地缓存，以便重用
        nativebuffer.release();
        return l1;
        Exception exception;
        exception;
        nativebuffer.release();
        throw exception;
    }
 private static native long CreateFile0(long l, int i, int j, long l1, int k, int i1)
        throws WindowsException;

创建方法中我们还有两点要看
2.a 
//将文件Path信息，放在本地buffer中
 NativeBuffer nativebuffer = asNativeBuffer(s);

2.b 
 //释放nativebuffer，放入线程本地缓存，以便重用
 nativebuffer.release();

下面分别来看这两点：
再看这个之前先看一下NativeBuffer
//NativeBuffer 
class NativeBuffer
{
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private final long address;//内存地址
    private final int size;//内存size
    private final Cleaner cleaner;//清理器
    private Object owner;//buffer拥有者
    private static class Deallocator
        implements Runnable
    {

        public void run()
        {
	    //释放本地buffer空间
            NativeBuffer.unsafe.freeMemory(address);
        }

        private final long address;

        Deallocator(long l)
        {
            address = l;
        }
    }
    NativeBuffer(int i)
    {
        address = unsafe.allocateMemory(i);
        size = i;
        cleaner = Cleaner.create(this, new Deallocator(address));
    }
    void release()
    {
        NativeBuffers.releaseNativeBuffer(this);
    }
    long address()
    {
        return address;
    }
    int size()
    {
        return size;
    }
    Cleaner cleaner()
    {
        return cleaner;
    }
    void setOwner(Object obj)
    {
        owner = obj;
    }
    Object owner()
    {
        return owner;
    }
}


再回到刚才创建文件中的两点
2.a 
//将文件Path信息，放在本地buffer中
 NativeBuffer nativebuffer = asNativeBuffer(s);

//WindowsNativeDispatcher 
static NativeBuffer asNativeBuffer(String s)
    {
        int i = s.length() << 1;
        int j = i + 2;
	//从线程本地缓冲获取本地buffer
        NativeBuffer nativebuffer = NativeBuffers.getNativeBufferFromCache(j);
	//如果获取本地buffer为空，则创建一个
        if(nativebuffer == null)
            nativebuffer = NativeBuffers.allocNativeBuffer(j);
        else//不为null，检查本地buffer的拥有者，是则直接返回
        if(nativebuffer.owner() == s)
            return nativebuffer;
        char ac[] = s.toCharArray();
	//否则,拷贝buffer内存
        unsafe.copyMemory(ac, Unsafe.ARRAY_CHAR_BASE_OFFSET, null, nativebuffer.address(), i);
        unsafe.putChar(nativebuffer.address() + (long)i, '\0');
	//设置buffer的拥有者
        nativebuffer.setOwner(s);
        return nativebuffer;
    }

2.b 
//释放nativebuffer，放入线程本地缓存，以便重用
 nativebuffer.release();

//NativeBuffers 
void release()
    {
        //委托给NativeBuffers
        NativeBuffers.releaseNativeBuffer(this);
    }

从以上a,b两点,我们需要关注的是getNativeBufferFromCache，allocNativeBuffer，releaseNativeBuffer方法，
下面我们单独来看一下NativeBuffers 
class NativeBuffers
{
    private static native void initIDs();
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    static 
    {
        //在当前线程访问控制权限下，加载net和nio库
        AccessController.doPrivileged(new PrivilegedAction() {

            public Void run()
            {
                System.loadLibrary("net");
                System.loadLibrary("nio");
                return null;
            }

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

        });
        initIDs();
    }
    private NativeBuffers()
    {
    }
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final int TEMP_BUF_POOL_SIZE = 3;//临时buffer
    private static ThreadLocal threadLocal = new ThreadLocal();//存放线程本地buffer
    static final boolean $assertionsDisabled = !sun/nio/fs/NativeBuffers.desiredAssertionStatus();
    //从线程本地缓存获取NativeBuffer
     static NativeBuffer getNativeBufferFromCache(int i)
    {
        //从线程本地缓存获取NativeBuffer数组
        NativeBuffer anativebuffer[] = (NativeBuffer[])threadLocal.get();
        if(anativebuffer != null)
        {
            for(int j = 0; j < 3; j++)
            {
                NativeBuffer nativebuffer = anativebuffer[j];
                if(nativebuffer != null && nativebuffer.size() >= i)
                {
		    //返回线程本地缓存NativeBuffer数组中，第一个可用的NativeBuffer(容量大于i)，
		    //将NativeBuffer数组index索引对应的置null
                    anativebuffer[j] = null;
                    return nativebuffer;
                }
            }

        }
        return null;
    }
    //创建本地buffer
     static NativeBuffer allocNativeBuffer(int i)
    {
        if(i < 2048)
            i = 2048;
	//size最小为2M
        return new NativeBuffer(i);
    }
    //获取容量大于等于i的NativeBuffer
     static NativeBuffer getNativeBuffer(int i)
    {
       //从线程本地缓存获取NativeBuffer
        NativeBuffer nativebuffer = getNativeBufferFromCache(i);
        if(nativebuffer != null)
        {
	   //拥有者不为null，则置null
            nativebuffer.setOwner(null);
            return nativebuffer;
        } else
        {
	    //否则创建一个NativeBuffer
            return allocNativeBuffer(i);
        }
    }
    //将字节序列存放到NativeBuffer
     static NativeBuffer asNativeBuffer(byte abyte0[])
    {
        //从线程本地缓存获取NativeBuffer
        NativeBuffer nativebuffer = getNativeBuffer(abyte0.length + 1);
         //拷贝字符串到nativebuffer
        copyCStringToNativeBuffer(abyte0, nativebuffer);
        return nativebuffer;
    }
    //拷贝字符串到nativebuffer
     static void copyCStringToNativeBuffer(byte abyte0[], NativeBuffer nativebuffer)
    {
        long l = Unsafe.ARRAY_BYTE_BASE_OFFSET;
        long l1 = abyte0.length;
	//断言开启，断言nativebuffer容量是否够用，不够用，则抛AssertionError
        if(!$assertionsDisabled && (long)nativebuffer.size() < l1 + 1L)
        {
            throw new AssertionError();
        } else
        {
            unsafe.copyMemory(abyte0, l, null, nativebuffer.address(), l1);
            unsafe.putByte(nativebuffer.address() + l1, (byte)0);
            return;
        }
    }
    //释放nativebuffer
    static void releaseNativeBuffer(NativeBuffer nativebuffer)
    {
        //从线程本地缓存获取NativeBuffer数组
        NativeBuffer anativebuffer[] = (NativeBuffer[])threadLocal.get();
        if(anativebuffer == null)
        {
	    //如果数组为空，则创长度为3的NativeBuffer数组，并将nativebuffer放入缓存中
            anativebuffer = new NativeBuffer[3];
            anativebuffer[0] = nativebuffer;
	    //将NativeBuffer数组添加到线程本地缓存
            threadLocal.set(anativebuffer);
            return;
        }
	//NativeBuffer数组不为null
        for(int i = 0; i < 3; i++)
            if(anativebuffer[i] == null)
            {
	        //将nativebuffer放到线程本地缓冲NativeBuffer数组，
		//索引对应的NativeBuffer为null的位置上
                anativebuffer[i] = nativebuffer;
                return;
            }
        //如果NativeBuffer的元素没有为null的，则将nativebuffer放在第一个容量小于它的index上，
	//并释放小于nativebuffer的内存空间
        for(int j = 0; j < 3; j++)
        {
            NativeBuffer nativebuffer1 = anativebuffer[j];
	    //将
            if(nativebuffer1.size() < nativebuffer.size())
            {
                nativebuffer1.cleaner().clean();
                anativebuffer[j] = nativebuffer;
                return;
            }
        }
        //释放nativebuffer内存空间
        nativebuffer.cleaner().clean();
    }
    //这里之所以将释放的NativeBuffer放在线程本地缓存中，主要为了重用NativeBuffer，因为NativeBuffer直接操作底层
    内存，创建一个要耗费一定的系统资源。

}

3. 
 //委托给FileChannelImpl
return FileChannelImpl.open(filedescriptor, flags.read, flags.write, flags.append, null);

在这一步我们又看到了FileChannelImpl#open方法，这个我们在后面再看。

[size=medium][b]总结：[/b][/size]
[color=blue]获取区文件的通道一共有四种，第一种从FileOutputStream获取写模式文件通道，第二种从FileInputStream获取读模式文件通道，第三种从RandomAccessFile获取读写模式文件通道，第四种调用FileChannelImpl#open方法，这个过程首先从参数文件Path（WindowsPath）获取文件系统的提供者，实际为WindowsFileSystemProvider，委托给WindowsFileSystemProvider创建文件通道，WindowsFileSystemProvider根据WindowsPath和，文件属性WindowsSecurityDescriptor（FileAttribute[]），和打开选项集，将实际创建通道任务交给WindowsChannelFactory，WindowsChannelFactory首先将打开选项装换为内部的通道配置标志Flags（读写模式（read，writer），同步方式（sync，dsync），append等），然后根据Flags,和Path信息等信息创建文件，创建文件实际由WindowsNativeDispatcher完成。WindowsNativeDispatcher首先从线程本地缓存获取NativeBuffer，将Path信息放在NativeBuffer中，然后创建文件，创建后，将NativeBuffer释放，即放入线程本地缓存，以便重用。具体选择哪种方式，根据需要选择。[/color]
Donald_Draper
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java createchannel_【原创】java NIO FileChannel 学习笔记 新建一个FileChannel
weixin_39777242的博客
02-26 157
首先使用FileChannel 的open方法获取一个FileChannel对象。下面这段代码是FileChannel中open方法的代码。public static FileChannel open(Path path,Set extends OpenOption> options,FileAttribute>... attrs)throws IOException{FileSyst...
关于windows文件系统的文件隧道功能
享受开发，颠倒银河
11-07 1160
许多童鞋在删除和重建或重命名一个文件时，会发现新文件的时间戳没有改变，这 是因为同名文件的元数据没有被刷新，有诗为证: 所谓隧道是指，若一个文件被删除，然后再很短时间内又创建或重命名一个文件， 其名称与原先删除的文件同名，则新文件的时间戳与原来的相同。原因是，当文 件被删后，文件系统元文件信息仍保存在系统缓存中。 如果有WRK，则文件base\ntos\fsrtl\tun
文件复制的另一种选择，使用FileChannel复制文件
anzhan38161的博客
05-27 186
通常来说，FileChannel比普通的缓冲输入输出流有更高的效率 import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.nio.channels.FileChannel...
NIO源码解析-FileChannel
恐龙弟旺仔的博客
09-10 535
前言： FileChannel是一个连接到文件的通道，我们可以通过FileChannel来读写文件。在之前我们读写文件的方式中，主要是采用InputStream和OutputStream的流式方式来操作的。 本文会介绍下FileChannel的那些常用api。 1.FileChannel的基本结构 通过它的类结构图我们可以看到，FileChannel实现了对文件的读写操作，还被设置为可中断。下面来具体了解下其API。 2.FileChannel API 2.1 FileChannel的创
linux文件描述符open file descriptors与open files的区别
子曰：好娃得是不抄作业？
12-28 1426
原文链接 什么是open file An open file may be a regular file, a directory, a block special file, a character special file, an executing text reference, a library, a stream or a network file.   什么是file des
物联网mac层技术综述培训文件
07-06
物联网mac层技术综述培训文件
路径规划综述.ppt文件
最新发布
05-03
路径规划技术是机器人研究领域中的一个重要分支。所谓机器人的最优路径规划问题,就是依据某个或某些优化准则(如工作代价最小、行走路线最短、行走时间最短等),在其工作空间中找到一条从起始状态到目标状态的能避开...
计算机之文件管理综述.ppt
05-07
计算机之文件管理综述.ppt
隐蔽通道及其分析技术综述
12-19
【隐蔽通道及其分析技术综述】 隐蔽通道是信息安全领域中一个关键的研究课题，因其独特的性质在防止非法信息传输中起到重要作用。尽管传统的防火墙和入侵检测系统能够有效地阻止通过正常通信途径的数据窃取，但它们...
分布式文件系统综述.pdf
08-09
#资源达人分享计划#
java nio Files DirectoryStream 文件复制
TimerBin的博客
01-20 322
JDK1.7 中新增了nio包，基于此包可实现java程序基于操作系统的情况下对文件或文件夹进行CRUD操作，同时支持跨系统间的文件操作。 一、对文件操作代码 1、在java中基于IO对系统文件进行操作 public static void oldCopyFileList(){ long begin = System.currentTimeMillis(); FileInputSt...
java nio 源码分析 -windows （select模型）
qq_36344441的博客
11-17 660
java socket 1.什么是nio 阻塞/非阻塞与同步/异步 1.1 阻塞io 阻塞 I/O 发起的 read 请求，线程会被挂起，一直等到内核数据准备好，并把数据从内核区域拷贝到应用程序的缓冲区中，当拷贝过程完成，read 请求调用才返回。接下来，应用程序就可以对缓冲区的数据进行数据解析。 1.2 非阻塞 非阻塞的 read 请求在数据未准备好的情况下立即返回，应用程序可以不断轮询内核，...
java filedescriptor_java IO笔记（FileDescriptor）
weixin_28749997的博客
02-16 463
由于在看io源码中偶尔看到FileDescriptor，所以本篇决定讲讲FileDescriptor，从字面上来看它就是文件描述符。官方是这么描述的：可以看出，FileDescriptor可以看做一种指向文件引用的抽象化概念。它能表示一个开放文件，一个开放的socket或者一个字节的源。它最主要的用途就是去创建FileInputStream或者FileOutputStream。并且也说了不应该创建...
文件通道解析一（读写操作，通道数据传输等）
Donald_Draper的专栏
05-16 513
单综述:[url]http://donald-draper.iteye.com/blog/2374237[/url] 文件读写方式简单综述后续（文件，流构造）:[url]http://donald-draper.iteye.com/blog/2374294[/url] 文件通道创建方式综述：[url]http://donald-draper.iteye.com/blog/2374537[/url] [size=medium][b]引言：[/b][/size] 获取区文件的通道一共有四种，第
Android 存储进化：分区存储，这些面试官常问的开发面试题你都掌握好了吗
wa2231a的博客
02-02 1015
可移除卷（例如 SD 卡）在文件系统中属于外部存储空间。空间较大，现在的智能机基本都配有，但为了兼容性，也可在使用相关api时检查该空间是否处于可用状态。Environment.getExternalStorageState() // 是否可读写 fun isExternalStorageWritable(): Boolean { return Environment.getExternalStorageState() == Environment.MEDIA_MOUNTED } // 是否可读 fun i
怎样使用FileChannel
u010228695的专栏
01-01 367
FileChannel定义了两个用于文件传输的方法： 1. transferTo(int position, long count, WritableByteChannel dst)     该方法是把文件从position位置开始向dst通道传送count个字节。   2. transferFrom(ReadableByteChannel src, long positi
NIO之通道Channel【FileChannel介绍】
波波烤鸭的博客
04-11 2098
通道(channel)介绍   Channel是一个对象,作用是用于源节点和目标节点的连接,在java NIO中负责缓冲区数据的传递。Channel本身不存储数据，因此需要配合缓冲区进行传输。 主要的实现类有   主要的实现类有如下四个: FileChannel, SocketChannel, ServerSocketChannel, DatagramChannel,都实现了java.nio.c...
Linux的open file 与 file descriptor区别
飞信天下专栏
08-24 3384
open file & file descriptor
File && FileDescriptor
asivy的专栏
01-23 1763
转自：http://www.fengfly.com/plus/view-214059-1.html File  File是“文件”和“目录路径名”的抽象表示形式。 File 直接继承于Object，实现了Serializable接口和Comparable接口。实现Serializable接口，意味着File对象支持序列化操作。而实现Comparable接口，意味着File对象之间可以比较大小
JASIST_论文讲解_无处不在的数字文件_文件管理研究述评_PPT中文
12-25
研究重点围绕用户与数字文件的互动，包括一系列操作，如创建、命名、重命名、下载、上传等，这些操作既涉及工作场景的专业文件管理，也包括个人日常文件的处理。 文章关注的是文件管理软件中的用户界面，如图形用户...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值