一。代码同步

1. ConcurrentHashMap

   采用分段方式减少锁粒度，提高并发性能。get时没有锁。

2. Copy-On-Write

JDK里的COW容器有两种：CopyOnWriteArrayList和CopyOnWriteArraySet。

3. ConcurrentLinkedQueue

实现了高并发状态下的高性能。通常ConcurrentLinkedQueue性能好于BlockingQueue,他是一个基于链接节点的无界线程安全队列，该队列的元素遵循先进先出的原则，头是最新加入，尾是最近加入。该队列不允许null元素。

4. ArrayBlockingQueue

基于数组的阻塞队列实现，读写同步。有界队列，构造函数初始化数组长度，插入数据时，如果数组已满，offer方法返回false，add方法抛出异常。

//构造函数初始化数组长度，以及采用的锁是否公平锁
ArrayBlockingQueue(int capacity, boolean fair)

5. LinkedBlockingQueue

基于链表的阻塞无界队列，读写分锁。

6. PriorityBlockingQueue

基于数组的阻塞队列实现，读写同步。构造函数传入Comparator排序，添加新数据时自动扩容。内部控制线程同步的锁采用的是非公平锁。

public PriorityBlockingQueue(int initialCapacity,
                                 Comparator<? super E> comparator) {
        if (initialCapacity < 1)
            throw new IllegalArgumentException();
        this.lock = new ReentrantLock();
        this.notEmpty = lock.newCondition();
        this.comparator = comparator;
        this.queue = new Object[initialCapacity];
    }
/**
     * Creates an instance of {@code ReentrantLock}.
     * This is equivalent to using {@code ReentrantLock(false)}.
     */
    public ReentrantLock() {
        sync = new NonfairSync();
    }

    /**
     * Creates an instance of {@code ReentrantLock} with the
     * given fairness policy.
     *
     * @param fair {@code true} if this lock should use a fair ordering policy
     */
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

7. DelayQueue

    基于数组，带有延迟时间的Queue, 其中的元素只有当其指定的延迟时间到了，才能够从队列中获取到该元素。

8. SynchronousQueue

    这是一个没有缓存的同步队列，采用CAS方式，读写同步。

二. 数据库锁同步

1. 物理同步（悲观锁）

    依靠数据库提供的锁机制。

    ex: select * from account where name='test' for update;

    这条语句锁定account表中所有符合条件的记录。

2. 乐观锁

    基于数据版本记录机制实现。数据表增加字段version，修改数据时只有大于数据表中的version时才生效。

Hibernate中实现了悲观锁和乐观锁。


三. 大数据量处理

当数据达到100W以上甚至上亿时，select等操作会很慢。优化方式:

1. 分表。将数据按日期或其他条件分块，分别建立结构相同的数据表

2. 缓存。使用memcached等中间件，单独设置缓存服务器。

3. 建立合适的索引，加快查询速度。

4. 组建集群分流。