Java OS类代码示例

import net.openhft.chronicle.core.OS; //导入依赖的package包/类
@Setup
public void setup() {
    String target = OS.TMP;
    upQueuePath = new File(target, "ComponentsBenchmark-up-" + System.nanoTime());
    upQueue = SingleChronicleQueueBuilder.binary(upQueuePath).build();
    smdWriter = upQueue.acquireAppender().methodWriter(SidedMarketDataListener.class);

    downQueuePath = new File(target, "ComponentsBenchmark-down-" + System.nanoTime());
    downQueue = SingleChronicleQueueBuilder.binary(downQueuePath).build();
    MarketDataListener mdWriter = downQueue.acquireAppender().methodWriter(MarketDataListener.class);

    SidedMarketDataCombiner combiner = new SidedMarketDataCombiner(mdWriter);

    reader = upQueue.createTailer().methodReader(combiner);
    System.out.println("up-q " + upQueuePath);
}
 

import net.openhft.chronicle.core.OS; //导入依赖的package包/类
private void mapTierBulksMapped(int upToBulkIndex) throws IOException {
    int firstBulkToMapIndex = tierBulkOffsets.size();
    int bulksToMap = upToBulkIndex + 1 - firstBulkToMapIndex;
    long mapSize = bulksToMap * tierBulkSizeInBytes;
    long mappingOffsetInFile, firstBulkToMapOffsetWithinMapping;
    long firstBulkToMapOffset = bulkOffset(firstBulkToMapIndex);
    if (OS.mapAlign(firstBulkToMapOffset) == firstBulkToMapOffset) {
        mappingOffsetInFile = firstBulkToMapOffset;
        firstBulkToMapOffsetWithinMapping = 0;
    } else {
        // If the bulk was allocated on OS with 4K mapping granularity (linux) and we
        // are mapping it in OS with 64K mapping granularity (windows), we might need to
        // start the mapping earlier than the first tier to map actually starts
        mappingOffsetInFile = OS.mapAlign(firstBulkToMapOffset) - OS.mapAlignment();
        firstBulkToMapOffsetWithinMapping = firstBulkToMapOffset - mappingOffsetInFile;
        // Now might need to have bigger mapSize
        mapSize += firstBulkToMapOffsetWithinMapping;
    }
    // mapping by hand, because MappedFile/MappedBytesStore doesn't allow to create a BS
    // which starts not from the beginning of the file, but has start() of 0
    NativeBytesStore extraStore = map(mapSize, mappingOffsetInFile);
    appendBulkData(firstBulkToMapIndex, upToBulkIndex, extraStore,
            firstBulkToMapOffsetWithinMapping);
}
 

import net.openhft.chronicle.core.OS; //导入依赖的package包/类
/**
 * @see net.openhft.chronicle.bytes.MappedFile#acquireByteStore(long, MappedBytesStoreFactory)
 */
private NativeBytesStore map(long mapSize, long mappingOffsetInFile) throws IOException {
    mapSize = pageAlign(mapSize);
    long minFileSize = mappingOffsetInFile + mapSize;
    FileChannel fileChannel = raf.getChannel();
    if (fileChannel.size() < minFileSize) {
        // In MappedFile#acquireByteStore(), this is wrapped with fileLock(), to avoid race
        // condition between processes. This map() method is called either when a new tier is
        // allocated (in this case concurrent access is mutually excluded by
        // globalMutableStateLock), or on map creation, when race condition should be excluded
        // by self-bootstrapping header spec
        raf.setLength(minFileSize);
    }
    long address = OS.map(fileChannel, READ_WRITE, mappingOffsetInFile, mapSize);
    resources.addMemoryResource(address, mapSize);
    return new NativeBytesStore(address, mapSize, null, false);
}
 

