package com.zsr.test.cyclicBarrier;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class Runner implements Runnable {
  private CyclicBarrier barrier;
  private String name;
  public Runner(CyclicBarrier barrier, String name) {
    super();
    this.barrier = barrier;
    this.name = name;
  }
  @Override
  public void run() {
    try {
      Thread.sleep(100);
      System.out.println(name + " 准备OK.");
      barrier.await();
    } catch (InterruptedException e) {
      e.printStackTrace();
    } catch (BrokenBarrierException e) {
      e.printStackTrace();
    }
    System.out.println(name + " Go!!");
  }
}

package com.zsr.test.cyclicBarrier;
import java.io.IOException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CyclicBarrierTest {
  public static void main(String[] args) throws IOException, InterruptedException {
    CyclicBarrier barrier = new CyclicBarrier(3);
    ExecutorService executor = Executors.newFixedThreadPool(3);
    executor.submit(new Thread(new Runner(barrier, "zhangsan")));
    executor.submit(new Thread(new Runner(barrier, "lisi")));
    executor.submit(new Thread(new Runner(barrier, "wangwu")));
    executor.shutdown();
  }
}

public CyclicBarrier(int parties) {
        this(parties, null);
}

public CyclicBarrier(int parties, Runnable barrierAction) {
        if (parties <= 0) throw new IllegalArgumentException();
        this.parties = parties;
        this.count = parties;
        this.barrierCommand = barrierAction;
}

public int await() throws InterruptedException, BrokenBarrierException {
        try {
            return dowait(false, 0L);
        } catch (TimeoutException toe) {
            throw new Error(toe); // cannot happen;
        }
    }
 public int await(long timeout, TimeUnit unit)
        throws InterruptedException,
               BrokenBarrierException,
               TimeoutException {
        return dowait(true, unit.toNanos(timeout));
    }

private int dowait(boolean timed, long nanos)
        throws InterruptedException, BrokenBarrierException,
               TimeoutException {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            final Generation g = generation;
            if (g.broken)
                throw new BrokenBarrierException();
            if (Thread.interrupted()) {
                breakBarrier();
                throw new InterruptedException();
            }
           int index = --count;
           if (index == 0) {  // tripped
               boolean ranAction = false;
               try {
                   final Runnable command = barrierCommand;
                   if (command != null)
                       command.run();
                   ranAction = true;
                   nextGeneration();
                   return 0;
               } finally {
                   if (!ranAction)
                       breakBarrier();
               }
           }
            // loop until tripped, broken, interrupted, or timed out
            for (;;) {
                try {
                    if (!timed)
                        trip.await();
                    else if (nanos > 0L)
                        nanos = trip.awaitNanos(nanos);
                } catch (InterruptedException ie) {
                    if (g == generation && ! g.broken) {
                        breakBarrier();
                        throw ie;
                    } else {
                        // We're about to finish waiting even if we had not
                        // been interrupted, so this interrupt is deemed to
                        // "belong" to subsequent execution.
                        Thread.currentThread().interrupt();
                    }
                }
                if (g.broken)
                    throw new BrokenBarrierException();
                if (g != generation)
                    return index;
                if (timed && nanos <= 0L) {
                    breakBarrier();
                    throw new TimeoutException();
                }
            }
        } finally {
            lock.unlock();
        }
    }

package com.zsr.test.countDownLatch;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
public class Worker implements Runnable {
  private CountDownLatch downLatch;
  private String name;
  public Worker(CountDownLatch downLatch, String name) {
    this.downLatch = downLatch;
    this.name = name;
  }
  @Override
  public void run() {
    this.doWork();
    try {
      TimeUnit.SECONDS.sleep(10);
    } catch (InterruptedException ie) {
    }
    System.out.println(this.name + "活干完了!");
    this.downLatch.countDown();
  }
  private void doWork() {
    System.out.println(this.name + "正在干活!");
  }
}

package com.zsr.test.countDownLatch;
import java.util.concurrent.CountDownLatch;
public class Boss implements Runnable {
  private CountDownLatch downLatch;
  public Boss(CountDownLatch downLatch) {
    this.downLatch = downLatch;
  }
  @Override
  public void run() {
    System.out.println("老板正在等所有的工人干完活......");
    try {
      this.downLatch.await();
    } catch (InterruptedException e) {
    }
    System.out.println("工人活都干完了，老板开始检查了！");
  }
}

