「java锁分离」java分段锁
本篇文章给大家谈谈java锁分离，以及java分段锁对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
JAVA锁有哪些种类，以及区别
常见的Java锁有下面这些：
公平锁/非公平锁
可重入锁
独享锁/共享锁
互斥锁/读写锁
乐观锁/悲观锁
分段锁
偏向锁/轻量级锁/重量级锁
自旋锁
这些分类并不是全是指锁的状态，有的指锁的特性，有的指锁的设计，下面总结的内容是对每个锁的名词进行一定的解释。
公平锁/非公平锁
公平锁是指多个线程按照申请锁的顺序来获取锁。
非公平锁是指多个线程获取锁的顺序并不是按照申请锁的顺序，有可能后申请的线程比先申请的线程优先获取锁。有可能，会造成优先级反转或者饥饿现象。
对于Java ReentrantLock而言，通过构造函数指定该锁是否是公平锁，默认是非公平锁。非公平锁的优点在于吞吐量比公平锁大。
对于Synchronized而言，也是一种非公平锁。由于其并不像ReentrantLock是通过AQS的来实现线程调度，所以并没有任何办法使其变成公平锁。
可重入锁
可重入锁又名递归锁，是指在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。说的有点抽象，下面会有一个代码的示例。
对于Java ReentrantLock而言, 他的名字就可以看出是一个可重入锁，其名字是Re entrant Lock重新进入锁。
对于Synchronized而言,也是一个可重入锁。可重入锁的一个好处是可一定程度避免死锁。
synchronized void setA() throws Exception{
Thread.sleep(1000);
setB();
}synchronized void setB() throws Exception{
Thread.sleep(1000);
}
上面的代码就是一个可重入锁的一个特点，如果不是可重入锁的话，setB可能不会被当前线程执行，可能造成死锁。
独享锁/共享锁
独享锁是指该锁一次只能被一个线程所持有。
共享锁是指该锁可被多个线程所持有。
对于Java ReentrantLock而言，其是独享锁。但是对于Lock的另一个实现类ReadWriteLock，其读锁是共享锁，其写锁是独享锁。
读锁的共享锁可保证并发读是非常高效的，读写，写读 ，写写的过程是互斥的。
独享锁与共享锁也是通过AQS来实现的，通过实现不同的方法，来实现独享或者共享。
对于Synchronized而言，当然是独享锁。
互斥锁/读写锁
上面讲的独享锁/共享锁就是一种广义的说法，互斥锁/读写锁就是具体的实现。
互斥锁在Java中的具体实现就是ReentrantLock
读写锁在Java中的具体实现就是ReadWriteLock
乐观锁/悲观锁
乐观锁与悲观锁不是指具体的什么类型的锁，而是指看待并发同步的角度。
悲观锁认为对于同一个数据的并发操作，一定是会发生修改的，哪怕没有修改，也会认为修改。因此对于同一个数据的并发操作，悲观锁采取加锁的形式。悲观的认为，不加锁的并发操作一定会出问题。
乐观锁则认为对于同一个数据的并发操作，是不会发生修改的。在更新数据的时候，会采用尝试更新，不断重新的方式更新数据。乐观的认为，不加锁的并发操作是没有事情的。
从上面的描述我们可以看出，悲观锁适合写操作非常多的场景，乐观锁适合读操作非常多的场景，不加锁会带来大量的性能提升。
悲观锁在Java中的使用，就是利用各种锁。
乐观锁在Java中的使用，是无锁编程，常常采用的是CAS算法，典型的例子就是原子类，通过CAS自旋实现原子操作的更新。
分段锁
分段锁其实是一种锁的设计，并不是具体的一种锁，对于ConcurrentHashMap而言，其并发的实现就是通过分段锁的形式来实现高效的并发操作。
我们以ConcurrentHashMap来说一下分段锁的含义以及设计思想，ConcurrentHashMap中的分段锁称为Segment，它即类似于HashMap（JDK7与JDK8中HashMap的实现）的结构，即内部拥有一个Entry数组，数组中的每个元素又是一个链表；同时又是一个ReentrantLock（Segment继承了ReentrantLock)。
当需要put元素的时候，并不是对整个hashmap进行加锁，而是先通过hashcode来知道他要放在那一个分段中，然后对这个分段进行加锁，所以当多线程put的时候，只要不是放在一个分段中，就实现了真正的并行的插入。
但是，在统计size的时候，可就是获取hashmap全局信息的时候，就需要获取所有的分段锁才能统计。
分段锁的设计目的是细化锁的粒度，当操作不需要更新整个数组的时候，就仅仅针对数组中的一项进行加锁操作。
偏向锁/轻量级锁/重量级锁
这三种锁是指锁的状态，并且是针对Synchronized。在Java 5通过引入锁升级的机制来实现高效Synchronized。这三种锁的状态是通过对象监视器在对象头中的字段来表明的。
偏向锁是指一段同步代码一直被一个线程所访问，那么该线程会自动获取锁。降低获取锁的代价。
轻量级锁是指当锁是偏向锁的时候，被另一个线程所访问，偏向锁就会升级为轻量级锁，其他线程会通过自旋的形式尝试获取锁，不会阻塞，提高性能。
重量级锁是指当锁为轻量级锁的时候，另一个线程虽然是自旋，但自旋不会一直持续下去，当自旋一定次数的时候，还没有获取到锁，就会进入阻塞，该锁膨胀为重量级锁。重量级锁会让其他申请的线程进入阻塞，性能降低。
自旋锁
在Java中，自旋锁是指尝试获取锁的线程不会立即阻塞，而是采用循环的方式去尝试获取锁，这样的好处是减少线程上下文切换的消耗，缺点是循环会消耗CPU。
经常会听到Java锁这个词，但给自己的感觉很朦胧，有办法清楚的了解它吗？大虾们给个建议！！！
java锁机制Synchronized
打个比方：一个object就像一个大房子，大门永远打开。房子里有很多房间（也就是方法）。这些房间有上锁的（synchronized方法）， 和不上锁之分（普通方法）。房门口放着一把钥匙（key），这把钥匙可以打开所有上锁的房间。另外我把所有想调用该对象方法的线程比喻成想进入这房子某个 房间的人。所有的东西就这么多了，下面我们看看这些东西之间如何作用的。
在此我们先来明确一下我们的前提条件。该对象至少有一个synchronized方法，否则这个key还有啥意义。当然也就不会有我们的这个主题了。
一个人想进入某间上了锁的房间，他来到房子门口，看见钥匙在那儿（说明暂时还没有其他人要使用上锁的房间）。于是他走上去拿到了钥匙，并且按照自己 的计划使用那些房间。注意一点，他每次使用完一次上锁的房间后会马上把钥匙还回去。即使他要连续使用两间上锁的房间，中间他也要把钥匙还回去，再取回来。
因此，普通情况下钥匙的使用原则是：“随用随借，用完即还。”
这时其他人可以不受限制的使用那些不上锁的房间，一个人用一间可以，两个人用一间也可以，没限制。但是如果当某个人想要进入上锁的房间，他就要跑到大门口去看看了。有钥匙当然拿了就走，没有的话，就只能等了。
要是很多人在等这把钥匙，等钥匙还回来以后，谁会优先得到钥匙？Not guaranteed。象前面例子里那个想连续使用两个上锁房间的家伙，他中间还钥匙的时候如果还有其他人在等钥匙，那么没有任何保证这家伙能再次拿到。 （JAVA规范在很多地方都明确说明不保证，象Thread.sleep()休息后多久会返回运行，相同优先权的线程那个首先被执行，当要访问对象的锁被 释放后处于等待池的多个线程哪个会优先得到，等等。我想最终的决定权是在JVM，之所以不保证，就是因为JVM在做出上述决定的时候，绝不是简简单单根据 一个条件来做出判断，而是根据很多条。而由于判断条件太多，如果说出来可能会影响JAVA的推广，也可能是因为知识产权保护的原因吧。SUN给了个不保证 就混过去了。无可厚非。但我相信这些不确定，并非完全不确定。因为计算机这东西本身就是按指令运行的。即使看起来很随机的现象，其实都是有规律可寻。学过 计算机的都知道，计算机里随机数的学名是伪随机数，是人运用一定的方法写出来的，看上去随机罢了。另外，或许是因为要想弄的确定太费事，也没多大意义，所 以不确定就不确定了吧。）
1、synchronized关键字的作用域有二种：
1）是某个对象实例内，synchronized aMethod(){}可以防止多个线程同时访问这个对象的synchronized方法（如果一个对象有多个synchronized方法，只要一个线程访问了其中的一个synchronized方法，其它线程不能同时访问这个对象中任何一个synchronized方法）。这时，不同的对象实例的synchronized方法是不相干扰的。也就是说，其它线程照样可以同时访问相同类的另一个对象实例中的synchronized方法；
2）是某个类的范围，synchronized static aStaticMethod{}防止多个线程同时访问这个类中的synchronized static 方法。它可以对类的所有对象实例起作用。
2、除了方法前用synchronized关键字，synchronized关键字还可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。用法是: synchronized(this){/*区块*/}，它的作用域是当前对象；
3、synchronized关键字是不能继承的，也就是说，基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){}，而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法；
synchronized的一个简单例子
public class TextThread
{
/**
* @param args
*/
public static void main(String[] args)
{
// TODO 自动生成方法存根
TxtThread tt = new TxtThread();
new Thread(tt).start();
new Thread(tt).start();
new Thread(tt).start();
new Thread(tt).start();
}
}
class TxtThread implements Runnable
{
int num = 100;
String str = new String();
public void run()
{
while (true)
{
synchronized(str)
{
if (num0)
{
try
{
Thread.sleep(10);
}
catch(Exception e)
{
e.getMessage();
}
System.out.println(Thread.currentThread().getName()+ "this is "+ num--);
}
}
}
}
}
上面的例子中为了制造一个时间差,也就是出错的机会,使用了Thread.sleep(10)
总的说来，synchronized关键字可以作为函数的修饰符，也可作为函数内的语句，也就是平时说的同步方法和同步语句块。如果再细的分类，synchronized可作用于instance变量、object reference（对象引用）、static函数和class literals(类名称字面常量)身上。
java集合类哪个函数可以
java集合里面的函数
java集合里面的函数_java集合【1】——— 从集合接口框架说起
百里方欣
原创
关注
0点赞·155人阅读
(一) java集合分类
之前大概分为三种，Set，List，Map三种，JDK5之后，增加Queue.主要由Collection和Map两个接口衍生出来,同时Collection接口继承Iterable接口，所以我们也可以说java里面的集合类主要是由Iterable和Map两个接口以及他们的子接口或者其实现类组成。我们可以认为Collection接口定义了单列集合的规范，每次只能存储一个元素，而Map接口定义了双列集合的规范，每次能存储一对元素。
Iterable接口:主要是实现遍历功能
Collection接口: 允许重复
Set接口：无序，元素不可重复,访问元素只能通过元素本身来访问。
List接口：有序且可重复，可以根据元素的索引来访问集合中的元素。
Queue接口：队列集合
Map接口：映射关系，简单理解为键值对，Key不可重复，与Collection接口关系不大，只是个别函数使用到。
整个接口框架关系如下(来自百度百科)：
(1) Iterable接口
1. 内部定义的方法
java集合最源头的接口，实现这个接口的作用主要是集合对象可以通过迭代器去遍历每一个元素。
源码如下：
// 返回一个内部元素为T类型的迭代器(JDK1.5只有这个接口)
Iterator iterator();
// 遍历内部元素，action意思为动作，指可以对每个元素进行操作(JDK1.8添加)
default void forEach(Consumer super T action) {}
// 创建并返回一个可分割迭代器(JDK1.8添加)，分割的迭代器主要是提供可以并行遍历元素的迭代器，可以适应现在cpu多核的能力，加快速度。
default Spliterator spliterator() {
return Spliterators.spliteratorUnknownSize(iterator(), 0);
}
从上面可以看出，foreach迭代以及可分割迭代，都加了default关键字，这个是Java 8 新的关键字，以前接口的所有接口，具体子类都必须实现，而对于deafult关键字标识的方法，其子类可以不用实现，这也是接口规范发生变化的一点。
下面我们分别展示三个接口的调用：
1.1 iterator方法
public static void iteratorHasNext(){
List list=new ArrayList();
list.add("Jam");
list.add("Jane");
list.add("Sam");
// 返回迭代器
Iterator iterator=list.iterator();
// hashNext可以判断是否还有元素
while(iterator.hasNext()){
//next()作用是返回当前指针指向的元素,之后将指针移向下个元素
System.out.println(iterator.next());
}
}
当然也可以使用for-each loop方式遍历
for (String item : list) {
System.out.println(item);
}
但是实际上，这种写法在class文件中也是会转成迭代器形式，这只是一个语法糖。class文件如下：
public class IterableTest {
public IterableTest() { }
public static void main(String[] args) {
iteratorHasNext();
}
public static void iteratorHasNext() {
List list = new ArrayList();
list.add("Jam");
list.add("Jane");
list.add("Sam");
Iterator iterator = list.iterator();
Iterator var2 = list.iterator();
while(var2.hasNext()) {
String item = (String)var2.next();
System.out.println(item);
}
}
}
需要注意的一点是，迭代遍历的时候，如果删除或者添加元素，都会抛出修改异常，这是由于快速失败【fast-fail】机制。
public static void iteratorHasNext(){
List list=new ArrayList();
list.add("Jam");
list.add("Jane");
list.add("Sam");
for (String item : list) {
if(item.equals("Jam")){
list.remove(item);
}
System.out.println(item);
}
}
从下面的错误我们可以看出，第一个元素是有被打印出来的，也就是remove操作是成功的，只是遍历到第二个元素的时候，迭代器检查，发现被改变了，所以抛出了异常。
Jam
Exception in thread "main" java.util.ConcurrentModificationException
at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:909)
at java.util.ArrayList$Itr.next(ArrayList.java:859)
at IterableTest.iteratorHasNext(IterableTest.java:15)
at IterableTest.main(IterableTest.java:7)
1.2 forEach方法
其实就是把对每一个元素的操作当成了一个对象传递进来，对每一个元素进行处理。
default void forEach(Consumer super T action) {
Objects.requireNonNull(action);
for (T t : this) {
action.accept(t);
}
}
```java
当然像ArrayList自然也是有自己的实现的，那我们就可以使用这样的写法,简洁优雅。forEach方法在java8中参数是`java.util.function.Consumer`,可以称为**消费行为**或者说**动作**类型。
```java
list.forEach(x - System.out.print(x));
同时，我们只要实现Consumer接口，就可以自定义动作，如果不自定义，默认迭代顺序是按照元素的顺序。
public class ConsumerTest {
public static void main(String[] args) {
List list=new ArrayList();
list.add("Jam");
list.add("Jane");
list.add("Sam");
MyConsumer myConsumer = new MyConsumer();
Iterator it = list.iterator();
list.forEach(myConsumer);
}
static class MyConsumer implements Consumer {
@Override
public void accept(Object t) {
System.out.println("自定义打印：" + t);
}
}
}
输出的结果：
自定义打印：Jam
自定义打印：Jane
自定义打印：Sam
1.3 spliterator方法
这是一个为了并行遍历数据元素而设计的迭代方法，返回的是Spliterator，是专门并行遍历的迭代器。以发挥多核时代的处理器性能，java默认在集合框架中提供了一个默认的Spliterator实现，底层也就是Stream.isParallel()实现的，我们可以看一下源码：
// stream使用的就是spliterator
default Stream stream() {
return StreamSupport.stream(spliterator(), false);
}
default Spliterator spliterator() {
return Spliterators.spliterator(this, 0);
}
public static Stream stream(Spliterator spliterator, boolean parallel) {
Objects.requireNonNull(spliterator);
return new ReferencePipeline.Head(spliterator,
StreamOpFlag.fromCharacteristics(spliterator),
parallel);
}
使用的方法如下：
public static void spliterator(){
List list = Arrays.asList("1", "2", "3","4","5","6","7","8","9","10");
// 获取可迭代器
Spliterator spliterator = list.spliterator();
// 一个一个遍历
System.out.println("tryAdvance: ");
spliterator.tryAdvance(item-System.out.print(item+" "));
spliterator.tryAdvance(item-System.out.print(item+" "));
System.out.println("\n-------------------------------------------");
// 依次遍历剩下的
System.out.println("forEachRemaining: ");
spliterator.forEachRemaining(item-System.out.print(item+" "));
System.out.println("\n------------------------------------------");
// spliterator1:0~10
Spliterator spliterator1 = list.spliterator();
// spliterator1:6~10 spliterator2:0~5
Spliterator spliterator2 = spliterator1.trySplit();
// spliterator1:8~10 spliterator3:6~7
Spliterator spliterator3 = spliterator1.trySplit();
System.out.println("spliterator1: ");
spliterator1.forEachRemaining(item-System.out.print(item+" "));
System.out.println("\n------------------------------------------");
System.out.println("spliterator2: ");
spliterator2.forEachRemaining(item-System.out.print(item+" "));
System.out.println("\n------------------------------------------");
System.out.println("spliterator3: ");
spliterator3.forEachRemaining(item-System.out.print(item+" "));
}
tryAdvance() 一个一个元素进行遍历
forEachRemaining() 顺序地分块遍历
trySplit()进行分区形成另外的 Spliterator，使用在并行操作中，分出来的是前面一半，就是不断把前面一部分分出来
结果如下：
tryAdvance:
1 2
-------------------------------------------
forEachRemaining:
3 4 5 6 7 8 9 10
------------------------------------------
spliterator1:
8 9 10
------------------------------------------
spliterator2:
1 2 3 4 5
------------------------------------------
spliterator3:
6 7
还有一些其他的用法在这里就不列举了，主要是trySplit()之后，可以用于多线程遍历。理想的时候，可以平均分成两半，有利于并行计算，但是不是一定平分的。
2. Collection接口 extend Iterable
Collection接口可以算是集合类的一个根接口之一，一般不能够直接使用，只是定义了一个规范，定义了添加，删除等管理数据的方法。继承Collection接口的有List，Set,Queue,不过Queue定义了自己的一些接口，相对来说和其他的差异比较大。
2.1 内部定义的方法
源码如下：
boolean add(Object o) //添加元素
boolean remove(Object o) //移除元素
boolean addAll(Collection c) //批量添加
boolean removeAll(Collection c) //批量移除
void retainAll(Collection c) // 移除在c中不存在的元素
void clear() //清空集合
int size() //集合大小
boolean isEmpty() //是否为空
boolean contains(Object o) //是否包含在集合中
boolean containsAll(Collection c) //是否包含所有的元素
Iterator iterator() // 获取迭代器
Object[] toArray() // 转成数组
default boolean removeIf(Predicate super E filter) {} // 删除集合中复合条件的元素，删除成功返回true
boolean equals(Object o)
int hashCode()
default Spliterator spliterator() {} //获取可分割迭代器
default Stream stream() {} //获取流
default Stream parallelStream() {} //获取并行流
里面获取并行流的方法parallelStream(),其实就是通过默认的ForkJoinPool(主要用来使用分治法(Divide-and-Conquer Algorithm)来解决问题)，提高多线程任务的速度。我们可以使用ArrayList来演示一下平行处理能力。例如下面的例子，输出的顺序就不一定是1,2,3...，可能是乱序的，这是因为任务会被分成多个小任务，任务执行是没有特定的顺序的。
List list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
list.parallelStream()
.forEach(out::println);
2.2 继承Collection的主要接口
graph LR;
Collection --List-有顺序,可重复
List-有顺序,可重复 --LinkedList-使用链表实现,线程不安全
List-有顺序,可重复 --ArrayList-数组实现,线程不安全
List-有顺序,可重复 --Vector-数组实现,线程安全
Vector-数组实现,线程安全 --Stack-堆栈,先进后出
Collection--Set-不可重复,内部排序
Set-不可重复,内部排序--HashSet-hash表存储
HashSet-hash表存储--LinkHashSet-链表维护插入顺序
Set-不可重复,内部排序--TreeSet-二叉树实现,排序
Collection--Queue-队列,先进先出
2.2.1 List extend Collection
继承于Collection接口，有顺序，取出的顺序与存入的顺序一致，有索引，可以根据索引获取数据，允许存储重复的元素，可以放入为null的元素。
最常见的三个实现类就是ArrayList，Vector,LinkedList，ArrayList和Vector都是内部封装了对数组的操作，唯一不同的是，Vector是线程安全的，而ArrayList不是，理论上ArrayList操作的效率会比Vector好一些。
里面是接口定义的方法：
int size(); //获取大小
boolean isEmpty(); //判断是否为空
boolean contains(Object o); //是否包含某个元素
Iterator iterator(); //获取迭代器
Object[] toArray(); // 转化成为数组(对象)
T[] toArray(T[] a); // 转化为数组(特定位某个类)
boolean add(E e); //添加
boolean remove(Object o); //移除元素
boolean containsAll(Collection c); // 是否包含所有的元素
boolean addAll(Collection extends E c); //批量添加
boolean addAll(int index, Collection extends E c); //批量添加，指定开始的索引
boolean removeAll(Collection c); //批量移除
boolean retainAll(Collection c); //将c中不包含的元素移除
default void replaceAll(UnaryOperator operator) {}//替换
default void sort(Comparator super E c) {}// 排序
void clear();//清除所有的元素
boolean equals(Object o);//是否相等
int hashCode(); //计算获取hash值
E get(int index); //通过索引获取元素
E set(int index, E element);//修改元素
void add(int index, E element);//在指定位置插入元素
E remove(int index);//根据索引移除某个元素
int indexOf(Object o); //根据对象获取索引
int lastIndexOf(Object o); //获取对象元素的最后一个元素
ListIterator listIterator(); // 获取List迭代器
ListIterator listIterator(int index); // 根据索引获取当前的位置的迭代器
List subList(int fromIndex, int toIndex); //截取某一段数据
default Spliterator spliterator(){} //获取可切分迭代器
上面的方法都比较简单，值得一提的是里面出现了ListIterator，这是一个功能更加强大的迭代器，继承于Iterator,只能用于List类型的访问，拓展功能例如：通过调用listIterator()方法获得一个指向List开头的ListIterator，也可以调用listIterator(n)获取一个指定索引为n的元素的ListIterator,这是一个可以双向移动的迭代器。
操作数组索引的时候需要注意，由于List的实现类底层很多都是数组，所以索引越界会报错IndexOutOfBoundsException。
说起List的实现子类：
ArrayList：底层存储结构是数组结构，增加删除比较慢，查找比较快，是最常用的List集合。线程不安全。
LinkedList：底层是链表结构，增加删除比较快，但是查找比较慢。线程不安全。
Vector：和ArrayList差不多，但是是线程安全的，即同步。
2.2.2 Set extend Collection
Set接口，不允许放入重复的元素，也就是如果相同，则只存储其中一个。
下面是源码方法：
int size(); //获取大小
boolean isEmpty(); //是否为空
boolean contains(Object o); //是否包含某个元素
Iterator iterator(); //获取迭代器
Object[] toArray(); //转化成为数组
T[] toArray(T[] a); //转化为特定类的数组
boolean add(E e); //添加元素
boolean remove(Object o); //移除元素
boolean containsAll(Collection c); //是否包含所有的元素
boolean addAll(Collection extends E c); //批量添加
boolean retainAll(Collection c); //移除所有不存在于c集合中的元素
boolean removeAll(Collection c); //移除所有在c集合中存在的元素
void clear(); //清空集合
boolean equals(Object o); //是否相等
int hashCode(); //计算hashcode
default Spliterator spliterator() {} //获取可分割迭代器
主要的子类：
HashSet
允许空值
通过HashCode方法计算获取hash值，确定存储位置，无序。
LinkedHashSet
HashSet的子类
有顺序
TreeSet
如果无参数构建Set，则需要实现Comparable方法。
亦可以创建时传入比较方法，用于排序。
2.2.3 Queue extend Collection
队列接口，在Collection接口的接触上添加了增删改查接口定义，一般默认是先进先出，即FIFO，除了优先队列和栈，优先队列是自己定义了排序的优先顺序，队列中不允许放入null元素。
下面是源码：
boolean add(E e); //插入一个元素到队列，失败时返回IllegalStateException (如果队列容量不够)
boolean offer(E e); //插入一个元素到队列，失败时返回false
E remove(); //移除队列头的元素并移除
E poll(); //返回并移除队列的头部元素，队列为空时返回null
E element(); //返回队列头元素
E peek(); //返回队列头部的元素，队列为空时返回null
主要的子接口以及实现类有：
Deque(接口):Queue的子接口，双向队列，可以从两边存取
ArrayDeque：Deque的实现类，底层用数组实现，数据存贮在数组中
AbstractQueue：Queue的子接口，仅实现了add、remove和element三个方法
PriorityQueue：按照默认或者自己定义的顺序来排序元素，底层使用堆(完全二叉树)实现，使用动态数组实现，
BlockingQueue： 在java.util.concurrent包中，阻塞队列，满足当前无法处理的操作。
(2) Map接口
定义双列集合的规范Map，每次存储一对元素，即key和value。
key的类型可以和value的类型相同，也可以不同，任意的引用类型都可以。
key是不允许重复的，但是value是可以重复的，所谓重复是指计算的hash值系统。
下面的源码的方法：
V put(K key, V value); // 添加元素
V remove(Object key); // 删除元素
void putAll(Map extends K, ? extends V m); // 批量添加
void clear() // 移除所有元素
V get(Object key); // 通过key查询元素
int size(); // 查询集合大小
boolean isEmpty(); // 集合是否为空
boolean containsKey(Object key); // 是否包含某个key
boolean containsValue(Object value); // 是否包含某个value
Set keySet(); // 获取所有key的set集合
Collection values(); // 获取所有的value的set集合
Set entrySet(); // 返回键值对的set，每一个键值对是一个entry对象
boolean equals(Object o); // 用于比较的函数
int hashCode(); // 计算hashcode
default V getOrDefault(Object key, V defaultValue) // 获取key对应的Value，没有则返回默认值()
default void forEach(BiConsumer super K, ? super V action) {} // 遍历
default void replaceAll(BiFunction super K, ? super V, ? extends V function) {} // 批量替换
// 缺少这个key的时候才会添加进去
// 返回值是是key对应的value值，如果不存在，则返回的是刚刚放进去的value
default V putIfAbsent(K key, V value) {}
default boolean remove(Object key, Object value) {} // 移除元素
default boolean replace(K key, V oldValue, V newValue) {} // 替换
default V replace(K key, V value) {} //替换
// 和putIfAbsent有点像，只不过传进去的mappingFunction是映射函数，也就是如果不存在key对应的value，将会执行函数，函数返回值会被当成value添加进去，同时返回新的value值
default V computeIfAbsent(K key,Function super K, ? extends V mappingFunction) {}
// 和computeIfAbsent方法相反，只有key存在的时候，才会执行函数，并且返回
default V computeIfPresent(K key,BiFunction super K, ? super V, ? extends V remappingFunction) {}
// 不管如何都会执行映射函数，返回value
default V compute(K key,BiFunction super K, ? super V, ? extends V remappingFunction) {}
default V merge(K key, V value,BiFunction super V, ? super V, ? extends V remappingFunction) {}
值得注意的是，Map里面定义了一个Entry类，其实就是定义了一个存储数据的类型，一个entry就是一个.
Map的常用的实现子类：
HashMap：由数组和链表组成，线程不安全，无序。
LinkedHashMap：如果我们需要是有序的，那么就需要它，时间和空间效率没有HashMap那么高，底层是维护一条双向链表，保证了插入的顺序。
ConcurrentHashMap：线程安全，1.7JDK使用锁分离，每一段Segment都有自己的独立锁，相对来说效率也比较高。JDK1.8抛弃了Segment，使用Node数组+链表和红黑树实现，在线程安全控制上使用Synchronize和CAS，可以认为是优化的线程安全的HashMap。
HashTable：对比与HashMap主要是使用关键字synchronize，加上同步锁，线程安全。
(二)总结
这些集合原始接口到底是什么？为什么需要？
我想，这些接口其实都是一种规则/规范的定义，如果不这么做也可以，所有的子类自己实现，但是从迭代以及维护的角度来说，这就是一种抽象或者分类，比如定义了Iterator接口，某一些类就可以去继承或者实现，那就得遵守这个规范/契约。可以有所拓展，每个子类的拓展不一样，所以每个类就各有所长，但是都有一个中心，就是原始的集合接口。比如实现Map接口的所有类的中心思想都不变，只是各有所长，各分千秋，形成了大千集合世界。
【作者简介】：
秦怀，公众号【秦怀杂货店】作者，技术之路不在一时，山高水长，纵使缓慢，驰而不息。个人写作方向：Java源码解析，JDBC，Mybatis，Spring，redis，分布式，剑指Offer，LeetCode等，认真写好每一篇文章，不喜欢标题党，不喜欢花里胡哨，大多写系列文章，不能保证我写的都完全正确，但是我保证所写的均经过实践或者查找资料。遗漏或者错误之处，还望指正。
平日时间宝贵，只能使用晚上以及周末时间学习写作，关注我，我们一起成长吧~
java同步锁慢怎么解决
百度知道
java同步锁慢怎么解决
173******87
超过41用户采纳过TA的回答
关注
成为第1位粉丝
性能优化的需求实现中，如果使用了多线程并行来提高程序运行效率，那么一个很难绕开的部分就是同步加锁。同步锁会将多线程并行执行强制合流为串行执行，通常会成为整个程序的性能瓶颈所在，所以锁性能的优化必不可少。一般来说，优化锁性能的关键如下：
降低锁竞争概率
提高锁竞争效率
1. 降低锁竞争概率
1.1 减小锁粒度
要降低锁竞争发生的概率，一个非常直观的思路是减小锁粒度，核心思想是将大的全局锁分割为一个个范围精确的小锁，使线程的竞争对象从全局锁变更为小锁，从而减少锁竞争发生
关于java锁分离和java分段锁的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。