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());
     }
 }