The root of this behavior is that when the program runs delay() function - nothing else could run (digitalwrites, checks, conditions, etc.) until the delay() time is passed.

The effective solution for this is avioding the delay() function, and getting the same results (without the side-effect) using timers (like millis()) or other ways.

Googling "How to avoid delay()" will give you lot of information about how-to do it, one example can be found here: Arduino Playground - How and Why to avoid delay() function.

Good luck with that, and enjoy your programming experience!

What happens when you give about 1 second worth of motor movement instructions to a motor in a tiny fraction of a millisecond? Run that sketch and find out!

You do not need parallel processing or finite-state machines for that:

// Vector with digital pin numbers for LEDs (with resistor to ground)
const int LED_MAX = 5;
const int LED[LED_MAX] = { 2, 3, 4, 5, 6 };

// Vector with analog pin numbers for LDR (with pullup resistor)
const int LDR_MAX = 5;
const int LDR[LDR_MAX] = { A0, A1, A2, A3, A4 };

// Analog value or lower when to light the LED
const int THRESHOLD = 200;

void setup()
{
   // All LED pins should be digital output pins
   for (int i = 0; i < LED_MAX; i++) 
     pinMode(LED[i], OUTPUT);
}

void loop()
{
   // Read all LDRs and set LED pins according to threshold
   for (int i = 0; i < LDR_MAX; i++)
     digitalWrite(LED[i], analogRead(LDR[i]) < THRESHOLD);
}

But if you really want to describe this as multiple tasks you could use the Simple Scheduler library:

#include <Scheduler.h>

const int THRESHOLD = 200;    

template<int LED> void setup()
{
   pinMode(LED, OUTPUT);
}

template<int LED, int LDR> void loop()
{
   digitalWrite(LED, analogRead(LDR) < THRESHOLD);
   yield();
}

void setup()
{
   Scheduler.start(setup<2>, loop<2, A0>);
   Scheduler.start(setup<3>, loop<3, A1>);
   Scheduler.start(setup<4>, loop<4, A2>);
   Scheduler.start(setup<5>, loop<5, A3>);
   Scheduler.start(setup<6>, loop<6, A4>);
}

void loop()
{
   yield();
}

I'm not sure what is required to output sinus-signal, but here's my take on a solution. First, what I understand you have:

void loop() {
    update_pwm_output();
    delay(1000/50); // 50 Hz
}

A possible solution:

int last_update = 0;
void loop() {
    int mill = millis();
    if (mill-last_update > (1000/50)) {
        last_update = mill;
        update_pwm_output();
    }
}

This solution would allow you to execute other code in between updates to your PWM signal.

There are a couple ways to keep a PWM updated while running other code. A library I've used, SoftwareServo, allows you to call its refresh() method periodically and it'll update, where as the Servo library takes up a timer and uses an interrupt to do its updates.

Brandon Halpin, Software Development Engineer at Amazon Answered Jun 6, 2017 Dear According to the lecture of Mr Brandon Halpin the engineer in Amazon Software Development : Without clarification you may be in one of two situations: 1-You have a fundamental misunderstanding of parallel programming and multithreading. At the core of every arduino is a microcontroller. These are single core processessors that run at 8–32KHz. As a reference the average computers CPU is running at least 2 cores at ~3GHz. These processors are not capable of multitasking in the true sense of the word. They literally cannot process more than one thing at once. 2-You understand Arduinos are microprocessors with one thread and you want to build a cluster of them to share the computation of some task.In this case the arduino is likely the last thing you should use for this situation. At this price point you can find many options (Raspberry Pi for instance) that are far more powerful and can create a more robust solution to any parallel processing problem you wish to solve. So that , I think using raspberry pi is saving for time and money for this purpose. If you think this answer help you, please try to recommend it.