Processing is a little more hands-on. So often many things can be done, but not always with a ready-made solution. You can use the function lerpColor for linear interpolation between two colors. A linear gradient of multiple colors is just a sequence of linear interpolations between two colors, right?

1 > 2 then 2 > 3 then 3 > 4 etc.

Or do you mean something different?

Here is the code I have so far:

You cannot add colors like this, it will mess up the values, actually.
The idea, in a multi-color gradient, is to have gradient stops, points in the gradient when you have color transitions. See gradient editors in applications like Gimp or Inkscape.
So you should use lerpColor between color c1 and c2 for part of the width (or height, depending on the orientation), then between c2 and c3 for another part, etc.
In short, make several gradient segments, successfully.

Adding to the above suggestions by phi.lho, you can make your solution in this case more efficient and flexible by going over the width first and using an array of colors instead of individual colors. Pixels are a one-dimensional array of colors, read this.

Code Example

1. PImage pincelmar;
2.  
3. void setup() {
4.   size(500, 500);
5.  
6.   color[] colors = {
7.     color(255, 0, 0),
8.     color(0, 0, 255),
9.     color(255, 0, 0),
10.     color(0, 255, 0)
11.   };
12.  
13.   pincelmar = createGradientImage(300, 20, colors);
14. }
15.  
16. void draw() {
17.   background(226, 225, 215);
18.   translate(100, 200);
19.   image(pincelmar, 0, 0);
20. }
21.  
22. PImage createGradientImage(int w, int h, color[] colors) {
23.   PImage img = createImage(w, h, RGB);
24.   int divideColors = colors.length - 1;
25.   int stepSize = img.width / divideColors;
26.   img.loadPixels();
27.   for (int x=0; x<img.width; x++) {
28.     color cS = colors[x/stepSize];
29.     color cE = colors[min((x/stepSize)+1, divideColors)];
30.     float amt = (float) (x % stepSize) / stepSize;
31.     color cC = lerpColor(cS, cE, amt);
32.     for (int y=0; y<img.height; y++) {  
33.       int index = x + y * img.width;
34.       img.pixels[index] = cC;
35.     }
36.   }
37.   img.updatePixels();
38.   return img;
39. }

An alternative solution would be to use a begin-endShape to 'solve' the color interpolation between vertices.

Code Example

1. PImage pincelmar;
2.  
3. void setup() {
4.   size(500, 500);
5.  
6.   color[] colors = {
7.     color(255, 0, 0),
8.     color(0, 0, 255),
9.     color(255, 0, 0),
10.     color(0, 255, 0)
11.   };
12.  
13.   pincelmar = createGradientImage(300, 20, colors);
14. }
15.  
16. void draw() {
17.   background(226, 225, 215);
18.   translate(100, 200);
19.   image(pincelmar, 0, 0);
20. }
21.  
22. PImage createGradientImage(int w, int h, color[] colors) {
23.   PGraphics img = createGraphics(w, h, P2D);
24.   int divideColors = colors.length - 1;
25.   int stepSize = img.width / divideColors;
26.   img.beginDraw();
27.   img.noStroke();
28.   img.beginShape(QUAD_STRIP);
29.   for (int i=0; i<colors.length; i++) {
30.     img.fill(colors[i]);
31.     img.vertex(stepSize*i, 0);
32.     img.vertex(stepSize*i, img.height);
33.   }
34.   img.endShape();
35.   img.endDraw();
36.   return img;
37. }

Thanks for the answers!