System.out.println("------------------string--------------");
String s1 = "abc";
String s2 = "abc";
String s3 = new String("abc");
String s4 = new String("abc");
String s5 = s4.intern();

System.out.println(s1 == s2); // true
System.out.println(s1 == s3); // false
System.out.println(s3 == s4); // false
System.out.println(s4 == s5); // false
System.out.println(s1 == s5); // true
System.out.println(s3.hashCode() == s4.hashCode()); // true
System.out.println(new String("abc").hashCode() == new String("abc").hashCode()); // true

public boolean equals(Object obj) {
    return (this == obj);
}

System.out.println(s3.equals(s4)); //true

System.out.println("------------------integer--------------");
Integer a1 = 10;
Integer a2 = 10;
Integer b1 = 128;
Integer b2 = 128;

System.out.println(a1 == a2); // true
System.out.println(b1 == b2); // false
HashMap<Integer, Integer> maps = new HashMap<Integer, Integer>();
Integer i1 = 1;
Integer i2 = 2048;
Integer i3 = 2;
maps.put(i1, 1);
maps.put(2, 2);
maps.put(2048, 2048); //　Integer 的　hashCode 就返回的是里面的 intValue, equals 方法当然也比较的是 intValue
System.out.println(maps.get(i1)); // 1
System.out.println(maps.get(i2)); // 2048
System.out.println(maps.get(i3)); // 2

protected native Object clone() throws CloneNotSupportedException;

class Student implements Cloneable {
 public Object clone() {
            Object o = null;
            try {
                o = super.clone();
            } catch (CloneNotSupportedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return o;
    }
}

class Student implements Cloneable {
        private String name;
        private int age;
        private Professor pro;
        public Student(){}
        public Student(String name,int age,Professor pro){
            this.name=name;
            this.age=age;
            this.pro=pro;
        }
        public Object clone(){
            Student o=null;
            try {
                //Object中的clone()识别出你要复制的是哪一个对象。
                o=(Student)super.clone();
            } catch (CloneNotSupportedException e) {
                System.out.println(e.toString());
            }
            o.pro = (Professor)pro.clone();
            return o;
        }
}

class Student implements Serializable {
    private String name;
    private int age;
    Professor pro;
    public Student(){}
    public Student(String name,int age,Professor pro){
        this.name=name;
        this.age=age;
        this.pro=pro;
    }
    public Object deepClone() throws IOException, ClassNotFoundException{
        //将对象写到流中
        ByteArrayOutputStream bo=new ByteArrayOutputStream();
        ObjectOutputStream oo=new ObjectOutputStream(bo);
        oo.writeObject(this);
        //从流中读出来
        ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());
        ObjectInputStream oi=new ObjectInputStream(bi);
        return oi.readObject();
    }
}

class Professor implements Serializable{
    private String name;
    private int age;
}

public class TryCatchFinally {

    public static int test() {
        int num = 10;
        try {
            return num += 10;
        } finally {
            num = 80;
            return num;
        }
    }

    public static int test1() {
        int num = 10;
        try {
            return num += 10;
        } finally {
            num = 80;
        }
    }

    public static int test2() {
        Number n = new Number(10);
        try {
            return n.num;
        } finally {
            n.num = 80;
        }
    }

    public static Number test3() {
        Number n = new Number(10);
        try {
            return n;
        } finally {
            n.num = 80;
        }
    }



    static class Number {
        int num = 0;
        public Number(int i) {
            this.num = i;
        }
    }

    public static void main(String[] args) {
        System.out.println(test());
        System.out.println(test1());
        System.out.println(test2());
        System.out.println(test3().num);
    }

}

// 80
// 20
// 10
// 80

i = 0;
i = i++;
System.out.println(i);

/**
     * The maximum size of array to allocate.
     * Some VMs reserve some header words in an array.
     * Attempts to allocate larger arrays may result in
     * OutOfMemoryError: Requested array size exceeds VM limit
     */
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

class SingleTon {

