请设计一个排序系统，能让每个排队的用户，都能看到自己在队列中

//观察者设计模式
//队列为被观察者，人为观察者
//当有人离开，通知所有在队列里的人
//用两个线程模拟入队，跟有人离开
package 队列系统线程;

import java.util.ArrayList;

public class Main {

    //观察者
    public static class Person{

        public String name;
        public Person(String name) {
            this.name = name;
        }

        public void listChange(int i){
            System.out.println(name+"当前位置为:"+i);
        }
    }
    //被观察者
    public static class ObjectiveList{


        public static ArrayList<Person> list;
        public ObjectiveList(){
            this.list = new ArrayList<>();
        }

        //增加到队尾
        public synchronized void addPerson(Person person){
            System.out.println(person.name+"加入队伍!");
            list.add(person);

        }

        //当前面的有人离开，通知所有人当前位置
        public synchronized void removePerson(int i){
            System.out.println(list.get(i).name+"离开队伍!");
            list.remove(i);

            for(int j=0;j<list.size();++j){
                list.get(j).listChange(j);
            }

        }

        public int getPersonSize(){
            return list.size();
        }

    }


    //有人加入，入队进程
    public static class ObjListAddPersonThread extends Thread{

            public ObjectiveList list;

            public ObjListAddPersonThread(ObjectiveList list) {

                this.list = list;
            }

            @Override
            public void run() {
                int i=0;
                while(true){


                    list.addPerson(new Person("name"+i++));


                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        // TODO 自动生成的 catch 块
                        e.printStackTrace();
                    }
                }
            }

    }

    //有人离开,位置发生改变进程
    public static class ObjListRemovePersonThread extends Thread{
        public ObjectiveList list;

        public ObjListRemovePersonThread(ObjectiveList list) {

            this.list = list;
        }

        @Override
        public void run() {
            int j=0;
            while(true){

                if(list.getPersonSize()==0){
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        // TODO 自动生成的 catch 块
                        e.printStackTrace();
                    }
                    continue;
                }

                list.removePerson(j++%list.getPersonSize());
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    // TODO 自动生成的 catch 块
                    e.printStackTrace();
                }

            }
        }


    }




    public static void main(String[] args) {

        ObjectiveList objectiveList = new ObjectiveList();

        ObjListAddPersonThread objListAddPersonThread = new ObjListAddPersonThread(objectiveList);
        ObjListRemovePersonThread objListRemovePersonThread = new ObjListRemovePersonThread(objectiveList);

        objListAddPersonThread.start();
        objListRemovePersonThread.start();

    }



}

Test.java

import java.util.ArrayList;

public class Test {

    /*请设计一个排序系统，能让每个排队的用户，都能看到自己在队列中所处的位置和变化，
     * 队列有人随时有可能加入和退出，当有人退出影响到自己的位置的时需要及时反馈到用户。
     * 思路：用JDk内置的Observer接口和Observable类完成观察者模式
     * 用户为观察者，系统为被观察者，另外添加删除的同时用ArrayList来储存User，以便于获取位置
     */


    final static int addCode=0;
    final static int removeCode=1;


    static ArrayList<User> ulist=new ArrayList<>();
    static QueueSystem qs=new QueueSystem();

    public  void addUser(User u){
        ulist.add(u);
        qs.addObserver(u);

    }

    public  void removeUser(User u){
        ulist.remove(u);
        qs.deleteObserver(u);

    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        User u1=new User(ulist);
        User u2=new User(ulist);
        Test t = new Test();
        t.addUser(u1);
        t.addUser(u2);
        qs.somethingChange();
    }

}

User.java

import java.util.ArrayList;
import java.util.Observable;
import java.util.Observer;

public class User implements Observer{

    private int position;
    private ArrayList<User> ulist;

    public User(ArrayList<User> list){
        this.ulist=list;

    }

    public int getPosition() {
        return position;
    }

