精华内容
下载资源
问答
  • Java中线程安全的集合类有Stack、Vector、Properties、Hashtable等。堆栈(stack)Java中的Stack类实现了基于后进先出(LIFO)原理的堆栈数据结构。因此,Stack类可以支持许多操作,比如push、pop、peek、search、empty...

    线程安全类是确保类的内部状态以及从方法返回的值在从多个线程并发调用时是正确的类。 Java中线程安全的集合类有Stack、Vector、Properties、Hashtable等。

    堆栈(stack)

    Java中的Stack类实现了基于后进先出(LIFO)原理的堆栈数据结构。因此,Stack类可以支持许多操作,比如push、pop、peek、search、empty等。

    例子import java.util.*;

    public class StackTest {

    public static void main (String[] args) {

    Stack stack = new Stack();

    stack.push(5);

    stack.push(7);

    stack.push(9);

    Integer num1 = (Integer)stack.pop();

    System.out.println("弹出的元素是: " + num1);

    Integer num2 = (Integer)stack.peek();

    System.out.println("堆栈顶部的元素是: " + num2);

    }

    }

    输出结果弹出的元素是: 9

    堆栈顶部的元素是: 7

    向量(vector)

    Java中的Vector类实现了根据需要增长的对象数组。Vector类可以支持add(),remove(),get(),elementAt(),size()等方法。

    例子import java.util.*;

    public class VectorTest {

    public static void main(String[] arg) {

    Vector vector = new Vector();

    vector.add(9);

    vector.add(3);

    vector.add("ABC");

    vector.add(1);

    vector.add("DEF");

    System.out.println("向量是: " + vector);

    vector.remove(1);

    System.out.println("移除元素后的向量为: " + vector);

    }

    }

    输出结果向量是: [9, 3, ABC, 1, DEF]

    移除元素后的向量为: [9, ABC, 1, DEF]

    展开全文
  • 点击蓝字关注我们FOLLOW USConcurrentHashMap是在在JDK 1.5中引入,属于java.util.concurrent包,它也实现了ConcurrentMap以及Serializable接口。ConcurrentHashMap是对HashMap增强,因为我们知道在我们应用...

    点击蓝字

    关注我们 FOLLOW US

    ConcurrentHashMap类是在在JDK 1.5中引入的,属于java.util.concurrent包,它也实现了ConcurrentMap以及Serializable接口。ConcurrentHashMap是对HashMap的增强,因为我们知道在我们的应用程序中处理Threads时,HashMap并不是一个很好的选择,因为从性能上来说,HashMap并不符合要求。

    ConcurrentHashMap的关键点:

    • ConcurrentHashMap的下划线数据结构是Hashtable

    • ConcurrentHashMap类是线程安全的,即多个线程可以对一个对象进行操作,而不会产生任何复杂的问题。

    • 任何数量的线程都可以同时进行读取操作,而不会锁定ConcurrentHashMap对象,这在HashMap中是不存在的。

    • 在ConcurrentHashMap中,对象根据并发级别被划分为若干段。

    • ConcurrentHashMap的默认并发级别是16。

    • 在ConcurrentHashMap中,一次可以有任意多个线程进行检索操作,但对于对象中的更新,线程必须锁定该线程要操作的特定段。这种类型的锁定机制被称为分段锁或桶锁。因此每次线程可以进行16次更新操作。

    • 在ConcurrentHashMap中不可能插入Null作为键或值。

    Declaration:

    public class ConcurrentHashMap<K,V> extends AbstractMap<K,V> implements ConcurrentMap<K,V>, Serializable

    这里,K是键对象类型,V是值对象类型。

    ConcurrentHashMap的层次结构

    c3475016583e6b7c4c4df0b47a8737ce.png

    它实现了 Serializable, ConcurrentMap, Map 接口,继承了AbstractMap

    ConcurrentHashMap的构造函数

    • 并发级别 它是指同时更新地图的线程数量。实现中会执行内部大小调整,以尽量适应这个数量的线程。

    • Load-Factor(负载系数):这是一个阈值,用于控制大小调整。

    • 初始容量 是一个阈值,用来控制调整大小。如果这个地图的容量是10,就意味着它可以存储10个条目。就意味着它可以存储10个条目。

    1. ConcurrentHashMap() : 创建一个新的空Map,默认初始容量(16)、负载因子(0.75)和并发级别(16)。

    ConcurrentHashMap<K, V> chm = new ConcurrentHashMap<>();

    2. ConcurrentHashMap(int initialCapacity) : 用指定的初始容量创建一个新的空Map,并使用默认的负载因子(0.75)和并发级别(16)。

    ConcurrentHashMap chm = new ConcurrentHashMap<>(int initialCapacity);

    3. ConcurrentHashMap(int initialCapacity, float loadFactor) : 用指定的初始容量和负载因子以及默认的并发级别(16)创建一个新的空Map。

    ConcurrentHashMap chm = new ConcurrentHashMap<>(int initialCapacity, float loadFactor);

    4. ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel); 用指定的初始容量、负载因子和并发级别创建一个新的空Map。

    ConcurrentHashMap chm = new ConcurrentHashMap<>(int initialCapacity, float loadFactor, int concurrencyLevel);

    5. ConcurrentHashMap(Map m); 创建一个与给定ConcurrentHashMap相同的新Map。

    ConcurrentHashMap chm = new ConcurrentHashMap<>(Map m);

    Example:

    // Java program to demonstrate working of ConcurrentHashMap import java.util.concurrent.*; class ConcurrentHashMapDemo {   public static void main(String[] args)   {     // create an instance of     // ConcurrentHashMap     ConcurrentHashMap m = new ConcurrentHashMap<>();           // Insert mappings using     // put method     m.put(100, "Hello");     m.put(101, "Geeks");     m.put(102, "Geeks");     // Here we cant add Hello because 101 key     // is already present in ConcurrentHashMap object     m.putIfAbsent(101, "Hello");     // We can remove entry because 101 key     // is associated with For value     m.remove(101, "Geeks");     // Now we can add Hello     m.putIfAbsent(103, "Hello");     // We cant replace Hello with For     m.replace(101, "Hello", "For");     System.out.println(m);   } } 

    Output:

    {100=Hello, 102=Geeks, 103=Hello}

    ConcurrentHashMap常用操作

    1. 添加元素

    要将映射数据插入到一个ConcurrentHashMap中,我们可以使用put()putAll()方法。下面的示例代码解释了这两种方法。

    // Java program to demonstrate adding // elements to the ConcurrentHashMap import java.util.concurrent.ConcurrentHashMap; import java.util.*; public class AddingElementsToConcuurentHashMap {   public static void main(String[] args)   {     // Creating ConcurrentHashMap     ConcurrentHashMap<String, String> my_cmmap       = new ConcurrentHashMap<String, String>();     // Adding elements to the map     // using put() method     my_cmmap.put("1", "1");     my_cmmap.put("2", "1");     my_cmmap.put("3", "1");     my_cmmap.put("4", "1");     my_cmmap.put("5", "1");     my_cmmap.put("6", "1");     // Printing the map     System.out.println("Mappings of my_cmmap : "            + my_cmmap);     // create another concurrentHashMap     ConcurrentHashMap<String, String> new_chm       = new ConcurrentHashMap<>();     // copy mappings from my_cmmap to new_chm     new_chm.putAll(my_cmmap);     // Displaying the new map     System.out.println("New mappings are: " + new_chm);   } }

    Output

    Mappings of my_cmmap : {1=1, 2=1, 3=1, 4=1, 5=1, 6=1}New mappings are: {1=1, 2=1, 3=1, 4=1, 5=1, 6=1}

    2. 删除元素

    要删除一个映射,我们可以使用 ConcurrentHashmap 类的 remove(Object key) 方法。如果key在map中不存在,那么这个函数什么也不做。要清除整个映射,我们可以使用clear()方法。

    // Java program to demonstrate removing // elements from ConcurrentHashMap import java.util.concurrent.ConcurrentHashMap; import java.util.*; public class RemoveElementsFromConcurrentHashMap {   public static void main(String[] args)   {     // Creating ConcurrentHashMap     Map my_cmmap = new ConcurrentHashMap();     // Adding elements to the map     // using put() method     my_cmmap.put("1", "1");     my_cmmap.put("2", "1");     my_cmmap.put("3", "1");     my_cmmap.put("4", "1");     my_cmmap.put("5", "1");     my_cmmap.put("6", "1");     // Printing the map     System.out.println("Map: " + my_cmmap);     System.out.println();     // Removing the mapping     // with existing key 6     // using remove() method     String valueRemoved = my_cmmap.remove("6");     // Printing the map after remove()     System.out.println("After removing mapping with key 6:");     System.out.println("Map: " + my_cmmap);     System.out.println("Value removed: "            + valueRemoved);     System.out.println();     // Removing the mapping     // with non-existing key 10     // using remove() method     valueRemoved = my_cmmap.remove("10");     // Printing the map after remove()     System.out.println(       "After removing mapping with key 10:");     System.out.println("Map: " + my_cmmap);     System.out.println("Value removed: "            + valueRemoved);     System.out.println();     // Now clear the map using clear()     my_cmmap.clear();     // Print the clea Map     System.out.println("Map after use of clear(): "            + my_cmmap);   } }

    Output

    Map: {1=1, 2=1, 3=1, 4=1, 5=1, 6=1}After removing mapping with key 6:Map: {1=1, 2=1, 3=1, 4=1, 5=1}Value removed: 1After removing mapping with key 10:Map: {1=1, 2=1, 3=1, 4=1, 5=1}Value removed: nullMap after use of clear(): {}

    3. 获取元素

    我们可以使用get()方法来访问一个ConcurrentHashMap的元素,下面给出了这个例子。

    // Java Program Demonstrate accessing // elements of ConcurrentHashMap import java.util.concurrent.*; class AccessingElementsOfConcurrentHashMap {   public static void main(String[] args)   {     // create an instance of ConcurrentHashMap     ConcurrentHashMap chm       = new ConcurrentHashMap();     // insert mappings using put method     chm.put(100, "Geeks");     chm.put(101, "for");     chm.put(102, "Geeks");     chm.put(103, "Contribute");     // Displaying the HashMap     System.out.println("The Mappings are: ");     System.out.println(chm);     // Display the value of 100     System.out.println("The Value associated to "            + "100 is : " + chm.get(100));     // Getting the value of 103     System.out.println("The Value associated to "            + "103 is : " + chm.get(103));   } }

    Output

    The Mappings are: {100=Geeks, 101=for, 102=Geeks, 103=Contribute}The Value associated to 100 is : GeeksThe Value associated to 103 is : Contribute

    4. 遍历

    我们可以使用Iterator接口来遍历Collection Framework的任何结构。由于Iterators只处理一种类型的数据,我们使用Entry< ? , ? > 将两种不同类型的数据解析成兼容的格式。然后使用 next() 方法打印 ConcurrentHashMap 的元素。

    // Java Program for traversing a // ConcurrentHashMap import java.util.concurrent.*; import java.util.*; public class TraversingConcurrentHashMap {   public static void main(String[] args)   {     // create an instance of ConcurrentHashMap     ConcurrentHashMapString> chmap       = new ConcurrentHashMapString>();     // Add elements using put()     chmap.put(8, "Third");     chmap.put(6, "Second");     chmap.put(3, "First");     chmap.put(11, "Fourth");     // Create an Iterator over the     // ConcurrentHashMap     IteratorString> >       itr = chmap.entrySet().iterator();     // The hasNext() method is used to check if there is     // a next element The next() method is used to     // retrieve the next element     while (itr.hasNext()) {       ConcurrentHashMap.EntryString> entry         = itr.next();       System.out.println("Key = " + entry.getKey()               + ", Value = "              + entry.getValue());     }   } }

    Output

    Key = 3, Value = FirstKey = 6, Value = SecondKey = 8, Value = ThirdKey = 11, Value = Fourth

    Methods of ConcurrentHashMap

    • K – Map集合中键的类型

    • V – Map中映射的值的类型。

    METHODDESCRIPTION
    clear()移除此Map上的所有键值对。
    compute(K key, BiFunction remappingFunction)试图计算指定键及其当前映射值的映射(如果没有当前映射,则为空)。
    computeIfAbsent(K key, Function mappingFunction)如果指定的键还没有与值相关联,则尝试使用给定的映射函数计算其值,并将其输入到这个映射中,除非为空。
    computeIfPresent(K key, BiFunction super K,? super V,? extends V> remappingFunction)如果指定键的值存在,则尝试根据键及其当前映射值计算新的映射。
    contains(Object value)测试某个键是否映射到本表的指定值中。
    containsKey(Object key)测试指定的对象是否是本集合中的键。
    containsValue(Object value)如果此映射将一个或多个键映射到指定的值,则返回true。
    elements()返回本表中数值的枚举。
    entrySet()返回该地图中包含的映射的Set视图。
    equals(Object o)将指定的对象与此图进行平等比较。
    forEach(long parallelismThreshold, BiConsumer super K,? super V> action)对每个(键,值)执行给定的操作。
    forEach(long parallelismThreshold, BiFunction super K,? super V,? extends U> transformer, Consumer super U> action)对每个(键,值)的非空变换执行给定的操作。
    forEachEntry(long parallelismThreshold, Consumer super Map.Entry> action)对每个条目执行指定的操作。
    forEachEntry(long parallelismThreshold, Function,? extends U> transformer, Consumer super U> action)对每个条目的非空变换执行给定动作。
    forEachKey(long parallelismThreshold, Consumer super K> action)Performs the given action for each key.
    forEachKey(long parallelismThreshold, Function super K,? extends U> transformer, Consumer super U> action)Performs the given action for each non-null transformation of each key.
    forEachValue(long parallelismThreshold, Consumer super V> action)Performs the given action for each value.
    forEachValue(long parallelismThreshold, Function super V,? extends U> transformer, Consumer super U> action)Performs the given action for each non-null transformation of each value.
    get(Object key)返回指定键的映射值,如果该映射不包含键的映射,则返回空值。
    getOrDefault(Object key, V defaultValue)Returns the value to which the specified key is mapped, or the given default value if this map contains no mapping for the key.
    hashCode()返回此Map的哈希码值,即Map中每个键值对的key.hashCode() ^ value.hashCode()之和。
    keys()返回本表中键的枚举。
    keySet()返回此地图中的键值的Set视图。
    keySet(V mappedValue)Returns a Set view of the keys in this map, using the given common mapped value for any additions (i.e., Collection.add(E) and Collection.addAll(Collection)).
    mappingCount()Returns the number of mappings.
    merge(K key, V value, BiFunction super V,? super V,? extends V> remappingFunction)If the specified key is not already associated with a (non-null) value, associates it with the given value.
    newKeySet()Creates a new Set backed by a ConcurrentHashMap from the given type to Boolean.TRUE.
    newKeySet(int initialCapacity)Creates a new Set backed by a ConcurrentHashMap from the given type to Boolean.TRUE.
    put(K key, V value)将指定的键映射到本表的指定值上。
    putAll(Map m)将指定地图上的所有映射复制到这个地图上。
    putIfAbsent(K key, V value)如果指定的键没有与值关联,则将其与给定的值关联。
    remove(Object key)从该地图中删除键(和其对应的值)。
    remove(Object key, Object value)只有在当前映射到给定值的情况下,才会删除某个键的条目。
    values()返回该Map中包含的值的集合视图。

    java.util.AbstractMap类中方法的定义

    METHODDESCRIPTION
    clone()返回这个AbstractMap实例的一个浅复制:键和值本身不会被克隆。
    isEmpty()如果该Map不包含键值对,则返回true。
    size()返回该Map中键值对的数量。

    java.util.concurrent.ConcurrentMap接口中方法的定义

    METHODDESCRIPTION
    forEach(BiConsumer super K,? super V> action)对Map中的每个条目执行给定的操作,直到所有的条目都被处理完,或者该操作引发一个异常。
    replaceAll(BiFunction super K,? super V,? extends V> function)用在该条目上调用给定函数的结果替换每个条目的值,直到所有条目都被处理完毕或函数引发异常。

    Must Read: Difference between HashMap and ConcurrentHashMap

    ConcurrentHashMap vs Hashtable

    HashTable

    • Hashtable  是Map数据结构的实现

    • 这是一个遗留类,其中所有方法都是在Hashtable实例上使用synchronized关键字进行同步。

    • 由于它的方法是同步的,所以是线程安全的。

    ConcurrentHashMap

    • ConcurrentHashMap  实现了Map数据结构,也提供了像Hashtable一样的线程安全。

    • 它的工作原理是将完整的哈希数组划分为片段或部分,并允许对这些片段进行并行访问。

    • 锁是在一个更细粒度的哈希桶。

    • 当你的程序中需要非常高的并发性时,请使用ConcurrentHashMap

    • 它是一个不需要同步整个Map的线程安全。

    • 读取可以非常快地进行,而写入则是在段级或桶级上加锁完成。

    • 在对象级别上没有锁。

    • 如果一个线程试图在另一个线程迭代时修改它,ConcurrentHashMap不会抛出ConcurrentModificationException

    • ConcurrentHashMap不允许NULL值,所以在ConcurrentHashMap中key不能为空。

    • 如果一个线程试图修改它,而另一个线程正在迭代它,ConcurrentHashMap不会抛出一个并发修改异常

    PROPERTIESHASHTABLECONCURRENTHASHMAP
    CreationMap ht = new Hashtable();  Map chm = new ConcurrentHashMap();
    Is Null Key Allowed ?NoNo
    Is Null Value Allowed ?NoYes
    Is Thread Safe ?YesYes, Thread safety is ensured by having separate locks for separate buckets, resulting in better performance. Performance is further improved by providing read access concurrently without any blocking.
    PerformanceSlow due to synchronization overhead.Faster than Hashtable. ConcurrentHashMap is a better choice when there are more reads than writes.
    IteratorHashtable uses enumerator to iterate the values of Hashtable object. Enumerations returned by the Hashtable keys and elements methods are not fail-fast.Fail-safe iterator: Iterator provided by the ConcurrentHashMap is fail-safe, which means it will not throw ConcurrentModificationException.

    结论:

    • 如果需要一个线程安全的高并发实现,那么建议使用ConcurrentHashMap来代替Hashtable

    991ad1c69d6f843ddecdcdad3e5a65ab.png

    展开全文
  • Vector、Hashtable、Stack 都是线程安全的,而像 HashMap 则是非线程安全的,不过在 JDK 1.5 之后随着 Java.util.concurrent 并发包的出现,它们也了自己对应的线程安全,比如 HashMap 对应的线程安全就是 ...

    VectorHashtableStack 都是线程安全的,而像 HashMap 则是非线程安全的,不过在 JDK 1.5 之后随着 Java.util.concurrent 并发包的出现,它们也有了自己对应的线程安全类,比如 HashMap 对应的线程安全类就是 ConcurrentHashMap。

    展开全文
  • 介绍JDK中提供了很多集合实现,本文不会介绍有哪些集合的接口以及实现,而是介绍如何在多线程情况下使用这些集合。阅读更多…如果您还不太了解Java整个集合体系话,请查看《Java开发成长之路第一年》。如果您...

    介绍

    JDK中提供了很多集合实现,本文不会介绍有哪些集合的接口以及实现类,而是介绍如何在多线程情况下使用这些集合。

    01b6040a9bcc

    阅读更多…

    如果您还不太了解Java的整个集合体系的话,请查看《Java开发成长之路第一年》。如果您还想要了解线程的相关内容,请查看《Java多线程》。

    线程不安全

    java.util.HashMap、java.util.ArrayList、java.util.LinkedList、java.util.HashSet等集合实现类都是线程不安全的,在多线程环境下使用的话,将会得到无法预期的结果。

    遍历不安全

    java.util.Hashtable、java.util.Vector等集合类在多线程环境下,如果只是调用put、get、remove等方法的话是能保证线程安全的,但如果进行遍历的话就无法保证线程安全了。这种情况也叫做“条件线程安全”。

    线程安全

    java.util.concurrent.ConcurrentHashMap、java.util.concurrent.CopyOnWriteArrayList、java.util.concurrent.ConcurrentArraySet等是线程安全的。

    Map

    下面是验证HashMap问题的示例代码:

    [codesyntax lang="java"]

    import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;/** * java.util.HashMap的线程不安全测试,这里会有如下两种情况: *

    • *
    • 输出的Map元素个数不对 *
    • 死循环(线程数多了更容易出现) *
    * @author suren * @date 2017年2月22日 下午3:31:09 /public class HashMapTest{ static Map map; public static void main(String[] args) { map = new HashMap(); long begin = System.currentTimeMillis(); ThreadGroup group = new ThreadGroup("HashMap thread test from surenpi.com"); List threadList = new ArrayList(); int threadCount = 10; for(int i = 0; i < threadCount; i++) { Thread thread = new Thread(group, new Runnable() { @Override public void run() { for(int j = 0; j < 200 ; j++) { map.put(Thread.currentThread().getName() + j, ""); map.get(Thread.currentThread().getName() + j); } } }); threadList.add(thread); } for(Thread thread : threadList) { thread.start(); } while(group.activeCount() > 0) {} System.out.println(map.size()); System.out.println("take time : " + (System.currentTimeMillis() - begin)); }}

    [/codesyntax]

    以下是线程安全的Map实现类的效率比较示例:

    [codesyntax lang="java"]

    import java.util.ArrayList;import java.util.Hashtable;import java.util.List;import java.util.Map;import java.util.concurrent.ConcurrentHashMap;/* * Hashtable和ConcurrentHashMap效率比较 * @author suren * @date 2017年2月22日 下午4:27:56 /public class ThreadSafeMapTest{ /* * @param args */ public static void main(String[] args) { mapTest(new Hashtable()); mapTest(new ConcurrentHashMap()); } static void mapTest(final Map map) { long begin = System.currentTimeMillis(); ThreadGroup group = new ThreadGroup("HashMap thread test from surenpi.com"); List threadList = new ArrayList(); int threadCount = 10; for(int i = 0; i < threadCount; i++) { Thread thread = new Thread(group, new Runnable() { @Override public void run() { for(int j = 0; j < 9999 ; j++) { map.put(Thread.currentThread().getName() + j, ""); map.get(Thread.currentThread().getName() + j); } } }); threadList.add(thread); } for(Thread thread : threadList) { thread.start(); } while(group.activeCount() > 0) {} System.out.println(map.getClass() + " take time : " + (System.currentTimeMillis() - begin)); }}

    [/codesyntax]

    List

    下面是ArrayList和LinkedList线程不安全的示例代码:

    [codesyntax lang="java"]

    import java.util.ArrayList;import java.util.LinkedList;import java.util.List;/** * java.util.LinkedList和java.util.ArrayList的线程不安全测试,这里会有如下两种情况: *

    • *
    • ArrayList可能会出现下标越界的异常 *
    • LinkedList的元素个数不正确 *
    * @author suren * @date 2017年2月22日 下午3:31:09 */public class NonThreadSafeListTest{ public static void main(String[] args) { listTest(new LinkedList()); listTest(new ArrayList()); } static void listTest(final List list) { long begin = System.currentTimeMillis(); ThreadGroup group = new ThreadGroup("HashMap thread test from surenpi.com"); List threadList = new ArrayList(); int threadCount = 10; for(int i = 0; i < threadCount; i++) { Thread thread = new Thread(group, new Runnable() { @Override public void run() { for(int j = 0; j < 200 ; j++) { list.add(Thread.currentThread().getName() + j); } } }); threadList.add(thread); } for(Thread thread : threadList) { thread.start(); } while(group.activeCount() > 0) {} System.out.println(list.size()); System.out.println(list.getClass() + " take time : " + (System.currentTimeMillis() - begin)); }}

    [/codesyntax]

    展开全文
  • Java中的集合包括三大,它们是Set、List和Map, Set(集) List(列表) Map(映射) 它们都处于java.util包中,Set、List和Map都是接口,它们各自的实现。(1)List的实现主要ArrayList,LinkedList...
  • Java中哪些集合线程安全的

    千次阅读 2018-12-23 11:28:39
    Java中哪些集合线程安全的   java.util.Collection是一个集合接口,Collection接口在java中的具体实现很多, 其中ArrayList、LinkedList、HashSet、TreeSet、HashMap、TreeMap等都是线程不安全的。Vector...
  • Vector 的add方法是加了synchronized关键字,所以他是一个同步方法,线程是安全的,效率低,工作中即使要使用线程安全的List集合,也不使用Vector,而是用Collections工具中的 Collections.synchronizedList...
  • 上回我们说到了在java有哪些集合线程安全的,其实,也可以是线程安全的,你们知道都有哪些类线程安全的吗?快跟小编一起了解了解吧。线程安全类有哪些?在java中分别有着四种线程安全的类,如下:1.vector类似于...
  • Java中的集合包括三大类,它们是Set、List和...List、Set都继承自Collection接口,Collection (所有集合类的接口) Set(集) 实现类主要HashSet和TreeSet List(列表) 实现类主要ArrayList,LinkedList,V...
  • java集合类线程安全

    2015-08-26 23:08:55
    1.Java常见的集合类有哪些?说出几个已经同步的集合类?其他的怎样进行同步? 答:Collection接口下常用的有List接口下的ArrayList和LinkedList,以及Set接口下的 HashSet和TreeSet。Map接口下有HashMap...
  • 类似的,最常用的单列集合ArrayList、HashSet是线程不安全的,有哪些线程安全的单列集合类。 1. Vector 从网上各处搜集的知识整理出来 Vector空间满了之后,扩容是一倍,而ArrayList仅仅是一半 Vector分配内存的...
  • 从文章标题看,你可能很疑惑JDK中没有...实现ConcurrentHashSet之前,我们先来回顾一下Set接口有哪些子类?我们先看下类图:从上面看,set子类有四个,其中 :HaseSet、TreeSet、LinkedHashSet.这三个都...
  • java多线程中并发集合和同步集合有哪些?... 包装Collections.synchronizedMap()和Collections.synchronizedList()提供了一个基本的有条件的线程安全的Map和List实现。 ConcurrentHashMap...
  • JDK中提供了很多集合实现,本文不会介绍有哪些集合的接口以及实现,而是介绍如何在多线程情况下使用这些集合线程安全 查看原文:http://surenpi.com/2016/07/26/java_collection_thread_saf...
  • 很容易表现出线程安全的现象,比如抛出异常、逻辑处理错误等,这种我们就称为线程安全的类 常见线程安全的类有哪些呢 下图中,我们只画出了最常见的几种情况,我们常见的Collections集合都是线程安全的...
  • java集合有哪些Java API中所用的集合类,都是实现了Collection接口,他的一个类继承结构如下:CollectionCollectionCollectionCollectionCollectionCollectionVector1) 底层数据结构是数组,查询快,增删慢2)线程...
  • 总共两大接口:Collection 和Map ,一个元素集合,一个是键值对集合; 其中List和Set接口继承了Collection接口,一个是有序元素集合,... HashMap 和HashTable实现了Map接口,并且HashTable是线程安全的,但是Hash...
  • Java集合类框架基本接口有哪些

    千次阅读 2019-01-08 04:31:22
    基本接口 Collection:元素集合,List和Set继承了Collection接口,List是有序元素集合,set是无序元素集合,ArrayList和... Map:键值对集合,HashTable与HashMap实现了Map,HashTable是线程安全...
  • Java集合线程安全的有哪些? Vector->SynchronizedList->CopyOnWriteArrayList SynchronizedSet->CopyOnWriteArraySet SynchronizedMap->ConcurrentHashMap 线程的创建方式 继承...
  • 总共两大接口:Collection 和Map ,一个元素集合,一个是键值对集合; 其中List和Set接口继承了Collection接口,一个是有序元素集合,... HashMap 和HashTable实现了Map接口,并且HashTable是线程安全的,但是Hash...
  • 总共两大接口:Collection 和Map ,一个元素集合,一个是键值对集合; 其中List和Set接口继承了Collection接口,一个是有序元素集合,... HashMap 和HashTable实现了Map接口,并且HashTable是线程安全的,但是Has...
  • 什么是线程安全的类呢? 如果一个的对象同时被多个... 常见线程安全的类有哪些呢 下图中,我们只画出了最常见的几种情况,我们常见的Collections集合都是线程安全的 StringBuilder-demo @Slf...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 220
精华内容 88
关键字:

有哪些线程安全的集合类