    private static SingleTon singleTon = new SingleTon();
    public static int count1; //在准备阶段value初始值为0
    public static int count2 = 3; //在准备阶段value初始值为0

    //private static SingleTon singleTon = new SingleTon();// 顺序不一样, 结果不一致偶! 
    //类的加载机制! 加载, 连接(验证/准备/解析), 初始化, 使用, 卸载. 初始化的时候,按照static block 和 static statement出现的顺序一次执行语句.
    // 初始化之前, singleton = null, count1=count2=0, 这是虚拟机规范.由于是先执行 singleton = new Singleton(), 因此先执行
    // 私有构造函数, 然后 count1 = 1. count2 = 1. 然后又继续执行 count1没有变化, count2 = 3. 因此最后, count1 = 1, count2 = 3;
    // 对于这种形式的单例模式, 如果私有构造器需要对静态成员变量进行赋值, 我们一定要把 构造单列的语句放在最后面!

    private SingleTon() {
        count1++;
        count2++;
    }

    public static SingleTon getInstance() {
        return singleTon;
    }
}

public class Test {
    public static void main(String[] args) {
        SingleTon singleTon = SingleTon.getInstance();
        System.out.println("count1=" + singleTon.count1);
        System.out.println("count2=" + singleTon.count2);
    }
}

Integer a1 = 10;
Integer a2 = 10;
Integer b1 = 128;
Integer b2 = 128;
System.out.println(a1 == a2); // true
System.out.println(b1 == b2); // 不设置JVM参数的情况下是 false

import java.util.Date;
import java.util.concurrent.CountDownLatch;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Java program to demonstrate How to use CountDownLatch in Java. CountDownLatch is
 * useful if you want to start main processing thread once its dependency is completed
 * as illustrated in this CountDownLatch Example
 * 
 * @author Javin Paul
 */
public class CountDownLatchDemo {

    public static void main(String args[]) {
       final CountDownLatch latch = new CountDownLatch(3);
       Thread cacheService = new Thread(new Service("CacheService", 1000, latch));
       Thread alertService = new Thread(new Service("AlertService", 1000, latch));
       Thread validationService = new Thread(new Service("ValidationService", 1000, latch));

       cacheService.start(); //separate thread will initialize CacheService
       alertService.start(); //another thread for AlertService initialization
       validationService.start();

       // application should not start processing any thread until all service is up
       // and ready to do there job.
       // Countdown latch is idle choice here, main thread will start with count 3
       // and wait until count reaches zero. each thread once up and read will do
       // a count down. this will ensure that main thread is not started processing
       // until all services is up.

       //count is 3 since we have 3 Threads (Services)

       try{
            latch.await();  //main thread is waiting on CountDownLatch to finish
            System.out.println("All services are up, Application is starting now");
       }catch(InterruptedException ie){
           ie.printStackTrace();
       }

    }

}

/**
 * Service class which will be executed by Thread using CountDownLatch synchronizer.
 */
class Service implements Runnable{
    private final String name;
    private final int timeToStart;
    private final CountDownLatch latch;

    public Service(String name, int timeToStart, CountDownLatch latch){
        this.name = name;
        this.timeToStart = timeToStart;
        this.latch = latch;
    }

    @Override
    public void run() {
        try {
            Thread.sleep(timeToStart);
        } catch (InterruptedException ex) {
            Logger.getLogger(Service.class.getName()).log(Level.SEVERE, null, ex);
        }
        System.out.println( name + " is Up");
        latch.countDown(); //reduce count of CountDownLatch by 1
    }

}

Output:
ValidationService is Up
AlertService is Up
CacheService is Up
All services are up, Application is starting now

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Java program to demonstrate how to use CyclicBarrier in Java. CyclicBarrier is a
 * new Concurrency Utility added in Java 5 Concurrent package.
 *
 * @author Javin Paul
 */
public class CyclicBarrierExample {

    //Runnable task for each thread
    private static class Task implements Runnable {

        private CyclicBarrier barrier;