package com.zsr.test.countDownLatch;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CountDownLatchTest {
  public static void main(String[] args) {
    ExecutorService executor = Executors.newCachedThreadPool();
    CountDownLatch latch = new CountDownLatch(2);
    Worker w1 = new Worker(latch, "张三");
    Worker w2 = new Worker(latch, "李四");
    Boss boss = new Boss(latch);
    executor.execute(w2);
    executor.execute(w1);
    executor.execute(boss);
    executor.shutdown();
  }
}

 /**
     * Synchronization control For CountDownLatch.
     * Uses AQS state to represent count.
     */
private static final class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = 4982264981922014374L;
        Sync(int count) {
            setState(count);
        }
        int getCount() {
            return getState();
        }
        protected int tryAcquireShared(int acquires) {
            return (getState() == 0) ? 1 : -1;
        }
        protected boolean tryReleaseShared(int releases) {
            // Decrement count; signal when transition to zero
            for (;;) {
                int c = getState();
                if (c == 0)
                    return false;
                int nextc = c-1;
                if (compareAndSetState(c, nextc))
                    return nextc == 0;
            }
        }
    }

public CountDownLatch(int count) {
       if (count < 0) throw new IllegalArgumentException("count < 0");
       this.sync = new Sync(count);
   }

public void countDown() {
        sync.releaseShared(1);
    }

public void await() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

package com.zsr.test.redislock;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.StringRedisSerializer;
/**
 * 实现分布式锁
 */