    public void setPosition(int position) {
        this.position = position;
    }

    @Override
    public void update(Observable o, Object arg) {
        // TODO Auto-generated method stub
        position=ulist.indexOf(this);
        System.out.println(arg+"your position is "+position);

    }

}

QueueSystem

import java.util.ArrayList;
import java.util.Observable;
import java.util.Observer;

public class QueueSystem extends Observable{

    public void somethingChange(){

        setChanged();
        notifyObservers("队列变化!");

    }
}

import java.util.ArrayList;
import java.util.List;

final class WaitSystem {

    //正在排队的用户
    private List<AbstractUser> waitingUsers = new ArrayList<>();

    /**
     * 加入排队的用户
     *
     * @param user
     * @return
     */
    public synchronized int addUser(AbstractUser user) {
        if (user == null) {
            throw new NullPointerException();
        }
        user.setPosition(waitingUsers.size() + 1);
        waitingUsers.add(user);
        return user.getPosition();
    }

    /**
     * 移除用户
     *
     * @param user
     */
    public synchronized void removeUser(AbstractUser user) {
        if (user == null) {
            throw new NullPointerException();
        }
        if (!waitingUsers.remove(user)) {
            return;
        }
        //获得user之前在队列中的位置, 后面的用户位置减一
        int pos = user.getPosition() - 1;
        for (int i = pos; i < waitingUsers.size(); i++) {
            waitingUsers.get(i).setPosition(i + 1);
            waitingUsers.get(i).onStatusChanged();
        }
    }
}

abstract class AbstractUser {

    protected int position;

    public int getPosition() {
        return position;
    }

    public void setPosition(int position) {
        this.position = position;
    }

    abstract void onStatusChanged();
}

class User extends AbstractUser {

    public void onStatusChanged() {
        System.out.println("my position is " + position);
    }
}

import java.util.LinkedList;
/**
 * Created by WZW on 2017/08/08.
 * 请设计一个排序系统，能让每个排队的用户，
 * 都能看到自己在队列中所处的位置和变化，
 * 队列有人随时有可能加入和退出，
 * 当有人退出影响到自己的位置的时需要及时反馈到用户
 */
public class PaiDuiSystem {
    public static void main(String args[]){
        QueueSystem queueSystem=new QueueSystem();
        People people=new People(queueSystem);
        People people1=new People(queueSystem);
        People people2=new People(queueSystem);
        people1.InQueue();
        people2.InQueue();
        people.InQueue();
        people1.PrintNow();
        people1.outQueue();
    }

}
class QueueSystem{
    LinkedList<People> list=new LinkedList<>();
    //入队
    public synchronized int InQueue(People people){
        this.list.addLast(people);
        return list.size();
    }
    //出队
    public void OutQueue(People people){
        int index=list.indexOf(people);
        if(index<0) {
            System.out.println("您不在队中");
        }else{
            //提示后续的人
            synchronized (this) {
                list.remove(index);
                for(int i=index;i<list.size();i++){
                    list.get(i).PrintChange(i+1);
                }
            }
        }
    }
    //获得当前位置
    public int getNow(People people){
        return list.indexOf(people);
    }
}
class People{
    QueueSystem queueSystem;
    public People(QueueSystem queueSystem){
        this.queueSystem=queueSystem;
    }
    //入队
    public void InQueue(){
        int index=queueSystem.InQueue(this);
        System.out.println("我入队了，当前位置："+index);
    }
    //出队
    public void outQueue(){
        queueSystem.OutQueue(this);
    }
    //当前位置
    public void PrintNow(){
        int index=queueSystem.getNow(this);
        if(index<0){
            System.out.println("您当前不在队中");
        }else{
            System.out.println("我的当前位置:"+(index+1));
        }
    }
    //如果有改动
    public void PrintChange(int index){
        System.out.println("有人出队，我的当前位置为："+index);
    }
}