        public Task(CyclicBarrier barrier) {
            this.barrier = barrier;
        }

        @Override
        public void run() {
            try {
                System.out.println(Thread.currentThread().getName() + " is waiting on barrier");
                barrier.await();
                System.out.println(Thread.currentThread().getName() + " has crossed the barrier");
            } catch (InterruptedException ex) {
                Logger.getLogger(CyclicBarrierExample.class.getName()).log(Level.SEVERE, null, ex);
            } catch (BrokenBarrierException ex) {
                Logger.getLogger(CyclicBarrierExample.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }

    public static void main(String args[]) {

        //creating CyclicBarrier with 3 parties i.e. 3 Threads needs to call await()
        final CyclicBarrier cb = new CyclicBarrier(3, new Runnable(){
            @Override
            public void run(){
                //This task will be executed once all thread reaches barrier
                System.out.println("All parties are arrived at barrier, lets play");
            }
        });

        //starting each of thread
        Thread t1 = new Thread(new Task(cb), "Thread 1");
        Thread t2 = new Thread(new Task(cb), "Thread 2");
        Thread t3 = new Thread(new Task(cb), "Thread 3");

        t1.start();
        t2.start();
        t3.start();

    }
}

Output:
Thread 1 is waiting on barrier
Thread 3 is waiting on barrier
Thread 2 is waiting on barrier
All parties have arrived at barrier, lets play
Thread 3 has crossed the barrier
Thread 1 has crossed the barrier
Thread 2 has crossed the barrier

count++;
// 拆分成指令
1. read count from memory
2. update count
3. write updated count to memory

public Singleton getInstance() {
    if (_instance == null) {// race condition if two threads sees _instance=null
        _instance = new Singleton();
    }
}

if(!hashTable.contains(key)) {
    hashTable.put(key,value);
}

from tornado import ioloop
class ServiceBase():
    def __init__(self):
        self.__http_client = AsyncHTTPClient()

    def start_register(self, delay=5):
        io = ioloop.IOLoop.instance()
        self._register_thread = io.add_timeout(delay, self.register)

    def register(self):
        self.registerA()

    def on_fail(self):
        self.start_register(delay=30)

    def registerA(self):
        self.__http_client.fetch('', self.on_registerA_succ, self.on_fail)

    def on_registerA_succ(self):
        self.registerB()

    def registerB(self):
        self.__http_client.fetch('', self.on_registerB_succ, self.on_fail)

    def on_registerB_succ(self):
        self.registerC()

    def registerC(self):
        .....

    .....

public interface Runnable {
    public abstract void run();
}

public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

ExecutorService pool = Executors.newCachedThreadPool();
     Future future = pool.submit(new Callable{
           public void call(){
                   //TODO
           }
    });

public interface Future<V> {
    //
    boolean cancel(boolean mayInterruptIfRunning);


    boolean isCancelled();


    boolean isDone();
    //用来获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回；
    V get() throws InterruptedException, ExecutionException;

    //用来获取执行结果，如果在指定时间内，还没获取到结果，就直接返回null。
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

FutureTask(Callable callable) FutureTask(Runnable runnable, V result)

FutureTask task = new FutureTask(new Callable{
        public void call(){
              //TODO
        }
  });
 Thead thread = new Thread(task);
 thread.start();

public class ABCSyncNotifyWell {
    // 实际上三个线程互斥的， 同一个时刻只有一个线程执行。我们的条件变量应该是控制全局状态，每个线程根据这个全局状态决定是等待还是执行。条件控制变量的设计合理性非常重要！
    public static void main(String[] args) {
        Object lockABC = new Object();
        Signal s = new Signal();
        Thread ta = new Thread(new A(lockABC, s));
        Thread tb = new Thread(new B(lockABC, s));
        Thread tc = new Thread(new C(lockABC, s));
        ta.start();
        tb.start();
        tc.start();
    }

    private static class Signal {
        boolean A = true;
        boolean B = false;
        boolean C = false;
    }

    private static class A implements Runnable {

        private Object lockABC = null;
        private Signal s = null;
        public A(Object lock, Signal s) {
            this.lockABC = lock;
            this.s = s;
        }
        @Override
        public void run() {
            while (true) {
                synchronized(this.lockABC) {
                    while (!s.A) {
                        try {
                            lockABC.wait();
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }

                    System.out.println("A");
                    this.s.A = false;
                    this.s.B = true;
                    this.s.C = false;
                    lockABC.notifyAll();

                }
            }

        }

    }

    private static class B implements Runnable {

        private Object lockABC = null;
        private Signal s = null;
        public B(Object lock, Signal s) {
            this.lockABC = lock;
            this.s = s;
        }
        @Override
        public void run() {
            while (true) {
                synchronized(this.lockABC) {
                    while (!s.B) {
                        try {
                            lockABC.wait();
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println("B");
                    this.s.A = false;
                    this.s.B = false;
                    this.s.C = true;
                    lockABC.notifyAll();

                }
            }

        }

    }

    private static class C implements Runnable {
        private Object lockABC = null;
        private Signal s = null;
        public C(Object lock, Signal s) {
            this.lockABC = lock;
            this.s = s;
        }
        @Override
        public void run() {
            while (true) {
                synchronized(this.lockABC) {
                    while (!s.C) {
                        try {
                            lockABC.wait();
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println("C");
                    this.s.A = true;
                    this.s.B = false;
                    this.s.C = false;
                    lockABC.notifyAll();
                }
            }

        }
    }
}

public class ABCCondition {
    private static Lock lock = new ReentrantLock();
    private static int conditionVar = 0;
    private static Condition A = lock.newCondition();
    private static Condition B = lock.newCondition();
    private static Condition C = lock.newCondition();

    static class A extends Thread {

        @Override
        public void run() {
            lock.lock();
            try {
                for (int i = 0; i < 10; i ++) {
                    while (conditionVar % 3 != 0) {
                        A.await();
                    }
                    System.out.println("A");
                    conditionVar ++;
                    B.signal();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }

    static class B extends Thread {

        @Override
        public void run() {
            lock.lock();
            try {
                for (int i = 0; i < 10; i ++) {
                    while (conditionVar % 3 != 1) {
                        B.await();
                    }
                    System.out.println("B");
                    conditionVar ++;
                    C.signal();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }

    static class C extends Thread {

        @Override
        public void run() {
            lock.lock();
            try {
                for (int i = 0; i < 10; i ++) {
                    while (conditionVar % 3 != 2) {
                        C.await();
                    }
                    System.out.println("C");
                    conditionVar ++;
                    A.signal();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {

        new A().start();
        new B().start();
        new C().start();
    }
}

public class ABCSemaphore {

    private static Semaphore A = new Semaphore(1);
    private static Semaphore B = new Semaphore(0);
    private static Semaphore C = new Semaphore(0);

    static class A extends Thread {

        @Override
        public void run() {
            try {
                for (int i = 0; i < 10; i++) {
                    A.acquire();
                    System.out.println("A");
                    B.release();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    static class B extends Thread {

        @Override
        public void run() {
            try {
                for (int i = 0; i < 10; i++) {
                    B.acquire();
                    System.out.println("B");
                    C.release();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    static class C extends Thread {

        @Override
        public void run() {
            try {
                for (int i = 0; i < 10; i++) {
                    C.acquire();
                    System.out.println("C");
                    A.release();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }

    public static void main(String[] args) throws InterruptedException {

        new A().start();
        new B().start();
        new C().start();
    }
}

public class Counter{

  private int count = 0;

  public int inc(){
    synchronized(this){
      return ++count;
    }
  }
}

  private Lock lock = new Lock();
  private int count = 0;

  public int inc(){
    lock.lock();
    int newCount = ++count;
    lock.unlock();
    return newCount;
  }
}

public class Lock{

  private boolean isLocked = false;

  public synchronized void lock()
  throws InterruptedException{
    while(isLocked){
      wait();
    }
    isLocked = true;
  }

  public synchronized void unlock(){
    isLocked = false;
    notify();
  }
}

public class PCModel {

    public static void main(String[] args) {
        SharedObject so = new SharedObject();
        Producer p = new Producer(so);
        Consumer c1 = new Consumer(so);
        Consumer c2 = new Consumer(so);

        new Thread(c1, "c1").start();
        new Thread(c2, "c2").start();
        Thread pt = new Thread(p,"p");
        //pt.setPriority(1);
        pt.start();

    }

    static class SharedObject {
        private int[] buffer = new int[64];
        private int rindex = 0;
        private int windex = 0;
        private int count = 0;

        public int get() {
            synchronized(this) {
                while (count == 0) {
                    try {
//                      System.out.println(Thread.currentThread().getName()+ " get() wait");
                        this.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                int item = this.buffer[rindex];
                rindex = (rindex+1)%64;
                count --;
                this.notify();
                return item;
            }       
        }

        public void put(int product) {
            synchronized(this) {
                while (count >= buffer.length) {
                    try {
                        this.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                this.buffer[windex] = product;
                windex = (windex+1)%64;
                count ++;
                this.notifyAll();
            }
        }
    }

    static class Producer implements Runnable {
        SharedObject so = null;
        Producer(SharedObject so) {
            this.so = so;
        }
        @Override
        public void run() {
            int i = 0;
            while(true){
                so.put(++i);
                System.out.println(Thread.currentThread().getName()+"-" + i);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }

    }

    static class Consumer implements Runnable {
        SharedObject so = null;
        Consumer(SharedObject so) {
            this.so = so;
        }
        @Override
        public void run() {
            System.out.println(Thread.currentThread().getName() + " started");
            while(true){
                int item = so.get();
                System.out.println(Thread.currentThread().getName()+"-"+item);  
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }

    }


}

public class PCModel2 {


    static class SharedObject {
        private ReentrantLock lock = new ReentrantLock();

        private Condition notEmpty = lock.newCondition();
        private Condition notFull = lock.newCondition();
        private int[] buffer = new int[64];
        private int rindex = 0;
        private int windex = 0;
        private int count = 0;

        public int get() {
            lock.lock();
            try {
                while (count == 0) {
                    notEmpty.await();
                }
                int item = this.buffer[rindex];
                rindex = (rindex+1)%buffer.length;
                count --;
                notFull.signal();
                return item;
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
            return 0;
        }

        public void put(int item) {
            lock.lock();
            try {
                while (count >= buffer.length) {
                    notFull.await();
                }
                this.buffer[windex] = item;
                count ++;
                windex = (windex+1)%buffer.length;
                notEmpty.signal();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }

    static class Producer implements Runnable {
        private SharedObject so = null;

        Producer(SharedObject so) {
            this.so = so;
        }
        @Override
        public void run() {
            int i = 0;
            while(true){
                so.put(++i);
                System.out.println(Thread.currentThread().getName()+"-" + i);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }

    }

    static class Consumer implements Runnable {
        private SharedObject so = null;
        Consumer(SharedObject so) {
            this.so = so;
        }

        public void run() {
            while (true) {
                int item = so.get();
                System.out.println(Thread.currentThread().getName() + "-" + item);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        SharedObject so = new SharedObject();
        Producer p = new Producer(so);
        Consumer c1 = new Consumer(so);
        Consumer c2 = new Consumer(so);

        new Thread(c1, "c1").start();
        new Thread(c2, "c2").start();
        Thread pt = new Thread(p,"p");
        //pt.setPriority(1);
        pt.start();
    }
}

public class Semaphore {
  private boolean signal = false;

  public synchronized void take() {
    this.signal = true;
    this.notify();
  }

  public synchronized void release() throws InterruptedException{
    while(!this.signal) wait();
    this.signal = false;
  }

}

public class CountingSemaphore {
  private int signals = 0;

  public synchronized void take() {
    this.signals++;
    this.notify();
  }

  public synchronized void release() throws InterruptedException{
    while(this.signals == 0) wait();
    this.signals--;
  }

public class BoundedSemaphore {
  private int signals = 0;
  private int bound   = 0;

  public BoundedSemaphore(int upperBound){
    this.bound = upperBound;
  }

  public synchronized void take() throws InterruptedException{
    while(this.signals == bound) wait();
    this.signals++;
    this.notify();
  }

  public synchronized void release() throws InterruptedException{
    while(this.signals == 0) wait();
    this.signals--;
    this.notify();
  }
}

//使用volatile关键字保证线程可见性
private volatile int value;
public final int get(){
    return value;
}

public final int incrementAndGet(){
    for (; ; ) {
        int current = get();
        int next = current + 1;
        if (compareAndSet(current, next))
            return next;
    }
}

 public final int getAndIncrement() {
    for (;;) {
        int current = get();
        int next = current + 1;
        if (compareAndSet(current, next))
            return current;
    }
}

public final boolean compareAndSet(int expect, int update) {
    return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}

class SimulatedCAS {
    private long value;

    public synchronized long get() {
        return value;
    }

    public synchronized boolean compareAndSwapLong(long expected, long newValue) {
        long oldValue = value;
        if (oldValue == expected) {
            value = newValue;
            return true;
        }
        return false;
    }

}

class SimulatedCASCounter {
    private SimulatedCAS value;

    public final long getCounter() {
        return value.get();
    }

    public long incrementAndGet() {
        for (;;) {
            long expected = value.get();
            long next = expected + 1;
            if (value.compareAndSwapLong(expected, next)) {
                return next;
            }
        }
    }

    public long getAndIncrement() {
        for (;;) {
            long expected = value.get();
            long next = expected + 1;
            if (value.compareAndSwapLong(expected, next)) {
                return expected;
            }
        }
    }

}

public class CASCounter {
    private Unsafe unsafe;
    private volatile long counter = 0;
    private long offset;

    private Unsafe getUnsafe() throws IllegalAccessException, NoSuchFieldException {
        Field f = Unsafe.class.getDeclaredField("theUnsafe");
        f.setAccessible(true);
        return (Unsafe) f.get(null);
    }

    public CASCounter() throws Exception {
        unsafe = getUnsafe();
        offset = unsafe.objectFieldOffset(CASCounter.class.getDeclaredField("counter"));
    }

    public void increment(){
        long expected = counter;
        while (!unsafe.compareAndSwapLong(this, offset, expected, expected+1)) {
            expected = counter;
        }
    }

    public long incrementAndGet(){
        long expected = counter;
        while (!unsafe.compareAndSwapLong(this, offset, expected, expected+1)) {
            expected = counter;
        }
        return expected + 1;
    }

    public long getAndIncrement() {
        long expected = counter;
        while (!unsafe.compareAndSwapLong(this, offset, expected, expected+1)) {
            expected = counter;
        }
        return expected;
    }
    public long getCounter() {
        return counter;
    }
}

class CountDownLatch {
    volatile int count;
    public CountDownLatch(int cnt) {
        count = cnt;
    }
    public synchronized void countDown() {
        count --;
        if (count == 0) notifyAll();
    }
    public synchronized void await() {
        while (count != 0) {
            wait();
        }
    }
}

class Generation {
    boolean broken;
}
class CyclicBarrier {
    int parties;
    int count;
    Runnable event;
    Generation generation = new Generation();
    public CyclicBarrier(int parties, Runnable event) {
        this.parties = parties;
        this.count = parties;
        this.event = event;
    }
    public synchronized int await() {
        Generation g = this.generation;
        int index = --this.count;
        if (index == 0) {
            event.run();
            //reset
            this.count = this.parties;
            this.generation = new Generation();

            notifyAll();
            return index;
        }
        while(true) {
            wait();
            if (g != this.generation) {
                return index;
            }
        }
    }
}