JAVA并发的性能调整

1.互斥技术

• synchronized
• Lock
• Atomic

　　性能比较Atomic >  Lock  > synchronized，当然这不是绝对的。当线程数比较少时，synchronized的效率还是很可观的，并且用这个关键修饰的代码块阅读性很强。所以我们在编程时首先考虑到使用synchronized,当对并发的性能要求高的时候，才考虑使用Lock或者Atomic。Atomic适合简答的对象，如果对象多于复杂，不建议使用。

2.免锁容器

• 　CopyOnWriteArrayList
•    CopyOnWriteArraySet
•    concurrentHashMap
•    ConcurrentLinkedQueue

　　在介绍勉锁容器时，先了解一下cow(copy on write)技术。该技术使用的对象一般是类似于数组这样存储量比较大的数据格式。在使用cow技术对数组进行写操作的时候，首先会对原始数组进行建立一个副本，然后对这个副本进行写操作。等到写操作完成后，通过一个原子操作将引用指向这个修改后的副本。这个写操作时互斥的，所以在某一时间段内只有一个线程对数组进行写操作。

　　在容器中引入cow技术后就是所谓的免锁容器，如CopyOnWriteArrayList。在免锁容器中，对数据的读和写操作可以同时发生,减少了获取锁和释放锁的操作。不过有一点需要注意，读到的始终是原数据的值。

　　免锁容器一般使用的场景是数据量比较少，读次数多，写次数少。

3.ReadWriteLock

　　该锁是针对写操作少，读操作多的情况使用。多个读者进行读操作时，不会产生冲突。当读锁被持有时，写操作不能进行。当写锁被其它任务持有时，任何读者都不能进行读操作，直到写锁被释放。

package com.dy.xidian;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReaderWriterList<T> {
    private ArrayList<T> lockedList;
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock(true);
    public ReaderWriterList(int size, T initialValue) {
        lockedList = new ArrayList<T>(Collections.nCopies(size, initialValue));
    }

    public T set(int index, T element) {
        Lock wlock = lock.writeLock();
        wlock.lock();
        try {
            return lockedList.set(index, element);
        } finally {
            wlock.unlock();
        }
    }

    public T get(int index) {
        Lock rlock = lock.readLock();
        rlock.lock();
        try {
            if (lock.getReadLockCount() > 1)
                System.out.println(lock.getReadLockCount());
            return lockedList.get(index);
        } finally {
            lock.readLock().unlock();
        }
    }

    public static void main(String[] args) {
        new ReaderWriterListTest(30, 1);
    }
}

class ReaderWriterListTest {
    ExecutorService exec = Executors.newCachedThreadPool();
    private final static int SIZE = 100;
    private static Random rand = new Random(47);
    private ReaderWriterList<Integer> list = new ReaderWriterList<Integer>(
            SIZE, 0);

    private class Writer implements Runnable {

        @Override
        public void run() {
            try {
                for (int i = 0; i < 20; i++) {
                    list.set(i, rand.nextInt());
                    TimeUnit.MILLISECONDS.sleep(100);
                }
            } catch (InterruptedException e) {
                System.out.println("interrupted!");
            }
            System.out.println("Writer finished, shutting down");
        }
    }

    private class Reader implements Runnable {

        @Override
        public void run() {
            try {
                while (!Thread.interrupted()) {
                    for (int i = 0; i < SIZE; i++) {
                        list.get(i);
                        TimeUnit.MILLISECONDS.sleep(1);
                    }
                }
            } catch (InterruptedException e) {
                System.out.println("Read interrupted");
            }
        }
    }

    public ReaderWriterListTest(int readers, int writers) {
        for (int i = 0; i < readers; i++)
            exec.execute(new Reader());
        for (int i = 0; i < writers; i++)
            exec.execute(new Writer());
    }
}