In this example, we'll demonstrate how to manage state using asynchronous operations in JavaScript. This approach aligns with JavaScript's event-driven nature and asynchronous programming model.

```javascript
const crypto = require('crypto');

// These classes encapsulate read and write operations
class ReadOp {
    constructor(key) {
        this.key = key;
        this.promise = new Promise((resolve) => {
            this.resolve = resolve;
        });
    }
}

class WriteOp {
    constructor(key, val) {
        this.key = key;
        this.val = val;
        this.promise = new Promise((resolve) => {
            this.resolve = resolve;
        });
    }
}

// Main function to run our example
async function main() {
    let readOps = 0;
    let writeOps = 0;

    // Channels for read and write operations
    const reads = [];
    const writes = [];

    // This function simulates the state-owning goroutine
    async function stateManager() {
        const state = new Map();

        while (true) {
            if (reads.length > 0) {
                const read = reads.shift();
                read.resolve(state.get(read.key));
            } else if (writes.length > 0) {
                const write = writes.shift();
                state.set(write.key, write.val);
                write.resolve(true);
            } else {
                await new Promise(resolve => setTimeout(resolve, 0));
            }
        }
    }

    // Start the state manager
    stateManager();

    // Start 100 read operations
    for (let r = 0; r < 100; r++) {
        (async () => {
            while (true) {
                const read = new ReadOp(crypto.randomInt(5));
                reads.push(read);
                await read.promise;
                readOps++;
                await new Promise(resolve => setTimeout(resolve, 1));
            }
        })();
    }

    // Start 10 write operations
    for (let w = 0; w < 10; w++) {
        (async () => {
            while (true) {
                const write = new WriteOp(crypto.randomInt(5), crypto.randomInt(100));
                writes.push(write);
                await write.promise;
                writeOps++;
                await new Promise(resolve => setTimeout(resolve, 1));
            }
        })();
    }

    // Let the operations run for a second
    await new Promise(resolve => setTimeout(resolve, 1000));

    // Report the operation counts
    console.log("readOps:", readOps);
    console.log("writeOps:", writeOps);
}

main();