The problem is that when you try to parallelise "basic code" you have to be carefull about what you are doing.
x += 1
is "syntactic sugar", it's actually this:
x = x + 1
Which in "machine terms" is a short sequence of discrete operations:
1) Load "x" into a register.
2) Add one to the register.
3) Load the register into "x".
When you parallelise that sequence, you get multiple tasks running it as close to simultaneously as possible, and because you don't have 154,563 separate cores in your processor that means that they don't all execute the same steps at the same time. So if you have one core that has just loaded "x" into a register, and a second core that is just about to load a new value into it, then the first task is going to overwrite the second tasks revised value with it's new one - but since they both loaded the same value the new value ends up incremented once only!
This gets complicated, and there are ways to avoid it, but they effectively "force" all the parallel task to execute sequentially because the whole of the method you wrote has to be treated as a single discrete operation and that loses any advantage of parallel operation! (In fact, it'll actually slow the whole thing down considerably, as each thread needs it's own memory space, stack, thread controller, and will require a significant amount of task switching work by the operating system.