java细节(六)

1 java.util.concurrent.locks.Lock  5.0

boolean tryLock()尝试获得锁而没有发生阻塞；若成功返回真。

 

2 若是很多线程从一个数据结构读取数据而很少线程修改其中数据的话，读写锁是很有用的。它允许读者线程共享访问，当然写线程依然必须互斥访问。

下面是一个读写锁的必要步骤:

构造一个ReentrantReadWriteLock对象：

private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();

抽取读锁和写锁：

private Lock readLock = rwl.readLock();

private Lock writeLock = rwl.writeLock();

对所有访问者加读锁：

public double getTotalBalance()

{

   readLock.lock();

   try { . . . } 

   finally { readLock.unlock(); }

}

对所有的修改者加写锁：

public void transfer(. . .)

{

   writeLock.lock();

   try { . . . } 

   finally { writeLock.unlock(); }

} 

 

3 java.util.concurrent.locks.ReentrantReadWriteLock  5.0

 Lock readLock()得到一个可以被多个读操作共用的读锁，但会排斥所有的写操作。

Lock writeLock()得到一个写锁，排斥其他所有的读写操作。

 

4 对于许多问题，可以通过一个或多个队列以优雅且安全的方式将其形式化。

ArrayBlockingQueue需要指定容量；LinkedBlockingQueue不需要指定容量；LinkedBlockingDeque是一个双端版本；PriorityBlockingQueue是个带优先级的队列。

 

5 

java.util.concurrent.BlockingQueue<E>  5.0

void put(E element)添加元素，必要时阻塞。

E take()移除并返回头元素，必要时阻塞。

boolean offer(E element, long time, TimeUnit unit)添加元素，并返回true；若队列满，则返回false

E poll(long time, TimeUnit unit)移除并返回头元素，若对列为空，则返回null

 

6 java.util.concurrent 包提供了映像,有序集和队列的高效实现：ConcurrentHashMap, ConcurrentSkipListMap , ConcurrentSkipListSet , 和ConcurrentLinkedQueue 。这些集合允许并发地访问数据结构的不同部分来使竞争极小化。

 

7 java.util.concurrent.ConcurrentLinkedQueue<E>

 ConcurrentLinkedQueue<E>() 构造一个可以被多线程安全访问的无边界非阻塞的队列。

 

 java.util.concurrent.ConcurrentHashMap<K, V>

 ConcurrentHashMap<K, V>()

ConcurrentHashMap<K, V>(int initialCapacity)

ConcurrentHashMap<K, V>(int initialCapacity, float loadFactor, int concurrencyLevel)

构造一个可以被多线程安全访问的散列映像表。

V putIfAbsent(K key, V value) 若是该键没有在映像表中出现，则将给定的值和值关联起来，并返回null。否则返回与该键关联的现有值。

boolean remove(K key, V value)若给定的值同给定的键关联，删除给定的键与值并返回真，否则返回false。

boolean replace(K key, V oldValue, V newValue) 若给定的值同oldValue关联，用它与newValue关联，否则返回false。

 

8 任何集合类通过使用同步包装器变成线程安全的：

List<E> synchArrayList = Collections.synchronizedList(new ArrayList<E>());

Map<K, V> synchHashMap = Collections.synchronizedMap(new HashMap<K, V>());

 

9 

java.util.concurrent.Executors  5.0

ExecutorService newCachedThreadPool() 返回一个带缓存的线程池，在必要时创建新线程；空闲线程会被保留60秒

ExecutorService newFixedThreadPool(int threads)返回一个线程池，该池中的线程数由参数指定。

ExecutorService newSingleThreadExecutor() 返回一个执行器，它在一个单个的线程中依次执行各个任务。

 

java.util.concurrent.ExecutorService 5.0

Future<T> submit(Callable<T> task)

Future<T> submit(Runnable task, T result)

Future<?> submit(Runnable task)

提交指定的任务去执行。

void shutdown()关闭服务，会先完成已经提交的任务而不再接收新的任务。

 

10 

java.util.concurrent.Executors  5.0

