import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.locks.*;

class SynchronizedList<E> {
  
  ArrayList<E> list;
  ReentrantReadWriteLock lock;
  Lock rlock, wlock;
  
  public SynchronizedList() {
    list = new ArrayList<>();
    lock = new ReentrantReadWriteLock();
    rlock = lock.readLock();
    wlock = lock.writeLock();
  }
  
  public SynchronizedList(int capacity) {
    list = new ArrayList<>(capacity);
    lock = new ReentrantReadWriteLock();
    rlock = lock.readLock();
    wlock = lock.writeLock();
  }
  
  public void listWriteLock() {
    wlock.lock();
  }
  
  public void listWriteUnlock() {
    wlock.unlock();
  }
  
  public void listReadLock() {
    rlock.lock();
  }
  
  public void listReadUnlock() {
    rlock.unlock();
  }
  
  public void add(E e) {
    wlock.lock();
    list.add(e);
    wlock.unlock();
  }
  
  public void add(int index, E e) {
    wlock.lock();
    list.add(index, e);
    wlock.unlock();
  }
  
  public boolean addAll(Collection<? extends E> c) {
    wlock.lock();
    boolean result = list.addAll(c);
    wlock.unlock();
    return result;
  }
  
  public void clear() {
    wlock.lock();
    list.clear();
    wlock.unlock();
  }
  
  public boolean contains(Object o) {
    rlock.lock();
    boolean result = list.contains(o);
    rlock.unlock();
    return result;
  }
  
  public void ensureCapacity(int minCapacity) {
    wlock.lock();
    list.ensureCapacity(minCapacity);
    wlock.unlock();
  }
  
  public E get(int index) {
    rlock.lock();
    E e = list.get(index);
    rlock.unlock();
    return e;
  }
  
  public int indexOf(Object o) {
    rlock.lock();
    int index = list.indexOf(o);
    rlock.unlock();
    return index;
  }
  
  public boolean isEmpty() {
    rlock.lock();
    boolean empty = list.isEmpty();
    rlock.unlock();
    return empty;
  }
  
  public int lastIndexOf(Object o) {
    rlock.lock();
    int lastIndex = list.lastIndexOf(o);
    rlock.unlock();
    return lastIndex;
  }
  
  public E remove(int index) {
    wlock.lock();
    E e = list.remove(index);
    wlock.unlock();
    return e;
  }
  
  public E set(int index, E element) {
    wlock.lock();
    E e = list.set(index, element);
    wlock.unlock();
    return e;
  }
  
  public int size() {
    rlock.lock();
    int lsize = list.size();
    rlock.unlock();
    return lsize;
  }
  
  List<E> subList(int fromIndex, int toIndex) {
    rlock.lock();
    List<E> newlist = list.subList(fromIndex, toIndex);
    rlock.unlock();
    return newlist;
  }
  
  class SyncrhonizedIterator implements Iterator<E> {
    Iterator it;
    Lock rlock;
    Lock wlock;
    
    public SyncrhonizedIterator(Lock readlock, Lock writelock) {
      rlock = readlock;
      wlock = writelock;
      it = list.iterator();
    }
    
    public boolean hasNext() {
      rlock.lock();
      boolean hasnext = it.hasNext();
      rlock.unlock();
      return hasnext;
    }
    
    public E next() {
      rlock.lock();
      Object o = it.next();
      rlock.unlock();
      return (E)o;
    }
    
    public void remove() {
      wlock.lock();
      it.remove();
      wlock.unlock();
    }
  }
}

class ListModifierThread extends Thread {
  Random rand;
  SynchronizedList<Integer> list;
  //ArrayList<Integer> list;
  
  public ListModifierThread(SynchronizedList<Integer> list) {
  //public ListModifierThread(ArrayList<Integer> list) {
    this.list = list;
    rand = new Random( new Date().getTime() );
  }
  
  public void run() {
    for(int i=0; i<1000; i++)
      list.add( rand.nextInt(1000) );
 
    for(int i=0; i<1000; i++)
      list.remove(0);
    
    if( list.isEmpty() ) 
      System.out.println( this.getName() +": list is empty!");
    else
      System.out.println( this.getName() +": list is NOT empty!");    
  }
}

class ListSynchronizer {
  public static void main(String []args) {
    SynchronizedList<Integer> list = new SynchronizedList<>();
    //ArrayList<Integer> list = new ArrayList<>();
    
    for(int i=0; i<10; i++) {
      (new ListModifierThread(list)).start();
    }
  }
}