@SuppressWarnings("rawtypes")
public class RedisLock {
  private static Logger logger = LoggerFactory.getLogger(RedisLock.class);
  private RedisTemplate redisTemplate;
  private static final int DEFAULT_ACQUIRY_RESOLUTION_MILLIS = 100;
  /**
   * Lock key path.
   */
  private String lockKey;
  /**
   * 锁超时时间，防止线程在入锁以后，无限的执行等待
   */
  private int expireMsecs = 1000;
  /**
   * 锁等待时间，防止线程饥饿
   */
  private int timeoutMsecs = 1000;
  /**
   * 锁到期时间
   */
  private String expiresStr = "";
  private volatile boolean locked = false;
  /**
   * Detailed constructor with default acquire timeout 10000 msecs and lock expiration of 60000
   * msecs.
   *
   * @param lockKey lock key (ex. account:1, ...)
   */
  public RedisLock(String lockKey) {
    this.lockKey = "LOCK_" + lockKey;
  }
  /**
   * Detailed constructor with default lock expiration of 60000 msecs.
   *
   */
  public RedisLock(String lockKey, int timeoutMsecs) {
    this(lockKey);
    this.timeoutMsecs = timeoutMsecs;
  }
  /**
   * Detailed constructor.
   *
   */
  public RedisLock(String lockKey, int timeoutMsecs, int expireMsecs) {
    this(lockKey, timeoutMsecs);
    this.expireMsecs = expireMsecs;
  }
  /**
   * @return lock key
   */
  public String getLockKey() {
    return lockKey;
  }
  private String get(final String key) {
    Object obj = null;
    try {
      obj = redisTemplate.execute(new RedisCallback<Object>() {
        @Override
        public Object doInRedis(RedisConnection connection) throws DataAccessException {
          StringRedisSerializer serializer = new StringRedisSerializer();
          byte[] data = connection.get(serializer.serialize(key));
          connection.close();
          if (data == null) {
            return null;
          }
          return serializer.deserialize(data);
        }
      });
    } catch (Exception e) {
      logger.error("get redis error, key : {}", key);
    }
    return obj != null ? obj.toString() : null;
  }
  private boolean setNX(final String key, final String value) {
    Object obj = null;
    try {
      obj = redisTemplate.execute(new RedisCallback<Object>() {
        @Override
        public Object doInRedis(RedisConnection connection) throws DataAccessException {
          StringRedisSerializer serializer = new StringRedisSerializer();
          Boolean success = connection.setNX(serializer.serialize(key), serializer.serialize(value));
          connection.close();
          return success;
        }
      });
    } catch (Exception e) {
      logger.error("setNX redis error, key : {}", key);
    }
    return obj != null ? (Boolean) obj : false;
  }
  private String getSet(final String key, final String value) {
    Object obj = null;
    try {
      obj = redisTemplate.execute(new RedisCallback<Object>() {
        @Override
        public Object doInRedis(RedisConnection connection) throws DataAccessException {
          StringRedisSerializer serializer = new StringRedisSerializer();
          byte[] ret = connection.getSet(serializer.serialize(key), serializer.serialize(value));
          connection.close();
          return serializer.deserialize(ret);
        }
      });
    } catch (Exception e) {
      logger.error("setNX redis error, key : {}", key);
    }
    return obj != null ? (String) obj : null;
  }
  /**
   * 主要是使用了redis 的setnx命令,缓存了锁. reids缓存的key是锁的key,所有的共享,
   * value是锁的到期时间(注意:这里把过期时间放在value了,没有时间上设置其超时时间)
   * <p>
   * 执行过程:
   * <p>
   * 1.通过setnx尝试设置某个key的值,成功(当前没有这个锁)则返回,成功获得锁
   * <p>
   * 2.锁已经存在则获取锁的到期时间,和当前时间比较,超时的话,则设置新的值
   *
   * @return true if lock is acquired, false acquire timeouted
   * @throws InterruptedException in case of thread interruption
   */
  public synchronized boolean lock() throws InterruptedException {
    int timeout = timeoutMsecs;
    while (timeout >= 0) {
      // 锁到期时间
      expiresStr = String.valueOf(System.currentTimeMillis() + expireMsecs + 1);
      if (this.setNX(lockKey, expiresStr)) {
        // lock acquired
        locked = true;
        return true;
      }
      String currentValueStr = this.get(lockKey); // redis里的时间
      if (currentValueStr != null && Long.parseLong(currentValueStr) < System.currentTimeMillis()) {
        // 判断是否为空，不为空的情况下，如果被其他线程设置了值，则第二个条件判断是过不去的
        // lock is expired
        String oldValueStr = this.getSet(lockKey, expiresStr);
        // 获取上一个锁到期时间，并设置现在的锁到期时间，
        // 只有一个线程才能获取上一个线上的设置时间，因为jedis.getSet是同步的
        if (oldValueStr != null && oldValueStr.equals(currentValueStr)) {
          // 防止误删（覆盖，因为key是相同的）了他人的锁——这里达不到效果，这里值会被覆盖，但是因为什么相差了很少的时间，所以可以接受
          // [分布式的情况下]:如过这个时候，多个线程恰好都到了这里，但是只有一个线程的设置值和当前值相同，他才有权利获取锁
          // lock acquired
          locked = true;
          return true;
        }
      }
      timeout -= DEFAULT_ACQUIRY_RESOLUTION_MILLIS;
      /*
       * 延迟100 毫秒, 这里使用随机时间可能会好一点,可以防止饥饿进程的出现,即,当同时到达多个进程,
       * 只会有一个进程获得锁,其他的都用同样的频率进行尝试,后面有来了一些进行,也以同样的频率申请锁,这将可能导致前面来的锁得不到满足. 使用随机的等待时间可以一定程度上保证公平性
       */
      Thread.sleep(DEFAULT_ACQUIRY_RESOLUTION_MILLIS);
    }
    return false;
  }
  /**
   * Acqurired lock release.
   */
  public synchronized void unlock() {
    if (locked) {
      if (expiresStr != null && expiresStr.equals(redisTemplate.opsForValue().get(lockKey))) {
        redisTemplate.delete(lockKey);
        locked = false;
      }
    }
  }
  /**
   * 测试
   */
  public static void main(String[] args) {
    final String key = "lockKey";
    final RedisLock lock = new RedisLock(key, 1000, 2000);
    for (int i = 0; i < 5; i++) {
      new Thread(new Runnable() {
        @Override
        public void run() {
          try {
            if (lock.lock()) {
              System.out.println("Thread: " + Thread.currentThread().getName() + "running");
            }
          } catch (InterruptedException e) {
            e.printStackTrace();
          } finally {
            lock.unlock();
          }
        }
      }, "" + i).start();
    }
  }
}