Package org.jcsp.lang

# Interface Any2AnyChannel

All Known Subinterfaces:
  `FilteredAny2AnyChannel`

public interface Any2AnyChannel
This defines the interface for an any-to-any Object channel, safe for use by many writers and many readers.

The only methods provided are to obtain the ends of the channel, through which all reading and writing operations are done. Only an appropriate channel-end should be plugged into a process – not the whole channel. A process may use its external channels in one direction only – either for writing or reading.

Actual channels conforming to this interface are made using the relevant `static` construction methods from `Channel`. Channels may be `synchronising`, `buffered`, `poisonable` or `both` (i.e. buffered and poisonable).

## Description

`Any2AnyChannel` is an interface for a channel which is safe for use by many reading and writing processes. Reading processes compete with each other to use the channel. Writing processes compete with each other to use the channel. Only one reader and one writer will actually be using the channel at any one time. This is managed by the channel – user processes just read from or write to it.

Please note that this is a safely shared channel and not a broadcaster or message gatherer. Currently, broadcasting or gathering has to be managed by writing active processes (see `DynamicDelta` for an example of broadcasting).

All reading processes and writing processes commit to the channel (i.e. may not back off). This means that the reading processes may not ``ALT`` on this channel.

The default semantics of the channel is that of CSP – i.e. it is zero-buffered and fully synchronised. A reading process must wait for a matching writer and vice-versa.

The `static` methods of `Channel` construct channels with either the default semantics or with buffering to user-specified capacity and a range of blocking/overwriting policies. Various buffering plugins are given in the `org.jcsp.util` package, but careful users may write their own.

The `Channel` methods also provide for the construction of `Poisonable` channels and for arrays of channels.

### Implementation Note and Caution

Fair servicing of readers and writers to this channel depends on the fair servicing of requests to enter a `synchronized` block (or method) by the underlying Java Virtual Machine (JVM). Java does not specify how threads waiting to synchronize should be handled. Currently, Sun's standard JDKs queue these requests - which is fair. However, there is at least one JVM that puts such competing requests on a stack - which is legal but unfair and can lead to infinite starvation. This is a problem for any Java system relying on good behaviour from `synchronized`, not just for these any-any channels.

Author:
  P.D. Austin and P.H. Welch
See Also:
  - `Channel`
  - `One2OneChannel`
  - `Any2OneChannel`
  - `One2AnyChannel`
  - `ChannelDataStore`

## Method Summary

Modifier and Type
Method
Description
`SharedChannelInput`
`in()`
Returns the input end of the channel.
`SharedChannelOutput`
`out()`
Returns the output end of the channel.

## Method Details

### in

SharedChannelInput in()
Returns the input end of the channel.

### out

SharedChannelOutput out()
Returns the output end of the channel.