import net.openhft.chronicle.core.OS; //导入依赖的package包/类
@Test
    public void test() throws IOException {
        final File cacheRoot = new File(OS.TARGET + "/test.cm3");
        ChronicleMapBuilder<byte[], byte[]> shaToNodeBuilder =
                ChronicleMapBuilder.of(byte[].class, byte[].class)
//                        .name("bytes-to-bytes")
                        .entries(1000000).
                        averageKeySize(20).
                        averageValueSize(30);

        ChronicleMap<byte[], byte[]> shaToNode =
                shaToNodeBuilder.createPersistedTo(cacheRoot);

        shaToNode.put("1".getBytes(), "2".getBytes());

        shaToNodeBuilder.createPersistedTo(cacheRoot);

    }
 

import net.openhft.chronicle.core.OS; //导入依赖的package包/类
public static void main(String... args) {
    String input = args.length > 0 ? args[0] : OS.TMP + "/input";
    String output = args.length > 1 ? args[1] : OS.TMP + "/output";
    try (ChronicleQueue inputQ = SingleChronicleQueueBuilder.binary(input).build();
         ChronicleQueue outputQ = SingleChronicleQueueBuilder.binary(output).build()) {
        System.out.println(inputQ.dump());
        System.out.println(outputQ.dump());
    }
}
 

import net.openhft.chronicle.core.OS; //导入依赖的package包/类
public static void main(String[] args) {
    String input = args.length > 0 ? args[0] : OS.TMP + "/input";
    String output = args.length > 1 ? args[1] : OS.TMP + "/output";

    AtomicLong lastUpdate = new AtomicLong(System.currentTimeMillis() + 1000);
    Thread thread = new Thread(() -> {
        ChronicleQueue outputQ = SingleChronicleQueueBuilder.binary(output).build();
        MethodReader reader = outputQ.createTailer().methodReader((HelloReplier) err::println);
        while (!Thread.interrupted()) {
            if (reader.readOne()) {
                lastUpdate.set(System.currentTimeMillis());
            } else {
                Jvm.pause(10);
            }
        }
    });
    thread.setDaemon(true);
    thread.start();

    ChronicleQueue inputQ = SingleChronicleQueueBuilder.binary(input).build();
    HelloWorld helloWorld = inputQ.createAppender().methodWriter(HelloWorld.class);

    Scanner scanner = new Scanner(System.in);
    while (true) {
        while (System.currentTimeMillis() < lastUpdate.get() + 30)
            Thread.yield();

        out.print("Chat ");
        out.flush();
        if (!scanner.hasNextLine())
            break;
        String line = scanner.nextLine();
        helloWorld.hello(line);
        lastUpdate.set(System.currentTimeMillis());
    }
    out.print("Bye");
}
 

import net.openhft.chronicle.core.OS; //导入依赖的package包/类
public static void main(String... args) {
    String input = args.length > 0 ? args[0] : OS.TMP + "/input";
    String output = args.length > 1 ? args[1] : OS.TMP + "/output";
    serviceWrapper = ServiceWrapperBuilder.serviceBuilder(input, output,
            HelloReplier.class, HelloWorldImpl::new).get();
    System.out.println("Started");
}
 

import net.openhft.chronicle.core.OS; //导入依赖的package包/类
public static void main(String... args) {
    String input = args.length > 0 ? args[0] : OS.TMP + "/order-input";
    String output = args.length > 1 ? args[1] : OS.TMP + "/order-output";
    serviceWrapper = ServiceWrapperBuilder.serviceBuilder(input, output,
            OrderListener.class, OrderManager::new).get();
    System.out.println("Started");
}
 

