The document describes a message system for communication between different components in a multi-threaded application. It defines an Address class that uses an atomic integer to generate unique IDs for each component. Messages are sent between Addresses and stored in queues, with the MessageSystem executing incoming messages on the appropriate components by looking them up by Address. Concrete message types like MsgUpdateUserId define the data passed and handling for different component types.

18. public final boolean compareAndSet(int expect, int update) {
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}
public final int incrementAndGet() {
while (true) {
int current = get(); //get() возвращает текущее значение (volatile)
int next = current + 1;
if (compareAndSet(current, next))
return next;
}
}

19. ―
―
―
―
―

21. ―
―
―
―
―

25. ―

27. public class Address {
static private AtomicInteger abonentIdCreator = new AtomicInteger();
final private int abonentId;
public Address(){
this.abonentId = abonentIdCreator.incrementAndGet();
}
public int hashCode() {
return abonentId;
}
}
public interface Abonent {
Address getAddress();
}

28. public abstract class Msg {
final private Address from;
final private Address to;
public Msg(Address from, Address to){
this.from = from;
this.to = to;
}
protected Address getFrom(){
return from;
}
protected Address getTo(){
return to;
}
public abstract void exec(Abonent abonent);
}

29. public abstract class MsgToFrontend extends Msg {
public MsgToFrontend(Address from, Address to) {
super(from, to);
}
public void exec(Abonent abonent) {
if( abonent instanceof Frontend ){
exec((Frontend)abonent);
}
}
public abstract void exec(Frontend frontend);
}

30. public class MsgUpdateUserId extends MsgToFrontend {
final private int sessionId;
final private int userId;
public GameInfoMsg(Address from, Address to, int sessionId, int userId) {
super(from, to);
this. sessionId = sessionId;
this. userId = userId;
}
public void exec(Frontend frontend) {
frontend.updateUserId(sessionId, userId);
}
}

31. Msg
MsgToAS MsgToFrontend
MsgUpdateUserIdMsgGetUserId
- Address from
- Address to
- String name
- Integer sessionId
- Integer sessionId
- Integer userId

32. private Map<Address, ConcurrentLinkedQueue<Msg>> messages
= new HashMap<Address, ConcurrentLinkedQueue<Msg>>();
public void sendMessage(Msg message){
Queue<Msg> messageQueue = messages.get(message.getTo());
messageQueue.add(message);
}
public void execForAbonent(Abonent abonent) {
Queue<Msg> messageQueue = messages.get(abonent.getAddress());
while(!messageQueue.isEmpty()){
Msg message = messageQueue.poll();
message.exec(abonent);
}
}

35. public class AddressService {
private Map<Class<?>, Address> addresses = new HashMap<Class<?>, Address>();
public Address getAddress(Class<?> abonentClass) {
return addresses.get(abonentClass);
}
public void setAddress(Abonent abonent) {
addresses.put(abonent.getClass(), abonent.getAddress());
}
}

37. public void run() {
while (true) {
messageSystem.execForAbonent(this);
Thread.sleep(TICK_TIME);
}
}

38. 14. Плюсы и минусы многопоточных приложений
15. Способы взаимодействия потоков
16. java.util.concurrent
17. MessageSystem. Address и Abonent