🚀 go-pugleaf

"Bj�rge S�ther" wrote:
> 
You need
> to understand the core of Windows OS somewhat better to succeed. I would
> advice programmers to dive into the WinAPI instead.
> The same may be said about TThread: The fact that this class exists, lead
> programmers to believe that this is some basic pattern for threads. It took
> me quite a while to understand that you would normally need to redesign the
> TThread class both for startup, termination, execution *and* synchronization.
> If they had provided a basic exception handling mechanism, it would be worth
> something...I'm sure I would get there faster without the prewritten class,
> at least.

I'd mainly agree with that. The problem is that TThread, especially
synchronise, is an attemt to make things *easy*. Unfortunately, it's a
situation where you *have* to understand the entire situation:
half-assed attempts won't do.

> Good luck with your book !

It's going very nicely actually. My basic premise has been 

- To introduce threads with TThread. 
- Introduce the various approaches useful with thread creation and
destruction. 
- Introduce synchronise, and explain why it is such a heap of crap.
Show how mutexes or critical sections do a much nicer job.
- Show a million and one ways to cause deadlock, both with mutexes and
synchronise, and ways of getting around it.

All of that I've done.

I'm now working on:

- Producer / consumer relationships : buffers with flow control by
implementing blocking read and write operations.
- Converting blocking I/O to asynchronous I/O and back: how to make an
asynchronous VCL thread live nicely with blocking worker threads.
- More interesting synchronisation primitives.
- An introduction to monitors.

If I get the chance, I'll also do some more advanced topics such as:

- Equivalency of synchronisation primitives.
- Various forms of IPC and converting one to another.
- An introduction to transaction processing.

Various subjects in transaction processing:

- Atomicity of composite operations, commit, abort & multi stage
rollback.
- Individuality of multiple operations and optimistic concurrency
control
- Persistence and crash resilience.

And perhaps throw in a bit on deadlock detection and avoidance as well.

It's turning out to be quite hard work, but I'm sure I'll be able to
cope.

MH.
--
Martin Harvey. martin@pergolesi.demon.co.uk
     http://www.pergolesi.demon.co.uk