Example of partial aggregation

Your aggregate definition looks correct.

The reason that the combine function is never called is that PostgreSQL doesn't choose a parallel plan, since the table is so tiny. Insert many more rows into my_table, and PostgreSQL will consider a parallel plan. Use EXPLAIN to see the execution plan — if there is a Gather node, PostgreSQL uses a parallel plan.

sum values for each type (eg, for type=1 - 1+2=3 and for type=2 - 3+4=7) and then combine it with by for example multiplying the subset results (eg, 3*7=21).

That sounds like you need a nested aggregate, not a partial aggregate (not necessarily):
_{demo at db<>fiddle}

select my_multiply_agg(sum_per_type)
from(select sum(value) as sum_per_type
     from my_table
     group by type) as subquery;

It's using the regular, built-in sum() in a subquery (you can also use a CTE) to collect 1+2=3 for type 1 and 3+4=7 for type 2, then it multiplies those using a custom aggregate:

CREATE OR REPLACE FUNCTION my_multiply_agg_sfunc(state numeric, value bigint) 
RETURNS numeric RETURN state * value;

CREATE OR REPLACE FUNCTION my_multiply_agg_combinefunc(state1 numeric, state2 numeric)
RETURNS numeric STRICT RETURN state1 * state2;

CREATE AGGREGATE my_multiply_agg(bigint) (
    SFUNC = my_multiply_agg_sfunc,
    STYPE = numeric,
    INITCOND = '1',
    COMBINEFUNC = my_multiply_agg_combinefunc,
    PARALLEL = SAFE
);

Partial aggregation is there only to let Postgres speed things up in some scenarios (e.g. high row count, partitioning), by splitting the work between parallel workers. It's good practice to add the feature to user-defined functions, but it's not strictly necessary for what you're doing.

Also, it does not expose any way to control which rows end up in each part, which seems to be a requirement in the logic you laid out. On its own it wouldn't let you implement it.

Myself included, it seems that most people here initially focused on the partial/parallel aggregate aspect way more than the actual thing you described you're trying to do.

The functions you originally showed would always get you a zero if parallel execution kicked in. The initcond should typically be a neutral element - in multiplication, that's 1. It is 0 when you add things. You're mixing both.

Also, if the aggregate definition specifies a non-null initcond, keep in mind that that will be used not only as the initial state for each partial aggregation run, but also as the initial state for the combine function, which will be called to combine each partial result into that state.

CREATE OR REPLACE FUNCTION my_sum_sfunc(state bigint, value integer) 
RETURNS bigint RETURN coalesce(state,0) + value;

CREATE OR REPLACE FUNCTION my_sum_combinefunc(state1 bigint, state2 bigint)
RETURNS bigint STRICT RETURN state1*state2;

CREATE AGGREGATE my_sum(integer) (
    SFUNC = my_sum_sfunc,
    STYPE = bigint,
    --initcond replaced by `coalesce()` in sfunc and making combinefunc strict
    COMBINEFUNC = my_sum_combinefunc,
    PARALLEL = SAFE
);

After "fixing" that, you'll find your function is nondeterministic. The order of + and * is significant: 2*3+4 =10 but 2+3*4 =14. Since there's no way to guarantee which parallel worker will pick which subset of rows, same input can lead to different outputs at different times.

Another thing to keep in mind is that regular sum() of int returns bigint, otherwise it'd risk overflow. Since you end up multiplying sums, that's even more of a concern in your case. Above bigint, you'll need numeric, which is what I switched to, in the example up top.

These are logical problems but functionally, your functions are fine. As immediately pointed out by @Bergi, confirmed by @Laurenz Albe and demonstrated on db<>fiddle, you just need more rows to trigger parallel execution. Here's your example on 300k:

explain analyze
SELECT my_sum(v.value)
FROM my_table v;

SELECT my_sum(v.value)
FROM my_table v;