java并发容器类代码,java并发容器类代码是什么

java代码 clone()函数的作用是什么?

从楼主对回答的追问上发现，楼主的连JAVA基本的语法都很差啊。=号是赋值运算符，不是比较。

创新互联主要从事成都网站制作、网站设计、网页设计、企业做网站、公司建网站等业务。立足成都服务岳阳楼,十余年网站建设经验,价格优惠、服务专业,欢迎来电咨询建站服务:13518219792

double[] vectorValue;

vectorValue = vectorValue.clone();

这个段代码执行肯定报错了。但他还的意思还是很明确的。

首先：double[] vectorValue; 这个是定义了一个double类型的数组变量vectorValue。

其次：vectorValue = vectorValue.clone(); //这个是将vectorValue 克隆一份，赋值给自己。也就是说vectorValue变量指向了新的一块内存区域。

举个例子可能更能说明问题。

public class TestMain implements Cloneable {

private int i ;

public TestMain(int i){

this.i = i ;

}

@Override

protected Object clone() {

// TODO Auto-generated method stub

return new TestMain(this.getI()+1);

}

public int getI() {

return i;

}

/**

* @param args

public static void main(String[] args) {

// TODO Auto-generated method stub

TestMain tm1 = new TestMain(1);

TestMain tm2 = tm1;

tm1 = (TestMain)tm1.clone();

System.out.println(tm1.getI()); //tm1指向的是通过clone()方法创建的新的对象的地址，i的值已经是2了。

System.out.println(tm2.getI()); //tm2指向的还是tm1创建时的地址，i的值为1

}

有哪些Java web里的并发框架，都有哪些？

一、并发是一种需求，以下先介绍一下javaweb对于高并发的处理思路：

1、synchronized 关键字

可用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这段代码。可能锁对象包括： this，临界资源对象，Class 类对象

2、同步方法

同步方法锁定的是当前对象。当多线程通过同一个对象引用多次调用当前同步方法时，需同步执行。

3、同步代码块

同步代码块的同步粒度更加细致，是商业开发中推荐的编程方式。可以定位到具体的同步位置，而不是简单的将方法整体实现同步逻辑。在效率上，相对更高。

A）锁定临界对象

同步代码块在执行时，是锁定 object 对象。当多个线程调用同一个方法时，锁定对象不变的情况下，需同步执行。

B）锁定当前对象

4、锁的底层实现

Java 虚拟机中的同步(Synchronization)基于进入和退出管程(Monitor)对象实现。同步方法并不是由 monitor enter 和 monitor exit 指令来实现同步的，而是由方法调用指令读取运行时常量池中方法的 ACC_SYNCHRONIZED 标志来隐式实现的。

5、锁的种类

Java 中锁的种类大致分为偏向锁，自旋锁，轻量级锁，重量级锁。

锁的使用方式为：先提供偏向锁，如果不满足的时候，升级为轻量级锁，再不满足，升级为重量级锁。自旋锁是一个过渡的锁状态，不是一种实际的锁类型。

锁只能升级，不能降级。

6、volatile 关键字

变量的线程可见性。在 CPU 计算过程中，会将计算过程需要的数据加载到 CPU 计算缓存中，当 CPU 计算中断时，有可能刷新缓存，重新读取内存中的数据。在线程运行的过程中，如果某变量被其他线程修改，可能造成数据不一致的情况，从而导致结果错误。而 volatile 修饰的变量是线程可见的，当 JVM 解释 volatile 修饰的变量时，会通知 CPU，在计算过程中，每次使用变量参与计算时，都会检查内存中的数据是否发生变化，而不是一直使用 CPU 缓存中的数据，可以保证计算结果的正确。

更多、此外还有很多细节需要通过学习去了解和完善，此处就不一一列举了。

二、并发框架

并发框架很多，如ExecutorService、RxJava、Disruptor、Akka等，具体选择哪个（或者都不选择）是根据项目需求选择的，框架本身的差异并不大，基本都是如下模式

并发编程解惑之线程

主要内容：

进程是资源分配的最小单位，每个进程都有独立的代码和数据空间，一个进程包含 1 到 n 个线程。线程是 CPU 调度的最小单位，每个线程有独立的运行栈和程序计数器，线程切换开销小。

Java 程序总是从主类的 main 方法开始执行，main 方法就是 Java 程序默认的主线程，而在 main 方法中再创建的线程就是其他线程。在 Java 中，每次程序启动至少启动 2 个线程。一个是 main 线程，一个是垃圾收集线程。每次使用 Java 命令启动一个 Java 程序，就相当于启动一个 JVM 实例，而每个 JVM 实例就是在操作系统中启动的一个进程。

多线程可以通过继承或实现接口的方式创建。

Thread 类是 JDK 中定义的用于控制线程对象的类，该类中封装了线程执行体 run() 方法。需要强调的一点是，线程执行先后与创建顺序无关。

通过 Runnable 方式创建线程相比通过继承 Thread 类创建线程的优势是避免了单继承的局限性。若一个 boy 类继承了 person 类，boy 类就无法通过继承 Thread 类的方式来实现多线程。

使用 Runnable 接口创建线程的过程：先是创建对象实例 MyRunnable，然后将对象 My Runnable 作为 Thread 构造方法的入参，来构造出线程。对于 new Thread(Runnable target) 创建的使用同一入参目标对象的线程，可以共享该入参目标对象 MyRunnable 的成员变量和方法，但 run() 方法中的局部变量相互独立，互不干扰。

上面代码是 new 了三个不同的 My Runnable 对象，如果只想使用同一个对象，可以只 new 一个 MyRunnable 对象给三个 new Thread 使用。

实现 Runnable 接口比继承 Thread 类所具有的优势：

线程有新建、可运行、阻塞、等待、定时等待、死亡 6 种状态。一个具有生命的线程，总是处于这 6 种状态之一。每个线程可以独立于其他线程运行，也可和其他线程协同运行。线程被创建后，调用 start() 方法启动线程，该线程便从新建态进入就绪状态。

NEW 状态（新建状态）实例化一个线程之后，并且这个线程没有开始执行，这个时候的状态就是 NEW 状态：

RUNNABLE 状态（就绪状态）：

阻塞状态有 3 种：

如果一个线程调用了一个对象的 wait 方法，那么这个线程就会处于等待状态（waiting 状态）直到另外一个线程调用这个对象的 notify 或者 notifyAll 方法后才会解除这个状态。

run() 里的代码执行完毕后，线程进入终结状态（TERMINATED 状态）。

线程状态有 6 种：新建、可运行、阻塞、等待、定时等待、死亡。

我们看下 join 方法的使用：

运行结果：

我们来看下 yield 方法的使用：

运行结果：

线程与线程之间是无法直接通信的，A 线程无法直接通知 B 线程，Java 中线程之间交换信息是通过共享的内存来实现的，控制共享资源的读写的访问，使得多个线程轮流执行对共享数据的操作，线程之间通信是通过对共享资源上锁或释放锁来实现的。线程排队轮流执行共享资源，这称为线程的同步。

Java 提供了很多同步操作（也就是线程间的通信方式），同步可使用 synchronized 关键字、Object 类的 wait/notifyAll 方法、ReentrantLock 锁、无锁同步 CAS 等方式来实现。

ReentrantLock 是 JDK 内置的一个锁对象，用于线程同步（线程通信），需要用户手动释放锁。

运行结果：

这表明同一时间段只能有 1 个线程执行 work 方法，因为 work 方法里的代码需要获取到锁才能执行，这就实现了多个线程间的通信，线程 0 获取锁，先执行，线程 1 等待，线程 0 释放锁，线程 1 继续执行。

synchronized 是一种语法级别的同步方式，称为内置锁。该锁会在代码执行完毕后由 JVM 释放。

输出结果跟 ReentrantLock 一样。

Java 中的 Object 类默认是所有类的父类，该类拥有 wait、 notify、notifyAll 方法，其他对象会自动继承 Object 类，可调用 Object 类的这些方法实现线程间的通信。

除了可以通过锁的方式来实现通信，还可通过无锁的方式来实现，无锁同 CAS（Compare-and-Swap，比较和交换）的实现，需要有 3 个操作数：内存地址 V，旧的预期值 A，即将要更新的目标值 B，当且仅当内存地址 V 的值与预期值 A 相等时，将内存地址 V 的值修改为目标值 B，否则就什么都不做。

我们通过计算器的案例来演示无锁同步 CAS 的实现方式，非线程安全的计数方式如下：

线程安全的计数方式如下：

运行结果：

线程安全累加的结果才是正确的，非线程安全会出现少计算值的情况。JDK 1.5 开始，并发包里提供了原子操作的类，AtomicBoolean 用原子方式更新的 boolean 值，AtomicInteger 用原子方式更新 int 值，AtomicLong 用原子方式更新 long 值。 AtomicInteger 和 AtomicLong 还提供了用原子方式将当前值自增 1 或自减 1 的方法，在多线程程序中，诸如 ++i 或 i++ 等运算不具有原子性，是不安全的线程操作之一。通常我们使用 synchronized 将该操作变成一个原子操作，但 JVM 为此种操作提供了原子操作的同步类 Atomic，使用 AtomicInteger 做自增运算的性能是 ReentantLock 的好几倍。

上面我们都是使用底层的方式实现线程间的通信的，但在实际的开发中，我们应该尽量远离底层结构，使用封装好的 API，例如 J.U.C 包（java.util.concurrent，又称并发包）下的工具类 CountDownLath、CyclicBarrier、Semaphore，来实现线程通信，协调线程执行。

CountDownLatch 能够实现线程之间的等待，CountDownLatch 用于某一个线程等待若干个其他线程执行完任务之后，它才开始执行。

CountDownLatch 类只提供了一个构造器：

CountDownLatch 类中常用的 3 个方法：

运行结果：

CyclicBarrier 字面意思循环栅栏，通过它可以让一组线程等待至某个状态之后再全部同时执行。当所有等待线程都被释放以后，CyclicBarrier 可以被重复使用，所以有循环之意。

相比 CountDownLatch，CyclicBarrier 可以被循环使用，而且如果遇到线程中断等情况时，可以利用 reset() 方法，重置计数器，CyclicBarrier 会比 CountDownLatch 更加灵活。

CyclicBarrier 提供 2 个构造器：

上面的方法中，参数 parties 指让多少个线程或者任务等待至 barrier 状态；参数 barrierAction 为当这些线程都达到 barrier 状态时会执行的内容。

CyclicBarrier 中最重要的方法 await 方法，它有 2 个重载版本。下面方法用来挂起当前线程，直至所有线程都到达 barrier 状态再同时执行后续任务。

而下面的方法则是让这些线程等待至一定的时间，如果还有线程没有到达 barrier 状态就直接让到达 barrier 的线程执行任务。

运行结果：

CyclicBarrier 用于一组线程互相等待至某个状态，然后这一组线程再同时执行，CountDownLatch 是不能重用的，而 CyclicBarrier 可以重用。

Semaphore 类是一个计数信号量，它可以设定一个阈值，多个线程竞争获取许可信号，执行完任务后归还，超过阈值后，线程申请许可信号时将会被阻塞。Semaphore 可以用来构建对象池，资源池，比如数据库连接池。

假如在服务器上运行着若干个客户端请求的线程。这些线程需要连接到同一数据库，但任一时刻只能获得一定数目的数据库连接。要怎样才能够有效地将这些固定数目的数据库连接分配给大量的线程呢？

给方法加同步锁，保证同一时刻只能有一个线程去调用此方法，其他所有线程排队等待，但若有 10 个数据库连接，也只有一个能被使用，效率太低。另外一种方法，使用信号量，让信号量许可与数据库可用连接数为相同数量，10 个数据库连接都能被使用，大大提高性能。

上面三个工具类是 J.U.C 包的核心类，J.U.C 包的全景图就比较复杂了：

J.U.C 包（java.util.concurrent）中的高层类（Lock、同步器、阻塞队列、Executor、并发容器）依赖基础类（AQS、非阻塞数据结构、原子变量类），而基础类是通过 CAS 和 volatile 来实现的。我们尽量使用顶层的类，避免使用基础类 CAS 和 volatile 来协调线程的执行。J.U.C 包其他的内容，在其他的篇章会有相应的讲解。

Future 是一种异步执行的设计模式，类似 ajax 异步请求，不需要同步等待返回结果，可继续执行代码。使 Runnable（无返回值不支持上报异常）或 Callable（有返回值支持上报异常）均可开启线程执行任务。但是如果需要异步获取线程的返回结果，就需要通过 Future 来实现了。

Future 是位于 java.util.concurrent 包下的一个接口，Future 接口封装了取消任务，获取任务结果的方法。

在 Java 中，一般是通过继承 Thread 类或者实现 Runnable 接口来创建多线程， Runnable 接口不能返回结果，JDK 1.5 之后，Java 提供了 Callable 接口来封装子任务，Callable 接口可以获取返回结果。我们使用线程池提交 Callable 接口任务，将返回 Future 接口添加进 ArrayList 数组，最后遍历 FutureList，实现异步获取返回值。

运行结果：

上面就是异步线程执行的调用过程，实际开发中用得更多的是使用现成的异步框架来实现异步编程，如 RxJava，有兴趣的可以继续去了解，通常异步框架都是结合远程 HTTP 调用 Retrofit 框架来使用的，两者结合起来用，可以避免调用远程接口时，花费过多的时间在等待接口返回上。

线程封闭是通过本地线程 ThreadLocal 来实现的，ThreadLocal 是线程局部变量（local vari able），它为每个线程都提供一个变量值的副本，每个线程对该变量副本的修改相互不影响。

在 JVM 虚拟机中，堆内存用于存储共享的数据（实例对象），也就是主内存。Thread Local .set()、ThreadLocal.get() 方法直接在本地内存（工作内存）中写和读共享变量的副本，而不需要同步数据，不用像 synchronized 那样保证数据可见性，修改主内存数据后还要同步更新到工作内存。

Myabatis、hibernate 是通过 threadlocal 来存储 session 的，每一个线程都维护着一个 session，对线程独享的资源操作很方便，也避免了线程阻塞。

ThreadLocal 类位于 Thread 线程类内部，我们分析下它的源码：

ThreadLocal 和 Synchonized 都用于解决多线程并发访问的问题，访问多线程共享的资源时，Synchronized 同步机制采用了以时间换空间的方式，提供一份变量让多个线程排队访问，而 ThreadLocal 采用了以空间换时间的方式，提供每个线程一个变量，实现数据隔离。

ThreadLocal 可用于数据库连接 Connection 对象的隔离，使得每个请求线程都可以复用连接而又相互不影响。

在 Java 里面，存在强引用、弱引用、软引用、虚引用。我们主要来了解下强引用和弱引用：

上面 a、b 对实例 A、B 都是强引用

而上面这种情况就不一样了，即使 b 被置为 null，但是 c 仍然持有对 C 对象实例的引用，而间接的保持着对 b 的强引用，所以 GC 不会回收分配给 b 的空间，导致 b 无法回收也没有被使用，造成了内存泄漏。这时可以通过 c = null; 来使得 c 被回收，但也可以通过弱引用来达到同样目的：

从源码中可以看出 Entry 里的 key 对 ThreadLocal 实例是弱引用：

Entry 里的 key 对 ThreadLocal 实例是弱引用，将 key 值置为 null，堆中的 ThreadLocal 实例是可以被垃圾收集器（GC）回收的。但是 value 却存在一条从 Current Thread 过来的强引用链，只有当当前线程 Current Thread 销毁时，value 才能被回收。在 threadLocal 被设为 null 以及线程结束之前，Entry 的键值对都不会被回收，出现内存泄漏。为了避免泄漏，在 ThreadLocalMap 中的 set/get Entry 方法里，会对 key 为 null 的情况进行判断，如果为 null 的话，就会对 value 置为 null。也可以通过 ThreadLocal 的 remove 方法（类似加锁和解锁，最后 remove 一下，解锁对象的引用）直接清除，释放内存空间。

总结来说，利用 ThreadLocal 来访问共享数据时，JVM 通过设置 ThreadLocalMap 的 Key 为弱引用，来避免内存泄露，同时通过调用 remove、get、set 方法的时候，回收弱引用（Key 为 null 的 Entry）。当使用 static ThreadLocal 的时候（如上面的 Spring 多数据源），static 变量在类未加载的时候，它就已经加载，当线程结束的时候，static 变量不一定会被回收，比起普通成员变量使用的时候才加载，static 的生命周期变长了，若没有及时回收，容易产生内存泄漏。

使用线程池，可以重用存在的线程，减少对象创建、消亡的开销，可控制最大并发线程数，避免资源竞争过度，还能实现线程定时执行、单线程执行、固定线程数执行等功能。

Java 把线程的调用封装成了一个 Executor 接口，Executor 接口中定义了一个 execute 方法，用来提交线程的执行。Executor 接口的子接口是 ExecutorService，负责管理线程的执行。通过 Executors 类的静态方法可以初始化

ExecutorService 线程池。Executors 类的静态方法可创建不同类型的线程池：

但是，不建议使用 Executors 去创建线程池，而是通过 ThreadPoolExecutor 的方式，明确给出线程池的参数去创建，规避资源耗尽的风险。

如果使用 Executors 去创建线程池：

最佳的实践是通过 ThreadPoolExecutor 手动地去创建线程池，选取合适的队列存储任务，并指定线程池线程大小。通过线程池实现类 ThreadPoolExecutor 可构造出线程池的，构造函数有下面几个重要的参数：

参数 1：corePoolSize

线程池核心线程数。

参数 2：workQueue

阻塞队列，用于保存执行任务的线程，有 4 种阻塞队列可选：

参数 3：maximunPoolSize

线程池最大线程数。如果阻塞队列满了（有界的阻塞队列），来了一个新的任务，若线程池当前线程数小于最大线程数，则创建新的线程执行任务，否则交给饱和策略处理。如果是无界队列就不存在这种情况，任务都在无界队列里存储着。

参数 4：RejectedExecutionHandler

拒绝策略，当队列满了，而且线程达到了最大线程数后，对新任务采取的处理策略。

有 4 种策略可选：

最后，还可以自定义处理策略。

参数 5：ThreadFactory

创建线程的工厂。

参数 6：keeyAliveTime

线程没有任务执行时最多保持多久时间终止。当线程池中的线程数大于 corePoolSize 时，线程池中所有线程中的某一个线程的空闲时间若达到 keepAliveTime，则会终止，直到线程池中的线程数不超过 corePoolSize。但如果调用了 allowCoreThread TimeOut(boolean value) 方法，线程池中的线程数就算不超过 corePoolSize，keepAlive Time 参数也会起作用，直到线程池中的线程数量变为 0。

参数 7：TimeUnit

配合第 6 个参数使用，表示存活时间的时间单位最佳的实践是通过 ThreadPoolExecutor 手动地去创建线程池，选取合适的队列存储任务，并指定线程池线程大小。

运行结果：

线程池创建线程时，会将线程封装成工作线程 Worker，Worker 在执行完任务后，还会不断的去获取队列里的任务来执行。Worker 的加锁解锁机制是继承 AQS 实现的。

我们来看下 Worker 线程的运行过程：

总结来说，如果当前运行的线程数小于 corePoolSize 线程数，则获取全局锁，然后创建新的线程来执行任务如果运行的线程数大于等于 corePoolSize 线程数，则将任务加入阻塞队列 BlockingQueue 如果阻塞队列已满，无法将任务加入 BlockingQueue，则获取全局所，再创建新的线程来执行任务

如果新创建线程后使得线程数超过了 maximumPoolSize 线程数，则调用 Rejected ExecutionHandler.rejectedExecution() 方法根据对应的拒绝策略处理任务。

CPU 密集型任务，线程执行任务占用 CPU 时间会比较长，应该配置相对少的线程数，避免过度争抢资源，可配置 N 个 CPU+1 个线程的线程池；但 IO 密集型任务则由于需要等待 IO 操作，线程经常处于等待状态，应该配置相对多的线程如 2*N 个 CPU 个线程，A 线程阻塞后，B 线程能马上执行，线程多竞争激烈，能饱和的执行任务。线程提交 SQL 后等待数据库返回结果时间较长的情况，CPU 空闲会较多，线程数应设置大些，让更多线程争取 CPU 的调度。

java并发包有哪些类

1、CyclicBarrier

一个同步辅助类，允许一组线程相互等待，直到这组线程都到达某个公共屏障点。该barrier在释放等待线程后可以重用，因此称为循环的barrier。

来个示例：

[java] view plain copy

package test;

import java.util.concurrent.CyclicBarrier;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class Recipes_CyclicBarrier {

public static CyclicBarrier barrier = new CyclicBarrier(10);

public static void main(String[] args){

ExecutorService executor = Executors.newCachedThreadPool();//FixedThreadPool(10);

for(int i=1;i=10;i++){

executor.submit(new Thread(new Runner(i+"号选手")));

}

executor.shutdown();

}

class Runner implements Runnable{

private String name;

public Runner(String name){

this.name = name;

}

@Override

public void run() {

System.out.println(name + "准备好了。");

try {

Recipes_CyclicBarrier.barrier.await(); //此处就是公共屏障点，所有线程到达之后，会释放所有等待的线程

} catch (Exception e) {

}

System.out.println(name + "起跑！");

}

2、CountDownLatch

CountDownLatch和CyclicBarrier有点类似，但是还是有些区别的。CountDownLatch也是一个同步辅助类，它允许一个或者多个线程一直等待，直到正在其他线程中执行的操作完成。它是等待正在其他线程中执行的操作，并不是线程之间相互等待。CountDownLatch初始化时需要给定一个计数值，每个线程执行完之后，必须调用countDown()方法使计数值减1，直到计数值为0，此时等待的线程才会释放。

来个示例：

[java] view plain copy

package test;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.CyclicBarrier;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class CountDownLatchDemo {

public static CountDownLatch countDownLatch = new CountDownLatch(10);//初始化计数值

public static void main(String[] args){

ExecutorService executor = Executors.newCachedThreadPool();//FixedThreadPool(10);

for(int i=1;i=10;i++){

executor.submit(new Thread(new Runner1(i+"号选手")));

}

executor.shutdown();

}

class Runner1 implements Runnable{

private String name;

public Runner1(String name){

this.name = name;

}

@Override

public void run() {

System.out.println(name + "准备好了。");

CountDownLatchDemo.countDownLatch.countDown(); //计数值减1

try {

CountDownLatchDemo.countDownLatch.await();

} catch (Exception e) {

}

System.out.println(name + "起跑！");

}

3、CopyOnWriteArrayList CopyOnWriteArraySet

CopyOnWriteArrayList CopyOnWriteArraySet是并发容器，适合读多写少的场景，如网站的黑白名单设置。缺点是内存占用大，数据一致性的问题，CopyOnWrite容器只能保证数据最终的一致性，不能保证数据实时一致性。鉴于它的这些缺点，可以使用ConcurrentHashMap容器。

实现原理：新增到容器的数据会放到一个新的容器中，然后将原容器的引用指向新容器，旧容器也会存在，因此会有两个容器占用内存。我们也可以用同样的方式实现自己的CopyOnWriteMap。

4、ConcurrentHashMap

ConcurrentHashMap同样是一个并发容器，将同步粒度最小化。

实现原理：ConcurrentHashMap默认是由16个Segment组成，每个Segment由多个Hashtable组成，数据变更需要经过两次哈希算法，第一次哈希定位到Segment，第二次哈希定位到Segment下的Hashtable，容器只会将单个Segment锁住，然后操作Segment下的Hashtable，多个Segment之间不受影响。如果需要扩容不是对Segment扩容而是对Segment下的Hashtable扩容。虽然经过两次哈希算法会使效率降低，但是比锁住整个容器效率要高得多。

5、BlockingQueue

BlockingQueue只是一个接口，它的实现类有ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue、SynchronousQueue、DelayQueue、LinkedBlockingDeque。

ArrayBlockingQueue：由数据支持的有界阻塞队列。

LinkedBlockingQueue：基于链接节点、范围任意的阻塞队列。

PriorityBlockingQueue：无界阻塞队列。

SynchronousQueue：一种阻塞队列，其中每个插入操作必须等待另一个线程的对应移除操作。

DelayQueue：Delayed元素的一个无界阻塞队列。

LinkedBlockingDeque：基于链接节点、范围任意的双端阻塞队列，可以在队列的两端添加、移除元素。

6、Lock

Lock分为公平锁和非公平锁，默认是非公平锁。实现类有ReetrantLock、ReetrantReadWriteLock，都依赖于AbstractQueuedSynchronizer抽象类。ReetrantLock将所有Lock接口的操作都委派到Sync类上，Sync有两个子类：NonFairSync和FaiSync，通过其命名就能知道分别处理非公平锁和公平锁的。AbstractQueuedSynchronizer把所有请求构成一个CLH队列，这里是一个虚拟队列，当有线程竞争锁时，该线程会首先尝试是否能获取锁，这种做法对于在队列中等待的线程来说是非公平的，如果有线程正在Running，那么通过循环的CAS操作将此线程增加到队尾，直至添加成功。

7、Atomic包

Atomic包下的类实现了原子操作，有对基本类型如int、long、boolean实现原子操作的类：AtomicInteger、AtomicLong、AtomicBoolean，如果需要对一个对象进行原子操作，也有对对象引用进行原子操作的AtomicReference类，还有对对象数组操作的原子类：AtomicIntegerArray、AtomicLongArray、AtomicReferenceArray。原子操作核心思想是CAS操作，然后调用底层操作系统指令来实现。

javase线程怎么存储到容器

Java 并发重要知识点

java 线程池

ThreadPoolExecutor 类分析

ThreadPoolExecutor 类中提供的四个构造方法。我们来看最长的那个，其余三个都是在这个构造方法的基础上产生（其他几个构造方法说白点都是给定某些默认参数的构造方法比如默认制定拒绝策略是什么）。

/**

* 用给定的初始参数创建一个新的ThreadPoolExecutor。

public ThreadPoolExecutor(int corePoolSize,//线程池的核心线程数量

int maximumPoolSize,//线程池的最大线程数

long keepAliveTime,//当线程数大于核心线程数时，多余的空闲线程存活的最长时间

TimeUnit unit,//时间单位

BlockingQueueRunnable workQueue,//任务队列，用来储存等待执行任务的队列

ThreadFactory threadFactory,//线程工厂，用来创建线程，一般默认即可

RejectedExecutionHandler handler//拒绝策略，当提交的任务过多而不能及时处理时，我们可以定制策略来处理任务

) {

if (corePoolSize 0 ||

maximumPoolSize = 0 ||

maximumPoolSize corePoolSize ||

keepAliveTime 0)

throw new IllegalArgumentException();

if (workQueue == null || threadFactory == null || handler == null)

throw new NullPointerException();

this.corePoolSize = corePoolSize;

this.maximumPoolSize = maximumPoolSize;

this.workQueue = workQueue;

this.keepAliveTime = unit.toNanos(keepAliveTime);

this.threadFactory = threadFactory;

this.handler = handler;

}

下面这些对创建非常重要，在后面使用线程池的过程中你一定会用到！所以，务必拿着小本本记清楚。

ThreadPoolExecutor 3 个最重要的参数：

corePoolSize : 核心线程数线程数定义了最小可以同时运行的线程数量。

maximumPoolSize : 当队列中存放的任务达到队列容量的时候，当前可以同时运行的线程数量变为最大线程数。

workQueue: 当新任务来的时候会先判断当前运行的线程数量是否达到核心线程数，如果达到的话，新任务就会被存放在队列中。

ThreadPoolExecutor其他常见参数 :

keepAliveTime:当线程池中的线程数量大于 corePoolSize 的时候，如果这时没有新的任务提交，核心线程外的线程不会立即销毁，而是会等待，直到等待的时间超过了 keepAliveTime才会被回收销毁；

unit : keepAliveTime 参数的时间单位。

threadFactory :executor 创建新线程的时候会用到。

handler :饱和策略。关于饱和策略下面单独介绍一下。

下面这张图可以加深你对线程池中各个参数的相互关系的理解（图片来源：《Java 性能调优实战》）：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nzbqGRz9-1654600571133)()]

ThreadPoolExecutor 饱和策略定义:

如果当前同时运行的线程数量达到最大线程数量并且队列也已经被放满了任务时，ThreadPoolTaskExecutor 定义一些策略:

ThreadPoolExecutor.AbortPolicy ：抛出 RejectedExecutionException来拒绝新任务的处理。

ThreadPoolExecutor.CallerRunsPolicy ：调用执行自己的线程运行任务，也就是直接在调用execute方法的线程中运行(run)被拒绝的任务，如果执行程序已关闭，则会丢弃该任务。因此这种策略会降低对于新任务提交速度，影响程序的整体性能。如果您的应用程序可以承受此延迟并且你要求任何一个任务请求都要被执行的话，你可以选择这个策略。

ThreadPoolExecutor.DiscardPolicy ：不处理新任务，直接丢弃掉。

ThreadPoolExecutor.DiscardOldestPolicy ：此策略将丢弃最早的未处理的任务请求。

举个例子：

Spring 通过 ThreadPoolTaskExecutor 或者我们直接通过 ThreadPoolExecutor 的构造函数创建线程池的时候，当我们不指定 RejectedExecutionHandler 饱和策略的话来配置线程池的时候默认使用的是 ThreadPoolExecutor.AbortPolicy。在默认情况下，ThreadPoolExecutor 将抛出 RejectedExecutionException 来拒绝新来的任务，这代表你将丢失对这个任务的处理。对于可伸缩的应用程序，建议使用 ThreadPoolExecutor.CallerRunsPolicy。当最大池被填满时，此策略为我们提供可伸缩队列。（这个直接查看 ThreadPoolExecutor 的构造函数源码就可以看出，比较简单的原因，这里就不贴代码了。）

推荐使用 ThreadPoolExecutor 构造函数创建线程池

在《阿里巴巴 Java 开发手册》“并发处理”这一章节，明确指出线程资源必须通过线程池提供，不允许在应用中自行显式创建线程。

为什么呢？

使用线程池的好处是减少在创建和销毁线程上所消耗的时间以及系统资源开销，解决资源不足的问题。如果不使用线程池，有可能会造成系统创建大量同类线程而导致消耗完内存或者“过度切换”的问题。

另外，《阿里巴巴 Java 开发手册》中强制线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 构造函数的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险

Executors 返回线程池对象的弊端如下(后文会详细介绍到)：

FixedThreadPool 和 SingleThreadExecutor ：允许请求的队列长度为 Integer.MAX_VALUE,可能堆积大量的请求，从而导致 OOM。

CachedThreadPool 和 ScheduledThreadPool ：允许创建的线程数量为 Integer.MAX_VALUE ，可能会创建大量线程，从而导致 OOM。

方式一：通过ThreadPoolExecutor构造函数实现（推荐）通过构造方法实现

方式二：通过 Executor 框架的工具类 Executors 来实现我们可以创建三种类型的 ThreadPoolExecutor：

FixedThreadPool

SingleThreadExecutor

CachedThreadPool

对应 Executors 工具类中的方法如图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YGd4ygZu-1654600571136)()]

正确配置线程池参数

说到如何给线程池配置参数，美团的骚操作至今让我难忘（后面会提到）！

我们先来看一下各种书籍和博客上一般推荐的配置线程池参数的方式，可以作为参考！

常规操作

很多人甚至可能都会觉得把线程池配置过大一点比较好！我觉得这明显是有问题的。就拿我们生活中非常常见的一例子来说：并不是人多就能把事情做好，增加了沟通交流成本。你本来一件事情只需要 3 个人做，你硬是拉来了 6 个人，会提升做事效率嘛？我想并不会。线程数量过多的影响也是和我们分配多少人做事情一样，对于多线程这个场景来说主要是增加了上下文切换成本。不清楚什么是上下文切换的话，可以看我下面的介绍。

上下文切换：

多线程编程中一般线程的个数都大于 CPU 核心的个数，而一个 CPU 核心在任意时刻只能被一个线程使用，为了让这些线程都能得到有效执行，CPU 采取的策略是为每个线程分配时间片并轮转的形式。当一个线程的时间片用完的时候就会重新处于就绪状态让给其他线程使用，这个过程就属于一次上下文切换。概括来说就是：当前任务在执行完 CPU 时间片切换到另一个任务之前会先保存自己的状态，以便下次再切换回这个任务时，可以再加载这个任务的状态。任务从保存到再加载的过程就是一次上下文切换。

上下文切换通常是计算密集型的。也就是说，它需要相当可观的处理器时间，在每秒几十上百次的切换中，每次切换都需要纳秒量级的时间。所以，上下文切换对系统来说意味着消耗大量的 CPU 时间，事实上，可能是操作系统中时间消耗最大的操作。

Linux 相比与其他操作系统（包括其他类 Unix 系统）有很多的优点，其中有一项就是，其上下文切换和模式切换的时间消耗非常少。

类比于实现世界中的人类通过合作做某件事情，我们可以肯定的一点是线程池大小设置过大或者过小都会有问题，合适的才是最好。

如果我们设置的线程池数量太小的话，如果同一时间有大量任务/请求需要处理，可能会导致大量的请求/任务在任务队列中排队等待执行，甚至会出现任务队列满了之后任务/请求无法处理的情况，或者大量任务堆积在任务队列导致 OOM。这样很明显是有问题的！ CPU 根本没有得到充分利用。

但是，如果我们设置线程数量太大，大量线程可能会同时在争取 CPU 资源，这样会导致大量的上下文切换，从而增加线程的执行时间，影响了整体执行效率。

有一个简单并且适用面比较广的公式：

CPU 密集型任务(N+1)：这种任务消耗的主要是 CPU 资源，可以将线程数设置为 N（CPU 核心数）+1，比 CPU 核心数多出来的一个线程是为了防止线程偶发的缺页中断，或者其它原因导致的任务暂停而带来的影响。一旦任务暂停，CPU 就会处于空闲状态，而在这种情况下多出来的一个线程就可以充分利用 CPU 的空闲时间。

I/O 密集型任务(2N)：这种任务应用起来，系统会用大部分的时间来处理 I/O 交互，而线程在处理 I/O 的时间段内不会占用 CPU 来处理，这时就可以将 CPU 交出给其它线程使用。因此在 I/O 密集型任务的应用中，我们可以多配置一些线程，具体的计算方法是 2N。

如何判断是 CPU 密集任务还是 IO 密集任务？

CPU 密集型简单理解就是利用 CPU 计算能力的任务比如你在内存中对大量数据进行排序。但凡涉及到网络读取，文件读取这类都是 IO 密集型，这类任务的特点是 CPU 计算耗费时间相比于等待 IO 操作完成的时间来说很少，大部分时间都花在了等待 IO 操作完成上。

美团的骚操作

美团技术团队在《Java线程池实现原理及其在美团业务中的实践》open in new window这篇文章中介绍到对线程池参数实现可自定义配置的思路和方法。

美团技术团队的思路是主要对线程池的核心参数实现自定义可配置。这三个核心参数是：

corePoolSize : 核心线程数线程数定义了最小可以同时运行的线程数量。

maximumPoolSize : 当队列中存放的任务达到队列容量的时候，当前可以同时运行的线程数量变为最大线程数。

workQueue: 当新任务来的时候会先判断当前运行的线程数量是否达到核心线程数，如果达到的话，新任务就会被存放在队列中。

为什么是这三个参数？

我在这篇《新手也能看懂的线程池学习总结》open in new window 中就说过这三个参数是 ThreadPoolExecutor 最重要的参数，它们基本决定了线程池对于任务的处理策略。

如何支持参数动态配置？且看 ThreadPoolExecutor 提供的下面这些方法。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Sm89qdJZ-1654600571137)()]

格外需要注意的是corePoolSize，程序运行期间的时候，我们调用 setCorePoolSize（）这个方法的话，线程池会首先判断当前工作线程数是否大于corePoolSize，如果大于的话就会回收工作线程。

另外，你也看到了上面并没有动态指定队列长度的方法，美团的方式是自定义了一个叫做 ResizableCapacityLinkedBlockIngQueue 的队列（主要就是把LinkedBlockingQueue的capacity 字段的final关键字修饰给去掉了，让它变为可变的）。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cmNN5yAL-1654600571138)()]

还没看够？推荐 why神的[《如何设置线程池参数？美团给出了一个让面试官虎躯一震的回答。》open in new window](如何设置线程池参数？美团给出了一个让面试官虎躯一震的回答。 (qq.com))这篇文章，深度剖析，很不错哦！

Java 常见并发容器

JDK 提供的这些容器大部分在 java.util.concurrent 包中。

ConcurrentHashMap : 线程安全的 HashMap

CopyOnWriteArrayList : 线程安全的 List，在读多写少的场合性能非常好，远远好于 Vector。

ConcurrentLinkedQueue : 高效的并发队列，使用链表实现。可以看做一个线程安全的 LinkedList，这是一个非阻塞队列。

BlockingQueue : 这是一个接口，JDK 内部通过链表、数组等方式实现了这个接口。表示阻塞队列，非常适合用于作为数据共享的通道。

ConcurrentSkipListMap : 跳表的实现。这是一个 Map，使用跳表的数据结构进行快速查找。

ConcurrentHashMap

我们知道 HashMap 不是线程安全的，在并发场景下如果要保证一种可行的方式是使用 Collections.synchronizedMap() 方法来包装我们的 HashMap。但这是通过使用一个全局的锁来同步不同线程间的并发访问，因此会带来不可忽视的性能问题。

所以就有了 HashMap 的线程安全版本—— ConcurrentHashMap 的诞生。

在 ConcurrentHashMap 中，无论是读操作还是写操作都能保证很高的性能：在进行读操作时(几乎)不需要加锁，而在写操作时通过锁分段技术只对所操作的段加锁而不影响客户端对其它段的访问。

CopyOnWriteArrayList

CopyOnWriteArrayList 简介

public class CopyOnWriteArrayListE

extends Object

implements ListE, RandomAccess, Cloneable, Serializable

在很多应用场景中，读操作可能会远远大于写操作。由于读操作根本不会修改原有的数据，因此对于每次读取都进行加锁其实是一种资源浪费。我们应该允许多个线程同时访问 List 的内部数据，毕竟读取操作是安全的。

这和我们之前在多线程章节讲过 ReentrantReadWriteLock 读写锁的思想非常类似，也就是读读共享、写写互斥、读写互斥、写读互斥。JDK 中提供了 CopyOnWriteArrayList 类比相比于在读写锁的思想又更进一步。为了将读取的性能发挥到极致，CopyOnWriteArrayList 读取是完全不用加锁的，并且更厉害的是：写入也不会阻塞读取操作。只有写入和写入之间需要进行同步等待。这样一来，读操作的性能就会大幅度提升。那它是怎么做的呢？

CopyOnWriteArrayList 是如何做到的？

CopyOnWriteArrayList 类的所有可变操作（add，set 等等）都是通过创建底层数组的新副本来实现的。当 List 需要被修改的时候，我并不修改原有内容，而是对原有数据进行一次复制，将修改的内容写入副本。写完之后，再将修改完的副本替换原来的数据，这样就可以保证写操作不会影响读操作了。

从 CopyOnWriteArrayList 的名字就能看出 CopyOnWriteArrayList 是满足 CopyOnWrite 的。所谓 CopyOnWrite 也就是说：在计算机，如果你想要对一块内存进行修改时，我们不在原有内存块中进行写操作，而是将内存拷贝一份，在新的内存中进行写操作，写完之后呢，就将指向原来内存指针指向新的内存，原来的内存就可以被回收掉了。

CopyOnWriteArrayList 读取和写入源码简单分析

CopyOnWriteArrayList 读取操作的实现

读取操作没有任何同步控制和锁操作，理由就是内部数组 array 不会发生修改，只会被另外一个 array 替换，因此可以保证数据安全。

/** The array, accessed only via getArray/setArray. */

private transient volatile Object[] array;

public E get(int index) {

return get(getArray(), index);

}

@SuppressWarnings("unchecked")

private E get(Object[] a, int index) {

return (E) a[index];

}

final Object[] getArray() {

return array;

}

CopyOnWriteArrayList 写入操作的实现

CopyOnWriteArrayList 写入操作 add()方法在添加集合的时候加了锁，保证了同步，避免了多线程写的时候会 copy 出多个副本出来。

/**

* Appends the specified element to the end of this list.

* @param e element to be appended to this list

* @return {@code true} (as specified by {@link Collection#add})

public boolean add(E e) {

final ReentrantLock lock = this.lock;

lock.lock();//加锁

try {

Object[] elements = getArray();

int len = elements.length;

Object[] newElements = Arrays.copyOf(elements, len + 1);//拷贝新数组

newElements[len] = e;

setArray(newElements);

return true;

} finally {

lock.unlock();//释放锁

}

ConcurrentLinkedQueue

Java 提供的线程安全的 Queue 可以分为阻塞队列和非阻塞队列，其中阻塞队列的典型例子是 BlockingQueue，非阻塞队列的典型例子是 ConcurrentLinkedQueue，在实际应用中要根据实际需要选用阻塞队列或者非阻塞队列。阻塞队列可以通过加锁来实现，非阻塞队列可以通过 CAS 操作实现。

从名字可以看出，ConcurrentLinkedQueue这个队列使用链表作为其数据结构．ConcurrentLinkedQueue 应该算是在高并发环境中性能最好的队列了。它之所有能有很好的性能，是因为其内部复杂的实现。

ConcurrentLinkedQueue 内部代码我们就不分析了，大家知道 ConcurrentLinkedQueue 主要使用 CAS 非阻塞算法来实现线程安全就好了。

ConcurrentLinkedQueue 适合在对性能要求相对较高，同时对队列的读写存在多个线程同时进行的场景，即如果对队列加锁的成本较高则适合使用无锁的 ConcurrentLinkedQueue 来替代。

BlockingQueue

BlockingQueue 简介

上面我们己经提到了 ConcurrentLinkedQueue 作为高性能的非阻塞队列。下面我们要讲到的是阻塞队列——BlockingQueue。阻塞队列（BlockingQueue）被广泛使用在“生产者-消费者”问题中，其原因是 BlockingQueue 提供了可阻塞的插入和移除的方法。当队列容器已满，生产者线程会被阻塞，直到队列未满；当队列容器为空时，消费者线程会被阻塞，直至队列非空时为止。

BlockingQueue 是一个接口，继承自 Queue，所以其实现类也可以作为 Queue 的实现来使用，而 Queue 又继承自 Collection 接口。下面是 BlockingQueue 的相关实现类：

BlockingQueue 的实现类

下面主要介绍一下 3 个常见的 BlockingQueue 的实现类：ArrayBlockingQueue、LinkedBlockingQueue 、PriorityBlockingQueue 。

ArrayBlockingQueue

ArrayBlockingQueue 是 BlockingQueue 接口的有界队列实现类，底层采用数组来实现。

public class ArrayBlockingQueueE

extends AbstractQueueE

implements BlockingQueueE, Serializable{}

ArrayBlockingQueue 一旦创建，容量不能改变。其并发控制采用可重入锁 ReentrantLock ，不管是插入操作还是读取操作，都需要获取到锁才能进行操作。当队列容量满时，尝试将元素放入队列将导致操作阻塞;尝试从一个空队列中取一个元素也会同样阻塞。

ArrayBlockingQueue 默认情况下不能保证线程访问队列的公平性，所谓公平性是指严格按照线程等待的绝对时间顺序，即最先等待的线程能够最先访问到 ArrayBlockingQueue。而非公平性则是指访问 ArrayBlockingQueue 的顺序不是遵守严格的时间顺序，有可能存在，当 ArrayBlockingQueue 可以被访问时，长时间阻塞的线程依然无法访问到 ArrayBlockingQueue。如果保证公平性，通常会降低吞吐量。如果需要获得公平性的 ArrayBlockingQueue，可采用如下代码：

private static ArrayBlockingQueueInteger blockingQueue = new ArrayBlockingQueueInteger(10,true);

LinkedBlockingQueue

LinkedBlockingQueue 底层基于单向链表实现的阻塞队列，可以当做无界队列也可以当做有界队列来使用，同样满足 FIFO 的特性，与 ArrayBlockingQueue 相比起来具有更高的吞吐量，为了防止 LinkedBlockingQueue 容量迅速增，损耗大量内存。通常在创建 LinkedBlockingQueue 对象时，会指定其大小，如果未指定，容量等于 Integer.MAX_VALUE 。

java并发容器类代码,java并发容器类代码是什么

java代码 clone()函数的作用是什么?

有哪些Java web里的并发框架，都有哪些？

并发编程解惑之线程

java并发包有哪些类

javase线程怎么存储到容器

其他资讯