Or is it like the difference between hooks and processors? (where a hook is executed by a specific processor)

Or are processors used for non-visual/http process and are instead used for things like commands or background actions?

Edit:

Both Pipelines and Processors are composed of processors. (Confusing naming scheme)
If you look in your configuration files you'll see a <processors> and a <pipelines> node with <process> child nodes.

Is there any real difference between them?

For example there is a <uiUpload> process (under <processors>) and a <publish> pipeline under the <pipelines> node. Both of which have processor children nodes.

From Sitecore documentation:

Pipelines define a sequence of processors that implement a function, such as defining the Sitecore context for an HTTP request or generating a list of messages in the Content Editor. Pipelines assist with encapsulation, flexible configuration, separation of concerns, testability and other objectives.

Each processor in a pipeline contains a method named Process() that accepts a single argument and returns void. A processor can abort the pipeline, preventing Sitecore from invoking subsequent processors.

The argument that is passed to the Process() method must be of a type that is specific to the pipeline or be the default argument —Sitecore.Pipelines.PipelineArgs. To create a pipeline processor, create a class that implements a method named Process() with the same signature as the other processors in the pipeline. This processor can inherit from an existing processor, and you can add, remove, replace, and rearrange processors in the pipelines to suit your requirements.

Read more in Sitecore Pipelines document. It's for Sitecore 6.5 but the concept is still the same.

EDIT

Both <processors> and <pipelines> nodes in Sitecore configuration are used for defining pipelines.

There are few differences I know about:

1. 
   Processors processors should have parameterless constructors


2. When defining a processor inside <processors> node, you can specify method name different from Process, e.g.:

<processors>
 <uiAddFromTemplate>
 <processor mode="on" type="Sitecore.Shell.Framework.Pipelines.AddFromTemplate,Sitecore.Kernel" 
 method="GetTemplate" />
 <processor mode="on" type="Sitecore.Shell.Framework.Pipelines.AddFromTemplate,Sitecore.Kernel" 
 method="Execute" />
 </uiAddFromTemplate>
</processors>

3. When defining <pipelines> pipeline, you can group pipelines (see second <pipelines> tag inside the group), e.g.:

<pipelines>
 <group name="itemProvider" groupName="itemProvider">
 <pipelines>
 <addFromTemplate help="Processors should derive from Sitecore.Pipelines.ItemProvider.AddFromTemplate.AddFromTemplateProcessor.">
 </addFromTemplate>
 </pipelines>
 </group>
</pipelines>

In background Sitecore uses different methods for creation of the pipelines defined in <processors> and in <pipelines> config nodes.

It looks like <processors> are mostly used for UI related stuff.

I would recommend to use always <pipelines> if you want to build any custom funcionality for consistency and transparency.

A pipeline is a series of actions that execute in sequence to perform a task in Sitecore. Pipelines are fundamental to Sitecore's basic architecture. Most processes in Sitecore are defined as pipelines. Pipelines can be modified by developers to change, add, or remove functionality from Sitecore.

Pipelines are made up of one or more steps - called "processors." A pipeline is defind in configuration. For example, here is the definition for the getRenderingPreview from Sitecore.config:

<getRenderingPreview>
 <processor type="Sitecore.Pipelines.GetRenderingPreview.GetXslRenderingPreview,Sitecore.Kernel" />
 <processor type="Sitecore.Pipelines.GetRenderingPreview.TryRenderControl,Sitecore.Kernel" />
 <processor type="Sitecore.Pipelines.GetRenderingPreview.GetRenderingPreviewField,Sitecore.Kernel" />
 <processor type="Sitecore.Pipelines.GetRenderingPreview.GetDefaultRenderingPreview,Sitecore.Kernel" />
</getRenderingPreview>

When the getRenderingPreview pipeline is executed, the processors defined above run in order from first to last. Most pipelines pass data between each processor in the form of an arguments object. For example, getRenderingPreview use an arguments object called GetRenderingPreviewArgs. This stores data that each processor of the pipeline may need. This usually also includes data about the current Sitecore context.

A processor is implemented by a C# class. Many built-in pipelines can be found under the Sitecore.Pipelines namespace in Sitecore.Kernel.dll.

Conceptually, a Sitecore pipeline is based around the pipes and filters pattern which is also termed the pipeline pattern.

pipes and filters pattern

The basic elements of the pipe and filters pattern are:

Pump : Pushes the data to be processed into the pipeline

Pipe : The channel containing one or more sequential filters

Filter : Performs the data processing (in Sitecore terms these are called Processors)

Sink : Consumes the data processed by the pipeline

Edit

If you see Sitecore.config Processors classes must have parameterless constructor. Processors is also a pipeline like dispatch as mentioned below.

As recommended practice for custom implementation use specific pipeline ex- initialize,httpRequestBegin,renderField based on yours requirement.

<!-- PROCESSORS
 Classes must have parameterless constructor.
 Supported attributes:
 mode=[on|off]
 type=name of class (case-sensitive).
 namespace=namespace containing class. If no namespace is included, it is assumed that the namespace is the same as the assembly name.
 assembly=name of dll containing the class (case-sensitive)
 -->
 <processors>
 <dispatch>
 <!-- This pipeline has been deprecated - try using the CommandManager object instead -->
 </dispatch>

In few words :

Processors provide the logic that is used when a pipeline is invoked.

A pipeline is basically a method whose flow is defined using XML.

A pipeline consists of a sequence of processors. A processor is a .NET class that implements a method. When a pipeline is invoked, the processors are run in order.

Pipelines are used to control most of Sitecore’s functionality. Processes ranging from authentication to request handling to publishing to indexing are all controlled through pipelines.

More informations you can find here:

https://sitecorespark.com/article/introduction-to-pipelines

http://www.coreworks.co/sitecore-pipelines-overview

As has been pointed out in other answers, <processors> are used primarily for UI-related activities. They must be executed via Sitecore.Pipelines.PipelineFactory and Sitecore.Pipelines.Pipeline instead of Sitecore.Pipelines.CorePipeline.

Functionally, the main difference appears to be that these UI pipelines have the ability to suspend while waiting for user input, and resume on Sheer UI postback. The Pipeline class has an ID property which is used for storing it in session. Thus the Pipeline itself and its args need to be [Serializable]. You can see some of this suspend/resume logic in Sitecore.Web.UI.Sheer.ClientPage.

Practically, unless you are doing Sheer UI customization, you should stick with use of <pipelines> / CorePipeline.