JUC线程高级教程

JUC

原创者：文思，感谢尚硅谷，资料来源于尚硅谷

1、volatile关键字与内存可见性

2、原子变量与CAS算法

3、同步容器类

4、闭锁操作

5、Callable接口(常用)

6、Lock同步锁

7、读写锁

8、线程八锁

9、线程池

10、线程调度

11、ForkJoinPool分支/合并框架工作窃取

一、JUC

1、volatile关键字与内存可见性

Java5.0提供了java.util.concurrent（简称JUC ）包，在此包中增加了在并发编程中很常用的实用工具类，用于定义类似于线程的自定义子系统，包括线程池、异步IO 和轻量级任务框架。提供可调的、灵活的线程池。还提供了设计用于多线程上下文中的Collection实现等。

内存可见性（Memory Visibility）是指当某个线程正在使用对象状态而另一个线程在同时修改该状态，需要确保当一个线程修改了对象状态后，其他线程能够看到发生的状态变化。

可见性错误是指当读操作与写操作在不同的线程中执行时，我们无法确保执行读操作的线程能适时地看到其他线程写入的值，有时甚至是根本不可能的事情。

如下代码示例：

public classTestVolatile {

public static void main(String[] args){

Testt = new Test();

new Thread(t).start();

while(true){

if(t.getFlag()){

System.out.println("-----enter main while if----");

break;

}

class Test implementsRunnable{

private boolean flag = false;

@Override

public void run() {

try{

Thread.sleep(1000);

}catch(Exception e){ }

flag = true;

System.out.println("------this is test child thread-----");

}

public boolean getFlag(){

return this.flag;

}

运行结果：

----------this is test child thread-----------

主线程main的------enter main while if-------一直没进入执行。这就是发生了内存可见性错误，上述程序执行流程：

由于布尔变量flag偏底层，所以jvm执行布尔运算时非常快，所以在test子线程内复制修改flag之后，还没有来得及写入main主线程，main主线程就进入到while中，导致如上效果。

如果用同步synchronized锁则往往是噩梦的开始：

while(true){

synchronized (t) {

if(t.getFlag()){

System.out.println("-----enter main while if-----");

break;

}

这样会导致极低的效率。同步锁具有互斥性，如果多个县城访问这块，如果一个线程已持有这个锁，另一个线程发现后就阻塞在这里等待锁的释放，然后就等待另一个线程调用完释放锁，然后cpu再调度。所以不要轻易甚至不要使用同步synchronized锁。这就需要volatile关键字：private volatile boolean flag = false。

*一、volatile关键字当多个线程进行操作共享数据时，可以保证内存中的数据可见。

* 相较于 synchronized 是一种较为轻量级的同步策略。

*注意：

* 1. volatile不具备“互斥性”

* 2. volatile不能保证变量的“原子性”

public classTestVolatile {

public static void main(String[] args){

Testt = new Test();

new Thread(t).start();

while(true){

if(t.getFlag()){

System.out.println("------enter main while if------");

break;

}

class Test implementsRunnable{

private volatile boolean flag = false;

@Override

public void run() {

try{

Thread.sleep(1000);

}catch(Exception e){

}

flag = true;

System.out.println("-------this is test child thread-----");

}

public boolean getFlag(){

return this.flag;

}

运行结果：

-----------enter main while if---------

----------this is test child thread-----------

程序执行流程：

子线程不会同步变量到自己的线程缓存中，直接修改主内存中的变量。

Java提供了一种稍弱的同步机制，即volatile 变量，用来确保将变量的更新操作通知到其他线程。可以将volatile 看做一个轻量级的锁，但是又与锁有些不同：

对于多线程，不是一种互斥关系

不能保证变量状态的“原子性”操作

2、原子变量与CAS算法

volatile只能解决变量同步问题，但解决不了并发中的原子性问题(原子性问题不再演示)。i++ 的操作实际上分为三个步骤“读-改-写”

int i = 10; i = i++; 相当于：int temp = i; i = i + 1; i = temp;可看出仅仅依靠volatile解决不了原子性问题。

Jdk提供了原子变量来解决此问题：

Java.util.concurrent.atomic类的小工具包，支持在单个变量上解除锁的线程安全编程。事实上，此包中的类可将volatile 值、字段和数组元素的概念扩展到那些也提供原子条件更新操作的类.

类AtomicBoolean、AtomicInteger、AtomicLong 和AtomicReference 的实例各自提供对相应类型单个变量的访问和更新。每个类也为该类型提供适当的实用工具方法。AtomicIntegerArray、AtomicLongArray 和AtomicReferenceArray 类进一步扩展了原子操作，对这些类型的数组提供了支持。这些类在为其数组元素提供volatile 访问语义方面也引人注目，这对于普通数组来说是不受支持的。

核心方法：booleancompareAndSet(expectedValue, updateValue)

java.util.concurrent.atomic 包下提供了一些原子操作的常用类:

AtomicBoolean 、AtomicInteger 、AtomicLong 、AtomicReference

AtomicIntegerArray 、AtomicLongArray

AtomicMarkableReference

AtomicReferenceArray

AtomicStampedReference

CAS (Compare-And-Swap) 是一种硬件对并发的支持，针对多处理器操作而设计的处理器中的一种特殊指令，用于管理对共享数据的并发访问

CAS 是一种无锁的非阻塞算法的实现

CAS 包含了3 个操作数：

1、需要读写的内存值V

2、进行比较的值A

3、拟写入的新值B

当且仅当V 的值等于A 时，CAS 通过原子方式用新值B 来更新V 的值，否则不会执行任何操作

示例：

*一、i++ 的原子性问题：i++ 的操作实际上分为三个步骤“读-改-写”

* inti = 10;

* i = i++; //10

* inttemp= i;

* i = i + 1;

* i =temp;

*二、原子变量：在 java.util.concurrent.atomic 包下提供了一些原子变量。

* 1.volatile保证内存可见性

* 2.CAS（Compare-And-Swap）算法保证数据变量的原子性

* CAS算法是硬件对于并发操作的支持

* CAS包含了三个操作数：

* ①内存值 V

* ②预估值 A

* ③更新值 B

* 当且仅当 V == A 时， V = B; 否则，不会执行任何操作。

public classTestAtomicDemo {

public static void main(String[] args) {

AtomicDemoa = new AtomicDemo();

for(int i=0;i<10;i++){//启动10个子线程

new Thread(a).start();

}

class AtomicDemo implements Runnable{

private AtomicInteger number = new AtomicInteger(0);

public void run() {

try{

Thread.sleep(2000);

}catch(Exception e){

}

System.out.println("number="+this.handlerNumber());

}

public int handlerNumber(){//子线程里加1

return number.getAndIncrement();

}

以上使用原子性变量解决了原子性问题。CAS算法是基于硬件底层算法实现的，也不是使用锁的互斥原理，不会释放cpu的控制权，所以效率比锁高。

3、同步容器类

HashMap与HashTable的区别之一是HashMap线程不安全，HashTable线程安全，所以HashTable的效率也低。

Java 5在java.util.concurrent 包中提供了多种并发容器类来改进同步容器的性能。

ConcurrentHashMap同步容器类是Java 5 增加的一个线程安全的哈希表。对与多线程的操作，介于HashMap 与Hashtable 之间。内部采用“锁分段”机制替代Hashtable 的独占锁，进而提高性能。

此包还提供了设计用于多线程上下文中的Collection 实现：ConcurrentHashMap、ConcurrentSkipListMap、ConcurrentSkipListSet、CopyOnWriteArrayList 和CopyOnWriteArraySet。当期望许多线程访问一个给定collection 时，ConcurrentHashMap 通常优于同步的HashMap，ConcurrentSkipListMap 通常优于同步的TreeMap。当期望的读数和遍历远远大于列表的更新数时，CopyOnWriteArrayList 优于同步的ArrayList。

JDK1.8对ConcurrentSkipListMap又取消了分段锁，又采用回了CAS。

示例：

import java.util.Iterator;

import java.util.concurrent.CopyOnWriteArrayList;

*CopyOnWriteArrayList/CopyOnWriteArraySet :“写入并复制”

*注意：添加操作多时，效率低，因为每次添加时都会进行复制，开销非常的大。并发迭代操作多时可以选择。

public class TestCopyOnWriteArrayList {

publicstatic void main(String[] args) {

HelloThreadht = new HelloThread();

for(int i = 0; i < 10; i++) {

newThread(ht).start();

}

class HelloThread implements Runnable{

private staticCopyOnWriteArrayList list = new CopyOnWriteArrayList<>();

static{

list.add("AA");

list.add("BB");

list.add("CC");

}

@Override

publicvoid run() {

Iteratorit = list.iterator();

while(it.hasNext()){

System.out.println(it.next());

list.add("AA");

}

4、闭锁操作

CountDownLatch 一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。

闭锁可以延迟线程的进度直到其到达终止状态，闭锁可以用来确保某些活动直到其他活动都完成才继续执行：

1、确保某个计算在其需要的所有资源都被初始化之后才继续执行;

2、确保某个服务在其依赖的所有其他服务都已经启动之后才启动;

3、等待直到某个操作所有参与者都准备就绪再继续执行

示例：

* CountDownLatch：闭锁，在完成某些运算是，只有其他所有线程的运算全部完成，当前运算才继续执行

public classTestCountDownLatch {

public static void main(String[] args) {

//new CountDownLatch(10)里面的参数是倒计时初始化个数，因为下面会创建10个线程，每启动一个线程就减1，当为0是就说明所有线程创建完毕

final CountDownLatch latch = new CountDownLatch(10);

LatchDemold = new LatchDemo(latch);

long startTime= System.currentTimeMillis();

for(int i=0;i<10;i++){

new Thread(ld).start();

}

try {

latch.await();

}catch(InterruptedException e) {

}

long endTime= System.currentTimeMillis();

System.out.println("----------"+(endTime-startTime));

}

class LatchDemo implements Runnable{

private CountDownLatch latch;

publicLatchDemo(CountDownLatch latch){

this.latch = latch;

}

@Override

public void run() {

for(int i=0;i<50000;i++){

if(1%2==0){

System.out.println(i);

}

latch.countDown();

}

一定要在await()之前必须调用countDown()进行递减操作。

5、Callable接口(常用)

以前都认为创建线程的方式是两种：继承Thread类和实现Runnable接口。现在可归结为四种，还有：实现Callable接口与

Java 5.在java.util.concurrent 提供了一个新的创建执行线程的方式：Callable 接口。

Callable 接口类似于Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。但是Runnable 不会返回结果，并且无法抛出经过检查的异常。

Callable 需要依赖FutureTask 。

根据以上分析FutureTask 也可以用作闭锁，实现闭锁的效果。

示例：

*一、创建执行线程的方式三：实现Callable 接口。相较于实现 Runnable 接口的方式，方法可以有返回值，并且可以抛出异常。

*二、执行Callable 方式，需要 FutureTask 实现类的支持，用于接收运算结果。 FutureTask是 Future接口的实现类

public classTestCallable {

public static void main(String[] args) {

int t = 0;

ThreadDemotd = new ThreadDemo(t);

FutureTaskresult= newFutureTask(td);

long starttime= System.currentTimeMillis();

new Thread(result).start();

try {

IntegerresultInt= result.get();

long endtime= System.currentTimeMillis();

System.out.println("---time---"+(endtime-starttime));

System.out.println("---resultInt---"+resultInt);

}catch(InterruptedException e) {

}catch(ExecutionException e){

}

class ThreadDemo implements Callable{

private Integer count;

public ThreadDemo(Integer count){

this.count = count;

}

@Override

public Integer call() throws Exception {

for(int i=0;i<1000000000;i++){

count++;

}

return count;

}

运行结果：

---time---3369

---resultInt---1000000000

6、Lock同步锁

在jdk1.5以前，解决线程安全只能用同步代码块和同步方法以及volatile 。

Jdk1.5后可以用同步锁Lock，这是一个显示锁，需要通过lock()方法上锁，通过unlock()方法释放锁。但并不是一种替代内置锁的方法，而是当内置锁不适用时，作为一种可选择的高级功能。

ReentrantLock 实现了Lock 接口，并提供了与synchronized 相同的互斥性和内存可见性。但相较于synchronized 提供了更高的处理锁的灵活性。

不加锁的同步问题：

加锁示例：

*一、用于解决多线程安全问题的方式：

* synchronized:隐式锁

* 1.同步代码块. 2. 同步方法

*jdk1.5后：

* 3.同步锁 Lock

*注意：是一个显示锁，需要通过 lock() 方法上锁，必须通过 unlock() 方法进行释放锁

public classTestLock {

public static void main(String[] args){

LockDemold = new LockDemo();

new Thread(ld,"1号售票点,").start();

new Thread(ld,"2号售票点,").start();

new Thread(ld,"3号售票点,").start();

}

class LockDemo implements Runnable{

private volatile int count=10;

private Lock lock = new ReentrantLock();

@Override

public void run() {

while(count>0){

lock.lock();

try {

Thread.sleep(100);

}catch(InterruptedException e) {

}finally{

lock.unlock();

}

count--;

System.out.println(Thread.currentThread().getName()+"剩余票数:"+count);

}

7、读写锁

写写,读写需要"互斥"，读读不需要"互斥"，这样即避免了线程安全问题又提高了效率。

一个读写锁维护了一个读锁和一个写锁，其中读锁可以多个线程使用，写锁只能一个线程独占。

/**

*写写,读写需要"互斥"

*读读不需要"互斥"

public classTestReadWriteLock {

public static void main(String[] args){

ReadWriteLockDemod = new ReadWriteLockDemo();

new Thread(new Runnable(){

@Override

public void run() {

d.write(1000000000);

}

},"write").start();

for(int i=0;i<10;i++){

new Thread(new Runnable(){

@Override

public void run() {

d.read();

}

},"read").start();

}

class ReadWriteLockDemo{

private int number = 0;

ReadWriteLocklock= newReentrantReadWriteLock();

public void read(){

lock.readLock().lock();;

try{

System.out.println(Thread.currentThread().getName()+":number="+this.number);

}finally{

lock.readLock().unlock();

}

public void write(int number){

lock.writeLock().lock();

try{

System.out.println(Thread.currentThread().getName());

this.number = number;

}finally{

lock.writeLock().unlock();

}

运行结果：

write

read:number=1000000000

8、线程八锁

a：两个普通同步方法，两个线程，标准打印

public classTestThread8demo {

public static void main(String[] args) {

Numbern = new Number();

new Thread(new Runnable(){

@Override

public void run() {

n.getOne();

}

}).start();

new Thread(new Runnable(){

@Override

public void run() {

n.getTwo();

}

}).start();

}

class Number{

public synchronized void getOne(){

System.out.println("One");

}

public synchronized void getTwo(){

System.out.println("Two");

}

运行结果：立刻打印出

One

Two

b：两个普通同步方法，其中一个线程休眠3秒后，两个线程再标准打印

public synchronizedvoidgetOne(){

try {

Thread.sleep(3000);

}catch(InterruptedException e) {

}

System.out.println("One");

}

public synchronized void getTwo(){

System.out.println("Two");

}

运行结果：3秒后打印出

One

Two

推论：

一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法了，其它的线程都只能等待，换句话说，某一个时刻内，只能有唯一一个线程去访问这些synchronized方法。

锁的是当前对象this，被锁定后，其它的线程都不能进入到当前对象的其它的synchronized方法。

c:新增一个普通方法(这样一个同步锁并休眠3秒，一个同步锁，一个普通方法)

public classTestThread8demo {

public static void main(String[] args) {

Numbern = new Number();

new Thread(new Runnable(){

@Override

public void run() {

n.getOne();

}

}).start();

new Thread(new Runnable(){

@Override

public void run() {

n.getTwo();

}

}).start();

new Thread(new Runnable(){

@Override

public void run() {

n.getThree();

}

}).start();

}

class Number{

public synchronized void getOne(){

try {

Thread.sleep(3000);

}catch(InterruptedException e) {

}

System.out.println("One");

}

public synchronized void getTwo(){

System.out.println("Two");

}

public void getThree(){

System.out.println("Three");

}

运行结果：

Three

3秒后……

One

Two

推论：普通方法与同步锁无关。

d:两个普通的同步方法，同时两个对象访问，打印

public classTestThread8demo {

public static void main(String[] args) {

Numbern = new Number();

Numbern2 = new Number();

new Thread(new Runnable(){

@Override

public void run() {

n.getOne();

}

}).start();

new Thread(new Runnable(){

@Override

public void run() {

n2.getTwo();

}

}).start();

}

class Number{

public synchronized void getOne(){

try {

Thread.sleep(3000);

}catch(InterruptedException e) {

}

System.out.println("One");

}

public synchronized void getTwo(){

System.out.println("Two");

}

运行结果：

Two

3秒后……

One

推论：

换成两个对象后，就不是同一把锁了，彼此不受影响。更进一步印证了synchronized最小作用域的范围是对象。

也就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁，可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁，所以毋须等待该实例对象已获取锁的非静态同步方法释放锁就可以获取他们自己的锁。

e：修改getOne为静态同步，然后一个对象访问打印

public classTestThread8demo {

public static void main(String[] args) {

Numbern = newNumber();

new Thread(new Runnable(){

@Override

public void run() {

n.getOne();

}

}).start();

new Thread(new Runnable(){

@Override

public void run() {

n.getTwo();

}

}).start();

}

class Number{

public static synchronized void getOne(){

try {

Thread.sleep(3000);

}catch(InterruptedException e) {

}

System.out.println("One");

}

public synchronized void getTwo(){

System.out.println("Two");

}

运行结果：

Two

3秒后……

One

推论：

所有的静态同步方法用的也是同一把锁：类对象本身，和非静态对象锁是两个不同的对象，所以静态同步方法与非静态同步方法之间是不会有竞态条件的。所以two先执行了，one休眠后继续执行。但是请看g

f：修改getOne和getTwo都为静态同步，然后一个对象访问打印

public classTestThread8demo {

public static void main(String[] args) {

Numbern = new Number();

Numbern2= newNumber();

new Thread(new Runnable(){

@Override

public void run() {

n.getOne();

}

}).start();

new Thread(new Runnable(){

@Override

public void run() {

n.getTwo();

}

}).start();

}

class Number{

public static synchronized void getOne(){

try {

Thread.sleep(3000);

}catch(InterruptedException e) {

}

System.out.println("One");

}

public static synchronized void getTwo(){

System.out.println("Two");

}

运行结果：

3秒后…

One

Two

推论：

进一步且只印证了所有的静态同步方法用的也是同一把锁：类对象本身，但是请看g

g：修改getOne和getTwo都为静态同步，然后两个对象访问打印

public classTestThread8demo {

public static void main(String[] args) {

Numbern = new Number();

Numbern2 = newNumber();

new Thread(new Runnable(){

@Override

public void run() {

n.getOne();

}

}).start();

new Thread(new Runnable(){

@Override

public void run() {

n2.getTwo();

}

}).start();

}

class Number{

public static synchronized void getOne(){

try {

Thread.sleep(3000);

}catch(InterruptedException e) {

}

System.out.println("One");

}

public static synchronized void getTwo(){

System.out.println("Two");

}

运行结果：

3秒后……

One

Two

推论：

所有的静态同步方法用的也是同一把锁：类对象本身，和非静态对象锁是两个不同的对象，所以静态同步方法与非静态同步方法之间是不会有竞态条件的。但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁。

h：只修改getOne为静态同步，然后两个对象访问打印

public classTestThread8demo {

public static void main(String[] args) {

Numbern = new Number();

Numbern2 = new Number();

new Thread(new Runnable(){

@Override

public void run() {

n.getOne();

}

}).start();

new Thread(new Runnable(){

@Override

public void run() {

n2.getTwo();

}

}).start();

}

class Number{

public static synchronized void getOne(){

try {

Thread.sleep(3000);

}catch(InterruptedException e) {

}

System.out.println("One");

}

public synchronized void getTwo(){

System.out.println("Two");

}

运行结果：

Two

3秒后……

One

推论：进一步印证了静态同步方法的锁是类对象本身，非静态方法的锁是对象本身，两类锁不是同一把锁。

线程八锁关键点总结：

I:非静态方法的锁默认为 this, 静态方法的锁为对应的 Class 实例。对象锁与类锁不互相干扰，不会有竞态条件。

Ii:某一个时刻内，只能有一个线程持有锁，无论几个方法。

9、线程池

第四种获取线程的方法：线程池。

提供一个线程队列，队列中保存着所有等待状态的线程，避免了创建与销毁的开销，提高了响应的速度。

线程池的体系结构：

* java.util.concurrent.Executor :负责线程的使用与调度的根接口

* |--**ExecutorService子接口: 线程池的主要接口

* |--ThreadPoolExecutor线程池的实现类

* |--ScheduledExecutorService子接口：负责线程的调度

* |--ScheduledThreadPoolExecutor：继承 ThreadPoolExecutor，实现 ScheduledExecutorService

可以看到，虽然ExecutorService下有许多子接口和实现类，但是这里建议使用Executors来获取线程。

工具类: Executors

* ExecutorServicenewFixedThreadPool() :创建固定大小的线程池

* ExecutorServicenewCachedThreadPool() :缓存线程池，线程池的数量不固定，可以根据需求自动的更改数量。可自动进行线程回收。

* ExecutorServicenewSingleThreadExecutor() :创建单个线程池。线程池中只有一个线程

*ScheduledExecutorService newScheduledThreadPool() :创建固定大小的线程，可以延迟或定时的执行任务。

示例1：

public classTestThreadPool {

public static void main(String[] args) {

//1创建有5个线程的线程池

ExecutorServiceexecutorService= Executors.newFixedThreadPool(5);

//执行10次线程，为线程分配任务

for (int i = 0; i < 10; i++) {

executorService.submit(new Runnable(){

@Override

public void run() {

int sum = 0;

for (int i = 0; i < 100; i++) {

sum ++;

}

System.out.println(Thread.currentThread().getName()+"="+sum);

}

});

}

//关闭线程,executorService.shutdownNow()是立即关闭

executorService.shutdown();

}

运行结果：

pool-1-thread-1:1

pool-1-thread-1:3

pool-1-thread-1:4

pool-1-thread-2:0

pool-1-thread-3:7

pool-1-thread-3:9

pool-1-thread-5:94

pool-1-thread-2:98

pool-1-thread-2:99

可以看到始终thread1-5，都用的线程池里的5个线程。

示例2：使用带返回值的Callable接口

public classTestThreadPool {

public static void main(String[] args) throwsInterruptedException,ExecutionException {

//1创建有5个线程的线程池

ExecutorServiceexecutorService= Executors.newFixedThreadPool(5);

//为线程分配10个任务

for(int i=0;i<10;i++){

Futureresult= executorService.submit(new Callable(){

@Override

public Integer call() throws Exception {

int count = 0;

for(int i=0;i<100;i++){

count++;

}

return count;

}

});

System.out.println(result.get());

}

//关闭线程，executorService.shutdownNow()是立即关闭

executorService.shutdown();

}

10、线程调度

即ScheduledExecutorService的使用示例：

public classTestScheduledThreadPool {

public static void main(String[] args) throws InterruptedException,

ExecutionException {

ScheduledExecutorServicepool= Executors.newScheduledThreadPool(5);

//3个参数,第1个是线程执行体,第2个延时多久,第3个延时单位

for(int i=0;i<3;i++){

Futureresult= pool.schedule(newCallable(){

@Override

public Integer call() throws Exception {

int t = newRandom().nextInt();

System.out.println(Thread.currentThread().getName()+"="+t);

return t;

}

},3, TimeUnit.SECONDS);//延时3秒执行

}

pool.shutdown();

}

运算结果：

3秒后……

pool-1-thread-2=-1843839421

pool-1-thread-3=-1333144512

pool-1-thread-1=1075550443

程序中Future result = pool.schedule(new Callable(){ 括号外加输出语句：

public staticvoidmain(String[] args)throwsInterruptedException, ExecutionException {

ScheduledExecutorServicepool= Executors.newScheduledThreadPool(5);

//3个参数,第1个是线程执行体,第2个延时多久,第3个延时单位

for(int i=0;i<3;i++){

Futureresult= pool.schedule(newCallable(){

@Override

public Integer call() throws Exception {

int t = newRandom().nextInt(); System.out.println(Thread.currentThread().getName()+"="+t);

return t;

}

},3, TimeUnit.SECONDS);//延时3秒执行

System.out.println(Thread.currentThread().getName()+"="+result.get());

}

pool.shutdown();

}

运行结果：

3秒后……

pool-1-thread-1=-506702518

main=-506702518

pool-1-thread-1=173222792

main=173222792

pool-1-thread-2=-1115855720

main=-1115855720

发现pool.schedule体外就是main主线程了。

二、ForkJoinPool分支/合并框架工作窃取

Fork/Join 框架：就是在必要的情况下，将一个大任务，进行拆分(fork)成若干个小任务（拆到不可再拆时），再将一个个的小任务运算的结果进行join 汇总。

采用“工作窃取”模式（work-stealing）：

当执行新的任务时它可以将其拆分分成更小的任务执行，并将小任务加到线程队列中，然后再从一个随机线程的队列中偷一个并把它放在自己的队列中。

相对于一般的线程池实现，fork/join框架的优势体现在对其中包含的任务的处理方式上.在一般的线程池中，如果一个线程正在执行的任务由于某些原因无法继续运行，那么该线程会处于等待状态。而在fork/join框架实现中，如果某个子问题由于等待另外一个子问题的完成而无法继续运行。那么处理该子问题的线程会主动寻找其他尚未运行的子问题来执行.这种方式减少了线程的等待时间，提高了性能。

jdk7和jdk8的使用不一样，现在分别举例：

首先20亿循环计算查看耗时：

1731毫秒。

jdk7反面示例1(拆分临界值太小,导致拆分太多)：

public classTestForkJoinPool {

public static void main(String[] args) {

long starttime= System.currentTimeMillis();

ForkJoinPoolpool= newForkJoinPool();

ForkJoinTasktask= newForkJoinSumCalculate(0l,2000000000l);

long sum = pool.invoke(task);

long endtime= System.currentTimeMillis();

System.out.println(sum);

System.out.println("---20亿循环计算耗时:"+(endtime-starttime));

}

class ForkJoinSumCalculate extends RecursiveTask{

private static final long serialVersionUID= -259195479995561737L;

private long start;

private long end;

private static final long THURSHOLD= 10000L;//任务拆分临界值(1万)

public ForkJoinSumCalculate(long start,long end){

this.start = start;

this.end = end;

}

@Override

protected Long compute() {

long length = end -start;

if(length<THURSHOLD){

long sum = 0L;

for(long i=start;i<=end;i++){

sum+=1;

}

return sum;

}else{

long middle = (start-end)/2;

ForkJoinSumCalculateleft= newForkJoinSumCalculate(start,middle);

left.fork();//进行拆分并压入线程队列

ForkJoinSumCalculateright= newForkJoinSumCalculate(middle,end);

right.fork();//进行拆分并压入线程队列

return left.join() + right.join();

}

运行结果：

Exception in thread "main"java.lang.StackOverflowError

atsun.reflect.GeneratedConstructorAccessor1.newInstance(Unknown Source)

at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)

atjava.lang.reflect.Constructor.newInstance(Constructor.java:423)

atjava.util.concurrent.ForkJoinTask.getThrowableException(ForkJoinTask.java:598)

at java.util.concurrent.ForkJoinTask.reportException(ForkJoinTask.java:677)

栈溢出了。大家知道内存分堆(堆内存)和栈(栈内存)，栈主要存变量及定义。我猜测拆分的变量都放在栈中，临界值小，从而拆的多，所以栈中的变量多，就益处了，那调大临界值试试看，从1万调到100万试试看：

private static final long THURSHOLD = 100000000L;//任务拆分临界值100万，还报栈内存溢出，那就改成1000万：private static final long THURSHOLD = 1000000000L;//任务拆分临界值1000万

不报错了，成功拆分，但貌似性能比不拆分慢很多，所以这种任务拆分不一定能提升性能，要根据机器硬件来适当选择。

使用jdk1.8示例：

public classTestForkJoinPool {

public static void main(String[] args) {

long starttime= System.currentTimeMillis();

Long sum= LongStream.rangeClosed(0L, 2000000000l)

.parallel()

.reduce(0L, Long::sum);

long endtime= System.currentTimeMillis();

System.out.println(sum);

System.out.println("---20亿循环计算耗时:"+(endtime-starttime));

}

运行结果：

2000000001000000000

---20亿循环计算耗时:1620

用了1620毫秒，快了一点。

最后编辑于：2018.08.24 18:37:58

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 206,311评论 6赞 481
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 88,339评论 2赞 382
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 152,671评论 0赞 342
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 55,252评论 1赞 279
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 64,253评论 5赞 371
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 49,031评论 1赞 285
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 38,340评论 3赞 399
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,973评论 0赞 259
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 43,466评论 1赞 300
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,937评论 2赞 323
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 38,039评论 1赞 333
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,701评论 4赞 323
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 39,254评论 3赞 307
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 30,259评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,485评论 1赞 262
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 45,497评论 2赞 354
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,786评论 2赞 345

JUC线程高级教程

JUC

一、JUC

二、ForkJoinPool分支/合并框架 工作窃取

推荐阅读更多精彩内容

二、ForkJoinPool分支/合并框架工作窃取