More on Threads

Multi-thread applications make use of the fact that many tasks contain separate and distinct subtasks.

One thread can be used for each subtask.

We are dealing with concurrent processes

suppose parallel

write program with this in mind

(for organization and to capture concept)

For example, consider that reasoning methods may be categorized into types such as

event-driven
goal-driven
model-driven
expectation-driven

Consider

a = x + y b = z + 1 c = a - b w = c + 1

Can we do anything concurrently?

Are there precedence constraints?

Precedence on the data...

If there are few such constraints, one could write a largely parallel algorithm. Often there are such constraints.

At a quite abstract level:

In any communication (man to man, machine to machine, man to machine), we have protocols. In the past, machines have been sequential single processors. When they have the ability to do more than one thing at once, what new things can they do? Do we still need to tell them what to do? How much can they do on their own?

In artificial intelligence we have the idea of intelligent agents and a blackboard. (their monitor) (consider implementation tools of Java Spaces and heredown for image)

Blackboard models usually consist of three components

the knowledge sources (intelligent agents) (independent)
the blackboard data structure
control

The problem solving state data is kept in a global data base, the blackboard. Knowledge sources produce changes to the blackboard which lead incrementally to a solution to the problem. Communication and interaction among the knowledge sources take place soley through the blackboard.

For control, the knowledge sources respond opportunistically to changes in the blackboard.

What does this mean? Changes to the blackboard trigger knowledge source activity.

Knowledge sources can be schematized as condition-action pairs.

The condition component prescribes the situations in which the KS may contribute to the problem-solving activity, and

the action component specifies what the contribution is and how to integrate it into the current situation.

The condition and action components of a KS are realized as arbitrary methods. To minimize reevaluating the condition programs continuously, each condition program declares to the system the primitive kinds of situations in which it is interested. The condition method is triggered only when there occurs changes that create such situations (and is then given references to all of them).

This changes a polling action into an interrupt-driven one and is more efficient.

When executed, the condition method can search among the set of existing hypothetical interpretations for arbitrarily complex configurations of interest to its KS

See Hearsay-II pg 219

various ideas -

bottom-up and top-down processing

selective attention : allocate limited computing resources to the most important and most promising actions

More computer science concrete: Dealing with resources

I am taking some of this out of Operating System Concepts, Peterson and Silberschatz

A sequential program can be in one of four states:

running
blocked (waiting for an event to occur)
ready (waiting to be assigned to a processor)
deadlocked

Figure for state diagram of a process (page 320)

We, of course want to prevent or avoid deadlock. If one has precedence constraints, then whether you process in parallel or sequentially, you still need to deal with this.

The Critical Section Problem

A critical section is a section of code that must be allowed to complete atomically with no interruption that affects its successful completion or the data it is working on. Such things as context switching a thread or updating a record in a database are critical sections. Other things may go on at the same time, and the thread that is executing in the critical section may even lose its processor, but no other thread may do anything that affects the critical section. Should another thread want to execute that same critical section, it is forced to wait until the first thread finishes.

Critical sections are typically made as short as possible and often carefully optimized because they can significantly affect the concurrency of the program. They are often used to prevent data corruption of shared resources.

Synchronization mechanisms:
For us in java, a critical section is the same as a synchronized method or block.

Two main functions with respect to shared resources:

exclusion (concurrency constraints) - exclude certain processes from resources under circumstances

note that resources can be almost anything

(e.g., an instance of something)

priority constraints - schedule access to the resource according to priorities

Monitor - If one wants concurrent processes then you need to keep the resources and the monitor separate.

Monitor also has the shared object (or data members). If one can have multiple threads accessing data simultaneously, all shared data must be locked and provide synchronized methods to provide access to the object. This synchronization is vital to maintaining the integrity of any shared objects.

Consider - why isn't synchronized stuff in resources? (Usually if one takes time to think about these things they make sense.)

Example Resources :

Producer/consumer
unbounded buffer
bounded buffer
Reader/Writer

Appropriate monitor operations must be involved before and after resource access

Monitors typically WAIT, SIGNAL, QUEUE

Another smaller scale example involves separate windows on a workstation. One window could be used for input of information (the producer) and another wiindow could react to that information (the consumer).

Mutual Exclusion

if a process is executing in its critical section then no other process can be executing in its critical section

The Dining Philosophers Problem: Dijkstra (page 347)

Five philosophers spend their lives thinking and eating. The philosophers share a common circular table surrounded by five chairs, each belonging to one philosopher. In the center of the table there is a bowl of rice, and the table is laid with five chopsticks. When a philosopher thinks, he does not interact with his colleagues. From time to time, a philosopher gets hungry and tries to pick up the two chopsticks that are closest to him (the chopsticks that are between him and his left and right neighbors). A philosopher may only pick up one chopstick at a time. Obviously, he cannot pick up a chopstick that is already in the hand of a neighbor. When a hungry philosopher has both his chopsticks at the same time, he eats without releasing his chopsticks. When he is finished eating, he puts down both of his chopsticks and starts thinking again.

The problem: deadlock. Suppose all pick up the right chopstick at the same time. These hardworking philosophers could starve to death

Some possible solutions for you to implement

Allow at most four philosophers to be sitting simultaneoulsy at the table
Allow a philosopher to pick up his chopsticks only if both of them are available (note this should be done in a critical section)
Use an asymmetric solution. That is, an odd philosopher picks up first his left chopstick and then his right chopstick, while an even philosopher picks up his right chopstick then his left.

Why did I even bring this up? communication, Shared memory and synchronization. SUN and Java now have Jini, Java Spaces and Java Message Services to work with these ideas as well.

Controlling thread order - the Scheduler
(page 367 and 372 Java in 21 days)

non-preemptive - once the cpu has been allocated to a process, it can keep it until it wants to release it. Particularly troublesome for time-sharing systems. One needs to be "courtly", ask permission to schedule
preemptive - e.g., time-slicing, round-robin. "Many developers are surprised to learn that equal-priority Java threads are not automatically timesliced by a round-robin scheduler. Part of this surprise stems from the tendency to think threads within a program as equivlaent in theory to processes in an operating system: it has long been ingrained in our psyches that a timesliced scheduler is the fairest mechanism to deal with multiple processes. And, in an interactive user environment, that's usually the case. There are, however, occasions when a round-robin scheduler is not the fairest scheduling algorithm available..." (More in "Java Threads", page 160)

Priorities:

t1.getPriority(); // Returns this thread's priority. t2.setPriority(4); // Changes the priority of this thread. t2.setPriority(t1.getPriority() + 1)

setPriority - from 0 to 10

Synchronization in Java is about 5 times more expensive to call. Use sparingly.