import net.openhft.chronicle.core.OS; //导入依赖的package包/类
@Test
public void testWithAsQueueService() {
    // acts as three processes in one test
    // process A writes to the HelloWorld interface.
    // process B read fromt he HelloWorld interface and writes to the
    String input = OS.TARGET + "/input-" + System.nanoTime();
    String output = OS.TARGET + "/output-" + System.nanoTime();

    HelloReplier replier = createMock(HelloReplier.class);
    replier.reply("Hello April");
    replier.reply("Hello June");
    replay(replier);

    ServiceWrapperBuilder<HelloReplier> builder = ServiceWrapperBuilder
            .serviceBuilder(input, output, HelloReplier.class, HelloWorldImpl::new)
            .inputSourceId(1).outputSourceId(2);

    try (CloseableHelloWorld helloWorld = builder.inputWriter(CloseableHelloWorld.class);
         MethodReader replyReader = builder.outputReader(replier);
         ServiceWrapper helloWorldService = builder.get()) {

        helloWorld.hello("April");
        helloWorld.hello("June");

        System.out.println(helloWorldService.inputQueues()[0].dump());
        for (int i = 0; i < 2; i++) {
            while (!replyReader.readOne()) {
                Thread.yield();
            }
        }
        System.out.println(helloWorldService.outputQueue().dump());
        verify(replier);
    } finally {
        IOTools.deleteDirWithFiles(new File(input), 2);
        IOTools.deleteDirWithFiles(new File(output), 2);
    }
}
 

import net.openhft.chronicle.core.OS; //导入依赖的package包/类
private long tryHashLookupSlotSize(int hashLookupSlotSize) {
    long entriesPerSegment = findMaxEntriesPerSegmentToFitHashLookupSlotSize(
            hashLookupSlotSize);
    long entrySpaceSize = roundUp(entriesPerSegment * entrySizeInfo().averageEntrySize);
    // Not to lose too much on linux because of "poor distribution" entry over-allocation.
    // This condition should likely filter cases when we target very small hash lookup
    // size + entry size is small.
    // * 5 => segment will lose not more than 20% of memory, 10% on average
    if (entrySpaceSize < OS.pageSize() * 5L)
        return -1;
    return trySegments(entriesPerSegment, MAX_SEGMENTS);
}
 

import net.openhft.chronicle.core.OS; //导入依赖的package包/类
int segmentHeaderSize() {
    int segments = actualSegments();

    long pageSize = OS.pageSize();
    if (segments * (64 * 3) < (2 * pageSize)) // i. e. <= 42 segments, if page size is 4K
        return 64 * 3; // cache line per header, plus one CL to the left, plus one to the right

    if (segments * (64 * 2) < (3 * pageSize)) // i. e. <= 96 segments, if page size is 4K
        return 64 * 2;

    // reduce false sharing unless we have a lot of segments.
    return segments <= 16 * 1024 ? 64 : 32;
}
 

import net.openhft.chronicle.core.OS; //导入依赖的package包/类
private void prepareMapPublication(VanillaChronicleMap map) throws IOException {
    establishReplication(map);
    map.setResourcesName();
    map.registerCleaner();
    // Ensure safe publication of the ChronicleMap
    OS.memory().storeFence();
    map.addToOnExitHook();
}
 

import net.openhft.chronicle.core.OS; //导入依赖的package包/类
@NotNull
private Byteable allocateByteable(Class<T> tClass) {
    try {
        return (Byteable) OS.memory().allocateInstance(tClass);
    } catch (InstantiationException e) {
        throw new IllegalStateException(e);
    }
}
 

import net.openhft.chronicle.core.OS; //导入依赖的package包/类
private long computeNumberOfTiersInBulk() {
    // TODO review heuristics
    int tiersInBulk = actualSegments / 8;
    tiersInBulk = Maths.nextPower2(tiersInBulk, 1);
    while (computeTierBulkBytesSize(tiersInBulk) < OS.pageSize()) {
        tiersInBulk *= 2;
    }
    return tiersInBulk;
}
 

import net.openhft.chronicle.core.OS; //导入依赖的package包/类
private void msync(long address, long length) throws IOException {
    // address should be a multiple of page size
    if (OS.pageAlign(address) != address) {
        long oldAddress = address;
        address = OS.pageAlign(address) - OS.pageSize();
        length += oldAddress - address;
    }
    if (OS.isWindows()) {
        WindowsMsync.msync(raf, address, length);
    } else {
        PosixMsync.msync(address, length);
    }
}