Concurrent Programming CS 598 Class Notes

Lecture Notes for Concurrent Programming

One-Reference Class Instances
Confinement
- Method Confinement
- Thread Confinement
- Object Confinement
- Group Confinement

One-reference class instances cannot be interfered with.
- Only the reference holder can access the object.
- Read-write access is allowed.
One-reference class instances require no synchronization.
- But the one-active reference rule must be enforced.
- This is a static requirement, and therefore cheaper.
Confinement techniques enforce the one-reference rule.
- Confinement in methods, threads, objects, and groups.
This is a dangerous approach.
- Reference leaks can introduce concurrent accessors.
- Java encourages you to forget about references.
- Compliance cannot be completely automated or tested.
- Failures are disastrous.
  - Hard to find, but easy to fix (usually).

Mis-managing references may break the one-reference rule.
- Could lead to more than one accessor.
- Known as a reference leak or reference escape.

References leak via copies or unrestricted access.

Method calls copy references in and out of the method.

point p = new point(1, 2)
// one reference here, 
// one reference in draw().
draw(p)

Non-local references leak, even private ones.

private point p = new point(1, 2)
void rotate() { ... p.x ... }
void translate() { ... p.x ...}

Transitive references can leak local references.

private Array points[]
void add(x, y)
  point p = new point(x, y) 
  // whatever 
  points[0] = p

References local to a method are necessarily one-reference.
```
void draw() { ... point p = point(x, y) ... }
```

Other method calls could leak.

void draw()
  { point p = point(x, y) ... normalize(p) ... }

Safe private methods can be organized in a session.

public service() 
  point p = new point() ; m1(p) ; m2(p) ; ...
private m1(point p) { no p copy }
private m2(point p) { no p copy }

Called methods must respect the one-reference rule.
- But do they really?
- If they don't, there could be trouble.
Copying arguments may protect against abuses.
```
void operate() 
  point p = new point(1, 2) 
  // whatever
  untrusted(p.clone())
```
- The caller makes a copy of the instance.
- Defining clone() can be difficult.
- There still may be trouble (unsynchronized access).

Passing immutable arguments work.

Either the whole instance or pieces of the instance.

void operate() 
  point p = new point(1, 2) 

  untrusted(p.freeze())

  untrusted(p.x, p.y)

A thread is like a method; the same techniques apply.
- Particularly session-based designs.
Threads are more accessible than methods, encouraging leaks.
- Particularly Thread class level access.

Subclassing threads allows for per-thread data.

class PointThread extends Thread

  private point p;

  PointThread(Runnable r, int x, int y) 
    super(r) 
    p = new point(x, y)

Using the mutex, everything in an instance is protected.
- Assuming all references are local.
Internal instances should not be synchronized.
- An expensive redundancy, even without contention.
Adapter and subclass patterns can synchronize private instances.
- Never synchronized classes can be adapted.
- Synchronized classes can be subclassed from non-synchronized ones.

A group of instances can share an unsynchronized resource.
- One group member owns the resource at a time.
- The resource is private to the group.
- Similar to token passing.
Requires an intra-group resource passing protocol.
- Some synchronization required.
- Simple topologies, like a ring, help minimize synchronization.
Resilient operation is hard.
- The current resource owner dies.

One-reference instances don't require synchronization.
- Even with read-write access.
Confinement enforces the one-reference rule.
- Confine in methods, threads, objects, and groups.
Method confinement is simple and effective.
- Hand-offs to other methods can be tricky.
Thread confinement is similar to method confinement.
- The design can be intricate, though.
Object confinement requires simple synchronization.
- Be careful of redundant synchronization.
Group confinement passes resources among members.
- Also load balancing, sharing.
The one-reference rule is easily violated without care.
- And difficult to isolate as a problem.

This page last modified on 8 July 2003.