ScheduledExecutorService newScheduledThreadPool(int threads)用于预定执行，返回一个线程池。

ScheduledExecutorService newSingleThreadScheduledExecutor()用于预定执行，返回一个执行器。

 

java.util.concurrent.ScheduledExecutorService 5.0

 ScheduledFuture<V> schedule(Callable<V> task, long time, TimeUnit unit)

ScheduledFuture<?> schedule(Runnable task, long time, TimeUnit unit)

预定在指定的时间之后执行任务。

 

ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long initialDelay, long delay, TimeUnit unit)

预定在初始的延迟结束后，周期性的运行给定的任务，周期长度是delay

 

11 java.util.Collection<E> 1.2 

Iterator<E> iterator()返回一个用于访问集合中每个元素的迭代器。

int size() 返回当前存储在集合中的元素的个数。

boolean isEmpty()若为空，返回true

boolean contains(Object obj)若包含一个与obj相等的对象，返回true。

boolean containsAll(Collection<?> other)若这个集合包含other中的所有元素，返回true。

 

boolean add(Object element)将一个元素添加到这个集合，若这个调用改变了集合，返回true。

boolean addAll(Collection<? extends E> other) 添加一个集合

boolean remove(Object obj)删除一个元素

boolean removeAll(Collection<?> other)删除other中的所有元素。以上4个方法，若是改变了集合，返回true。

void clear()删除所有元素。

boolean retainAll(Collection<?> other)从这个集合中删除所有与other集合中的元素不同的元素。

Object[] toArray()返回这个集合的对象数组。

 

12 java.util.Iterator<E>  1.2

 boolean hasNext()若存在可访问的元素，返回true。

 E next()返回将要访问的下一个对象。

void remove()删除上次访问的对象，这个方法必须紧跟在访问一个元素之后执行。

 

13

ArrayList 一种可以动态增长和缩减的索引序列

LinkedList 一种可以在任何位置进行高效地插入和删除操作的有序序列。

ArrayDeque 一种用循环数组实现的双端队列。

HashSet 一种没有重复元素的无序集合。

TreeSet 一种有序集。

EnumSet一种包含枚举类型值的集。

LinkedHashSet 一种可以记住插入次序的集。

PriorityQueue 一种允许高效删除最小元素的集合。

HashMap 一种存储键/值关联的数据结构。

TreeMap 一种键值有序排列的映射表。

LinkedHashMap 一种记住键值添加次序的映射表。

 

14 java.util.List<E>  1.2

ListIterator<E> listIterator()

ListIterator<E> listIterator(int index)

void add(int i, E element)

void addAll(int i, Collection<? extends E> elements)

E remove(int i) 删除给定位置的元素并返回这个元素。

E get(int i)

E set(int i, E element)

int indexOf(Object element)

int lastIndexOf(Object element)

 

15 java.util.ListIterator<E> 1.2

void add(E newElement)

void set(E newElement)

boolean hasPrevious()

E previous()

int nextIndex()

int previousIndex()

 

16 Vector类的所有方法都是同步的，而ArrayList方法不是同步的。

17 具有不同数据域的对象将产生不同的散列码。注意，自己实现的hashCode方法应该与equals方法兼容，即如果a.equals(b)为true，a与b必须具有相同的散列码。

 

18 HashSet的构造方法

java.util.HashSet<E> 1.2

HashSet()

HashSet(Collection<? extends E> elements)

HashSet(int initialCapacity)

HashSet(int initialCapacity, float loadFactor)

 

19 java.lang.Object 1.0 

int hashCode()返回这个对象的散列码。散列码可以是任何整数，包括正数或负数。

 

20 对象的比较

public interface Comparable<T>

{

   int compareTo(T other);

}

若a与b相等，调用a.compareTo(b)一定返回0；若排序后a在b的前面，则返回负值；若a在b后，则返回正值。具体返回什么值都不重要，关键是符号。

例：

 class Item implements Comparable<Item>

   {  

      public int compareTo(Item other)

      {   

         return partNumber - other.partNumber;//注：x-y的情况下，有可能溢出。

      }

      . . .

   }