Как одновременно запустить несколько экземпляров класса с асинхронными функциями?

Вы можете использовать threading:

import asyncio
import threading


class Calculation:
    def __init__(self, value):
        self.value = value
        self.running = True

    async def one(self):
        while self.running:
            print(self.value * 1, 'one')
            await asyncio.sleep(1)

    async def two(self):
        while self.running:
            print(self.value * 2, 'two')
            await asyncio.sleep(1)

    async def starter(self):
        task1 = asyncio.create_task(self.one())
        task2 = asyncio.create_task(self.two())
        await asyncio.gather(task1, task2)

    def stop(self):
        self.running = False


def run_calculation(calculation_instance):
    loop = asyncio.new_event_loop()
    asyncio.set_event_loop(loop)
    loop.run_until_complete(calculation_instance.starter())
    loop.close()


if __name__ == '__main__':
    a, b = Calculation(2), Calculation(3)

    t1 = threading.Thread(target=run_calculation, args=(a,))
    t2 = threading.Thread(target=run_calculation, args=(b,))
    t1.start()
    t2.start()

    t1.join(timeout=1)
    t2.join(timeout=1)

    a.stop()
    b.stop()

Принты

2 one
4 two
3 one
6 two
2 one
4 two
3 one
6 two
2 one
4 two
3 one
6 two

Нет необходимости использовать потоки или дочерние процессы в зависимости от того, что делают one и two:

import asyncio
import time

class Calculation():
    def __init__(self, value):
        self.value = value

    async def one(self):
        for _ in range(3):  # So that we end eventually
            print(f'{self.value} * 1 = {self.value * 1} (time = {time.monotonic() - start_time})')
            await asyncio.sleep(1)

    async def two(self):
        for _ in range(3):  # So that we end eventually
            print(f'{self.value} * 2 = {self.value * 2}  (time = {time.monotonic() - start_time})')
            await asyncio.sleep(1)

    async def starter(self):
        await asyncio.gather(self.one(), self.two())


async def run_calculations():
    global start_time

    c2 = Calculation(2)
    c3 = Calculation(3)
    start_time = time.monotonic()
    await asyncio.gather(c2.starter(), c3.starter())

if __name__ == '__main__':
    asyncio.run(run_calculations())

Распечатки:

2 * 1 = 2 (time = 0.0)
2 * 2 = 4  (time = 0.0)
3 * 1 = 3 (time = 0.0)
3 * 2 = 6  (time = 0.0)
2 * 1 = 2 (time = 1.0159999998286366)
3 * 1 = 3 (time = 1.0159999998286366)
2 * 2 = 4  (time = 1.0159999998286366)
3 * 2 = 6  (time = 1.0159999998286366)
2 * 1 = 2 (time = 2.030999999959022)
2 * 2 = 4  (time = 2.030999999959022)
3 * 1 = 3 (time = 2.030999999959022)
3 * 2 = 6  (time = 2.030999999959022)

Обновление для многопроцессорной обработки

Если вам действительно необходимо использовать многопроцессорную обработку, поскольку ваши асинхронные сопрограммы one и two выполняют некоторые ресурсоемкие вычисления, я бы предложил вам поместить эти вычисления в «обычный» метод (т. е. не в сопрограмму), называемый blocking_code в этой демонстрации, и использовать циклический метод run_in_executor следующим образом:

import asyncio
import concurrent.futures
import time

class Calculation():
    def __init__(self, value):
        self.value = value
        self.start_time = time.monotonic()

    def blocking_code(self, multiplier):
        print(f'{self.value} * {multiplier} = {self.value * multiplier} (time = {time.monotonic() - self.start_time})')

    async def one(self, pool):
        loop = asyncio.get_running_loop()
        for _ in range(3):  # So that we end eventually
            await loop.run_in_executor(pool, self.blocking_code, 1)
            await asyncio.sleep(1)

    async def two(self, pool):
        loop = asyncio.get_running_loop()
        for _ in range(3):  # So that we end eventually
            await loop.run_in_executor(pool, self.blocking_code, 2)
            await asyncio.sleep(1)

    async def starter(self, pool):
        await asyncio.gather(self.one(pool), self.two(pool))


async def run_calculations():
    c2 = Calculation(2)
    c3 = Calculation(3)
    with concurrent.futures.ProcessPoolExecutor(4) as pool:
        await asyncio.gather(c2.starter(pool), c3.starter(pool))

if __name__ == '__main__':
    asyncio.run(run_calculations())

Распечатки:

2 * 1 = 2 (time = 0.2190000000409782)
2 * 2 = 4 (time = 0.2190000000409782)
3 * 1 = 3 (time = 0.2190000000409782)
3 * 2 = 6 (time = 0.2190000000409782)
2 * 1 = 2 (time = 1.2190000000409782)
3 * 1 = 3 (time = 1.2190000000409782)
3 * 2 = 6 (time = 1.2350000003352761)
2 * 2 = 4 (time = 1.2350000003352761)
2 * 1 = 2 (time = 2.25)
3 * 1 = 3 (time = 2.25)
2 * 2 = 4 (time = 2.25)
3 * 2 = 6 (time = 2.25)

Если blocking_code не особо нагружает ЦП (например, он получает URL-адрес с помощью модуля requests), но не использует asyncio, то вы можете инициализировать pool экземпляром concureent.futures.ThreadPoolExecutor.