You're pretty vague about what kind of Lisp you need.
Just ``Lisp'', today, is used either as an umbrella term for all the Lisp derivates or to mean Common Lisp, I'll assume the first, as you also asked the difference between them.
Lisp, in the years, always spawned various derivatives for being a simple language and trivial to parse, but these days there are only two main branches: Common Lisp and Scheme.
Now, let me introduce them.
Common Lisp is born to be a, well, ``common'' Lisp, to unificate various features from the other Lisps, being ultimately based on MacLisp.
You surely have heard that Common Lisp (abbreviated CL, never CLISP) is a ``Lisp-2'' or ``Lisp-n'', it means that symbols can have multiple meanings.
For example, you can do
(setq foo 2)
(defun foo (x) x)
(foo foo)
and will call the function `foo' with the previously
setqed variable, also named `foo', without name clashes.
You also know that Lisp is famous for being able to pass functions as argument, so to disambiguate it from a variable, you need to use
(function ...) or
#' prefixed to the function's name, and then call it with
(funcall ...):
(defun foo (x) x)
(defun bar (f x) (funcall f x))
(bar #'foo 3) ; this really expands to (bar (function foo) 3)
You may think this like a ``quote for functions''.
The need for funcall and #' may appear unnecessary, but has its advantages.
Scheme born to be simple and elegant, and it's a ``Lisp-1'', which means that your functions and your variables share the same namespace, but it's usually simpler to use for newcomers to Lisp.
(define (foo x) x)
(define (bar f x) (f x))
(bar foo 3)
Will do exactly what you think. In fact, function definitions just bind a procedure to a variable, and the
(define (foo x) x) syntax is just a shorthand to
(define foo (lambda (x) x)).
This simplify things, but that means you can't name your variables `list', `string', etc, without shadowing those functions.
Common Lisp has an ANSI standard and much more mature implementations than Scheme, which has gained some serious and fast implementations just recently.
CL code, having a quite big standard, is mostly portable between all the implementations.
Scheme, instead, has a 55 pages long standard (the R5RS, the most widespread one), so implementations are usually self-contained and non-portable. There are libraries that are portable between the R5RS Schemes (like SLIB). This doesn't mean that you can't use Scheme, it just means that you have a wider choice.
I suggest you Chicken, which can be as fast as C (and it's also compilated to C), and has a excellent library support and FFI, and Racket, which is JIT compilated and provides many nice features and a big library (and the FFI is simply fantastic).
Here some libraries for what you asked:
http://www.cliki.net/thread
http://www.cliki.net/CL-PPCRE
http://www.cliki.net/CL-HTML-Parse
http://docs.racket-lang.org/reference/regexp.html
http://docs.racket-lang.org/reference/threads.html
http://docs.racket-lang.org/html/index.html
http://docs.racket-lang.org/xml/index.html
http://wiki.call-cc.org/man/4/Unit%20regex
http://wiki.call-cc.org/man/4/Unit%20srfi-18
http://wiki.call-cc.org/chicken-projects/egg-index-4.html#web
The choice between CL, Scheme (Chicken, Racket), depends on what you want, I can't decide for you.