Java8新特性-JUC

一、Java JUC 简介

在 Java 5.0 提供了 java.util.concurrent （ 简称JUC ） 包，在此包中增加了在并发编程中很常用的实用工具类，

用于定义类似于线程的自定义子系统，包括线程池、异步 IO 和轻量级任务框架。提供可调的、灵活的线程池。还

提供了设计用于多线程上下文中的 Collection 实现等

二、volatile关键字-内存可见性

1、内存可见性

​ ①、内存可见性（Memory Visibility）是指当某个线程正在使用对象状态而另一个线程在同时修改该状态，需

​ 要确保当一个线程修改了对象状态后，其他线程能够看到发生的状态变化。

​ ②、可见性错误是指当读操作与写操作在不同的线程中执行时，我们无法确保执行读操作的线程能适时地看到

​ 其他线程写入的值，有时甚至是根本不可能的事情。

​ ③、我们可以通过同步来保证对象被安全地发布。除此之外我们也可以使用一种更加轻量级的 volatile 变量。

2、volatile 关键字

​ Java 提供了一种稍弱的同步机制，即 volatile 变量，用来确保将变量的更新操作通知到其他线程。可以将

​ volatile 看做一个轻量级的锁，但是又与锁有些不同：

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

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

先看下面代码：

​ 下面代码中，在 main 方法的 while 循环中，如果没有加 synchronized 时，那么 while 中 if 里面的代码是不会

​ 执行的。这是因为由于内存可见性的问题，首先 flag 是存放在主存当中的，其他线程取 flag 的值时，都是先到

​ 主存中取数据，取到数据再执行其他操作后，再刷新到主存当中。所以这个代码中，mian主线程取到 flag 的值

​ 是 false。所以代码只会打印 flag =true，不会打印 ‘-------’ 分割线。

​ 但是如果增加了 synchronized 后，’-------’ 会打印出来，这是因为加了 synchronized 后，每次都会从主存中获

​ 取数据。但是 synchronized 的执行效率比较低，每次都只会让一个线程进入这段代码块。所以我们可以在变量

​ 前面增加 volatile 关键字，这个关键字的作用是每次去变量的值时都会从主存中获取

package com.pengtxyl.juc.Volatile;

/*
	一、volatile关键字：当多个线程进行操作共享数据时，可以保证内存中的数据可见。
						相较于synchronized是一种较为轻量级的同步策略
 	
 	注意：
 		1、volatile不具备"互斥性"
 		2、volatile不能保证质量的"原子性"
 */
public class TestVolatile {
	
	public static void main(String[] args) {
		ThreadDemo td = new ThreadDemo();
		new Thread(td).start();
		while(true) {
//			synchronized (td) {
				if(td.isFlag()) {
					System.out.println("----------");
					break;
				}
//			}
		}
	}
	
}

class ThreadDemo implements Runnable{

	private volatile boolean flag = false;
	
	@Override
	public void run() {
		
		try {
			Thread.sleep(200);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		flag = true;
		System.out.println("flag=" + isFlag());
	}

	public boolean isFlag() {
		return flag;
	}

	public void setFlag(boolean flag) {
		this.flag = flag;
	}
	
}

三、原子变量-CAS算法

1、CAS算法

​ ①、CAS (Compare-And-Swap) 是一种硬件对并发的支持，针对多处理器操作而设计的处理器中的一种特殊指

​ 令，用于管理对共享数据的并发访问。

​ ②、CAS 是一种无锁的非阻塞算法的实现。

​ ③、CAS 包含了 3 个操作数：

​ ● 需要读写的内存值 V

​ ● 进行比较的值 A

​ ● 拟写入的新值 B

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

2、原子变量

​ ①、类的小工具包，支持在单个变量上解除锁的线程安全编程。事实上，此包中的类可将 volatile 值、字段和数

​ 组元素的概念扩展到那些也提供原子条件更新操作的类。

​ ②、类 AtomicBoolean、 AtomicInteger、 AtomicLong 和 AtomicReference 的实例各自提供对相应类型单个

​ 变量的访问和更新。每个类也为该类型提供适当的实用工具方法。

​ ③、AtomicIntegerArray、 AtomicLongArray 和 AtomicReferenceArray 类进一步扩展了原子操作，对这些类

​ 型的数组提供了支持。这些类在为其数组元素提供 volatile 访问语义方面也引人注目，这对于普通数组来说

​ 是不受支持的。

​ ④、核心方法： boolean compareAndSet(expectedValue, updateValue)

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

​ ● AtomicBoolean 、 AtomicInteger 、 AtomicLong 、 AtomicReference

​ ● AtomicIntegerArray 、 AtomicLongArray

​ ● AtomicMarkableReference

​ ● AtomicReferenceArray

​ ● AtomicStampedReference

如下代码：

​ 当有10个线程同时对一个数据进行 i++ 操作时，会发生数据重复的情况，这是因为 i++ 操作会分三步，有可能

​ 一个线程取出 i 后，还未来得及 ++，另一个线程也取出了 i，此时就会存在数据重复。我们可以使用原子操作

​ 的相关类进行声明变量，这样就能保住数据不会重复。注意 volatile 不会保住原子性，只会保证可见性

package com.pengtxyl.juc.Atomic;

import java.util.concurrent.atomic.AtomicInteger;

/*
	一、i++ 的原子性问题：i++的操作实际上分为三个步骤"读-改-写"
			int i = 10
			i = i++; //10
			
			int temp = i;
			i = i + 1;
			i = temp;
	
	二、原子变量：jdk1.5 后 java.util.concurrent.atomic 包下提供了常用的原子变量：
		1、volatile 保证内存可见性
		2、CAS(Compare-And-Swap) 算法保证数据的原子性
			CAS 算法是硬件对于并发操作共享数据的支持
			CAS 包含了三个操作数：
				内存值 V
				预估值 A
				更新值 B
				当且仅当 V==A 时，V = B，否则，将不做任何操作
 */
public class TestAtomicDemo {
	
	public static void main(String[] args) {
		AtomicDemo ad = new AtomicDemo();
		
		for(int i = 0 ; i < 10 ; i++) {
			new Thread(ad).start();
		}
	}
	
}

class AtomicDemo implements Runnable{

	private volatile int serialNumber = 0;
	
	private AtomicInteger serialNumberAtomic = new AtomicInteger();
	
	@Override
	public void run() {
		
		try {
			Thread.sleep(200);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		System.out.println(Thread.currentThread().getName() + ": " + getSerialNumber());
	}
	
	public int getSerialNumber() {
		return serialNumber++;
//		return serialNumberAtomic.getAndIncrement();
	}
	
}

3、模拟CAS算法

package com.pengtxyl.juc.CAS;

//模拟CAS算法
public class TestCompareAndSwap {

	public static void main(String[] args) {
		final CompareAndSwap cas = new CompareAndSwap();
		
		for(int i = 0 ; i < 10 ; i++) {
			new Thread(new Runnable() {
				
				@Override
				public void run() {
					int expectedValue = cas.get();
					boolean b = cas.compareAndSet(expectedValue, (int)(Math.random() * 101));
					System.out.println(b);
				}
			}).start();
		}
	}
	
}

class CompareAndSwap{
	private int value;
	
	//获取内存值
	public synchronized int get() {
		return value;
	}
	
	//比较
	public synchronized int compareAndSwap(int expecteValue, int newValue) {
		int oldValue = value;
		
		if(oldValue == expecteValue) {
			this.value = newValue;
		}
		
		return oldValue;
	}
	
	//设置
	public synchronized boolean compareAndSet(int expectedValue, int newValue) {
		return expectedValue == compareAndSwap(expectedValue, newValue);
	}
}

四、ConcurrentHashMap锁分段机制

1、ConcurrentHashMap

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

​ ②、ConcurrentHashMap 同步容器类是Java 5 增加的一个线程安全的哈希表。对与多线程的操作，介于

​ HashMap 与 Hashtable 之间。内部采用“锁分段”机制替代 Hashtable 的独占锁。进而提高性能。

​ ③、此包还提供了设计用于多线程上下文中的 Collection 实现：

​ ConcurrentHashMap、 ConcurrentSkipListMap、 ConcurrentSkipListSet、CopyOnWriteArrayList 和

​ CopyOnWriteArraySet。当期望许多线程访问一个给定 collection 时， ConcurrentHashMap 通常优于同

​ 步的 HashMap，ConcurrentSkipListMap 通常优于同步的 TreeMap。当期望的读数和遍历远远大于列表

​ 的更新数时， CopyOnWriteArrayList 优于同步的 ArrayList。

看下面的代码：

​ 当运行下面的代码后，会发生并发修改异常： java.util.ConcurrentModificationException，产生的原因如下：

​ 在 list 的 add 方法中，有一条语句：modCount++，而在迭代器中的代码如下：

if (modCount != expectedModCount)
        throw new ConcurrentModificationException();

​ 这时，如果多个线程调用 add 方法，可能存在 modCount == expectedModCount 情况，导致抛出异常。

​ 我们可以使用 CopyOnWriteArrayList 类来代替

​ Collections.synchronizedList(new ArrayList()) 解决并发修改异常，但是注意：

​ CopyOnWriteArrayList 类添加操作多时，效率低，因为每次添加时都会进行复制，开销非常的大

package com.pengtxyl.juc.CopyOnWriteArrayList;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

//CopyOnWriteArrayList/CopyOnWriteArraySet: 写入并复制
public class TestCopyOnWriteArrayList {
	
	public static void main(String[] args) {
		HelloThread ht = new HelloThread();
		
		for(int i = 0 ; i < 10 ; i++) {
			new Thread(ht).start();
		}
	}
	
}

class HelloThread implements Runnable{
	
//	private static List<String> list = Collections.synchronizedList(new ArrayList<String>());
	
	private static CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
	
	static {
		list.add("AA");
		list.add("BB");
		list.add("CC");
	}

	@Override
	public void run() {
		Iterator<String> it = list.iterator();
		
		while(it.hasNext()) {
			System.out.println(it.next());
			list.add("AA");
		}
	}
	
}

五、CountDownLatch闭锁

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

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

​ 等待。

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

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

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

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

package com.pengtxyl.juc.CountDownLatch;

import java.util.concurrent.CountDownLatch;

//CountDownLatch: 闭锁，在完成某些运算时，只有其他所有线程的运算全部完成，当前运算才继续执行
public class TestCountDownLatch {
	
	public static void main(String[] args) {
		final CountDownLatch latch = new CountDownLatch(5);
		LatchDemo ld = new LatchDemo(latch);
		
		long start = System.currentTimeMillis();
		
		for(int i = 0 ; i < 10 ; i++) {
			new Thread(ld).start();
		}
		
		try {
            //计数器未减到0则等待
			latch.await();
		} catch(InterruptedException e) {
			e.printStackTrace();
		}
		
		long end = System.currentTimeMillis();
		
		System.out.println("耗费时间为: " + (end - start));
	}

}

class LatchDemo implements Runnable{
	
	private CountDownLatch latch;
	
	public LatchDemo(CountDownLatch latch) {
		this.latch = latch;
	}

	@Override
	public void run() {
		
		synchronized (this) {
			try {
				for(int i = 0 ; i < 50000 ; i++) {
					if(i % 2 == 0) {
						System.out.println(i);
					}
				}
			} finally {
                //每一个线程过来计数器减一
				latch.countDown();
			}
		}
		
	}
	
}

六、实现Callable接口

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

2、Callable 接口类似于 Runnable，两者都是为那些其实例可能被另一个线程执行的类设计的。但是 Runnable

​ 不会返回结果，并且无法抛出经过检查的异常。

3、Callable 需要依赖FutureTask ， FutureTask 也可以用作闭锁。

package com.pengtxyl.juc.Callable;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/*
	一、创建执行线程的方式三：实现 Callable 接口。相较于实现 Runnable 接口的方式，
		方法可以有返回值，并且可以抛出异常
	二、执行 Callable 方式，需要 FutureTask 实现类的支持，用于接收运算结果。
		FutureTask 是 Future 接口的实现类
 */
public class TestCallable {
	
	public static void main(String[] args) {
		ThreadDemo td = new ThreadDemo();
		
		//1.执行Callable方式，需要FutureTask实现类的支持，用于接收运算结果
		FutureTask<Integer> result = new FutureTask<>(td);
		new Thread(result).start();
		
		System.out.println("------------------------------");
		
		//2.接收线程运算后的结果
		try {
			Integer sum = result.get();
			System.out.println(sum);
			System.out.println("------------------------------");
		} catch (InterruptedException | ExecutionException e) {
			e.printStackTrace();
		} 
	}

}

//创建线程的方式三：
class ThreadDemo implements Callable<Integer>{

	@Override
	public Integer call() throws Exception {
		int sum = 0;
		for(int i = 0 ; i <= 100 ; i++) {
			sum += i;
		}
		return sum;
	}
	
}

//以前我们创建线程使用下面的方式
/*class ThreadDemp implements Runnable{

	@Override
	public void run() {
		// TODO Auto-generated method stub
		
	}
	
}*/

七、Lock同步锁

​ 1、在 Java 5.0 之前，协调共享对象的访问时可以使用的机制只有 synchronized 和 volatile 。 Java 5.0 后增加

​ 了一些新的机制，但并不是一种替代内置锁的方法，而是当内置锁不适用时，作为一种可选择的高级功能

​ 2、ReentrantLock 实现了 Lock 接口，并提供了与synchronized 相同的互斥性和内存可见性。但相较于

​ synchronized 提供了更高的处理锁的灵活性

package com.pengtxyl.juc.Lock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/*
	一、用于解决多线程安全问题的方式：
		synchronized：隐式锁
			1、同步代码块
			2、同步方法
		jdk1.5后：
			3、同步锁 Lock
				注意：这是一个显式锁，需要通过 lock() 方法上锁，必须通过unlock()方法进行释放锁
 */
public class TestLock {

	public static void main(String[] args) {
		Ticket ticket = new Ticket();
		
		new Thread(ticket, "1号窗口").start();
		new Thread(ticket, "2号窗口").start();
		new Thread(ticket, "3号窗口").start();
	}
	
}

class Ticket implements Runnable{
	
	private int tick = 100;
	
	private Lock lock = new ReentrantLock();

	@Override
	public void run() {
		while(true) {
			lock.lock(); //上锁
			try {
				if(tick > 0) {
					try {
						Thread.sleep(100);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName() + " 完成售票,余票为: " + --tick);
				}
			} finally {
				lock.unlock();
			}
			
		}
	}
	
}

八、Condition控制线程通信

​ 1、Condition 接口描述了可能会与锁有关联的条件变量。这些变量在用法上与使用 Object.wait 访问的隐式监

​ 视器类似，但提供了更强大的功能。需要特别指出的是，单个 Lock 可能与多个 Condition 对象关联。为了

​ 避免兼容性问题， Condition 方法的名称与对应的 Object 版本中的不同。

​ 2、在 Condition 对象中，与 wait、 notify 和 notifyAll 方法对应的分别是await、 signal 和 signalAll。

​ 3、Condition 实例实质上被绑定到一个锁上。要为特定 Lock 实例获得Condition 实例，请使用其

​ newCondition() 方法。

生产者消费者案例：

package com.pengtxyl.juc.ProductorAndConsumer;

/*
	生产者和消费者案例
 */
public class TestProductorAndConsumer {
	
	public static void main(String[] args) {
		Clerk clerk = new Clerk();
		
		Productor pro = new Productor(clerk);
		Consumer cus = new Consumer(clerk);
		
		//存在多个生产者和多个消费者
		new Thread(pro, "生产者A").start();
		new Thread(cus, "消费者B").start();
		
		new Thread(pro, "生产者C").start();
		new Thread(cus, "消费者D").start();
	}

}

//店员
class Clerk{
	private int product = 0;
	//进货
	/*
	  这里存在一个问题：
	  	假如生产者生产时存在0.2s的延迟，那么会导致生产者生产产品时速度变慢，而在Clerk类的get方法
	  	中如果product>=1时就产品已满。由于生产过程变慢，假如生产者生产产品时还剩最后2次，而消费者
	  	消费产品还剩最后1次，同时product=0，那么假如此时消费者抢到了锁，执行sale方法，由于
	  	product=0，那么此时消费者会执行 wait 进行等待，并且释放了锁，此时被生产者抢到了锁，
	  	此时由于 product=0，那么会执行else里面的代码，并且product=1，同时执行notifyAll，同时
	  	循环还剩下1次。并且通知其他线程抢锁，此时假如被消费者抢到了锁，那么消费者执行sale方法
	  	的wait方法后，消费者执行完所有循环了，锁也释放了。如果此时被生产者抢到了锁，
	  	由于product=1,那么就会执行if里面的代码	那么此时就会一直执行this.wait()方法
	  	进行等待，导致程序一直等待而不会结束。要想解决这个问题，只需要将 get 和 sale 方法的
	  	else去掉。
	  	但是，即使这样还是会有问题，如果同时存在多个生产者和多个消费者，可能会产生负数的情况。
	  	如果product=0,假如两个消费者同时抢占资源，如果第一个消费者抢到了锁，会执行sale方法，
	  	此时会执行if里面的代码，执行后会释放锁，而释放锁后假如被第二个消费者抢到了锁，也会执行
	  	sale方法，同时也会执行if里面的代码，执行后也会释放锁，此后如果被生产者抢到了锁，会
	  	执行notifyAll方法，此时如果被前面的两个消费者抢到锁后，那么product就会继续执行减减
	  	操作，那么就会变为负数。这种问题叫做虚假唤醒。要想解决这个问题，只需将 if 换为 while
	  	即可，即最后再去判断一次。
	 */
	public synchronized void get() {
		/*if(product >= 1) {*/
		while(product >= 1) {	//解决虚假唤醒
			System.out.println("产品已满!");
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		} /*else {*/
			System.out.println(Thread.currentThread().getName() + ": " + ++product);
			this.notifyAll();
		/*}*/
	}
	
	//卖货
	public synchronized void sale() {
		/*if(product <= 0) {*/
		while(product >= 1) {	//解决虚假唤醒
			System.out.println("缺货!");
			try {
				this.wait();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		} /*else {*/
			System.out.println(Thread.currentThread().getName() + ": " + --product);
			this.notifyAll();
		/*}*/
	}
}

//生产者
class Productor implements Runnable{
	
	private Clerk clerk;
	
	public Productor(Clerk clerk) {
		this.clerk = clerk;
	}

	@Override
	public void run() {
		for(int i = 0 ; i < 20 ; i++) {
			try {
				Thread.sleep(200);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			clerk.get();
		}
	}
	
}

//消费者
class Consumer implements Runnable{
	
	private Clerk clerk;
	
	public Consumer(Clerk clerk) {
		this.clerk = clerk;
	}

	@Override
	public void run() {
		for(int i = 0 ; i < 20 ; i++) {
			clerk.sale();
		}
	}
	
}

九、线程按序交替

​ 编写一个程序，开启 3 个线程，这三个线程的 ID 分别为A、 B、 C，每个线程将自己的 ID 在屏幕上打印 10

​ 遍，要求输出的结果必须按顺序显示。

​ 如： ABCABCABC…… 依次递归

package com.pengtxyl.juc.Condition;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/*
	编写一个程序，开启 3 个线程，这三个线程的 ID 分别为A、 B、 C，每个线程将自己的 ID 
	在屏幕上打印 10 遍，要求输出的结果必须按顺序显示。
​		如： ABCABCABC…… 依次递归
 */
public class TestABCAlternate {

	public static void main(String[] args) {
		AlternateDemo ad = new AlternateDemo();
		
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				for(int i = 0 ; i < 20 ; i++) {
					ad.loopA(i);
				}
			}
		}, "A").start();
		
		new Thread(new Runnable() {
					
			@Override
			public void run() {
				for(int i = 0 ; i < 20 ; i++) {
					ad.loopB(i);
				}
			}
		}, "B").start();
		
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				for(int i = 0 ; i < 20 ; i++) {
					ad.loopC(i);
					System.out.println("---------------------");
				}
			}
		}, "C").start();
	}
	
}

class AlternateDemo{
	private int number = 1;//当前正在执行线程的标记
	
	private Lock lock = new ReentrantLock();
	
	private Condition condition1 = lock.newCondition();
	private Condition condition2 = lock.newCondition();
	private Condition condition3 = lock.newCondition();
	
	public void loopA(int totalLoop) {
		lock.lock();
		try {
			
			//1.判断
			if(number != 1) {
				condition1.await();
			}
			
			//2.打印
			for(int i = 1 ; i <= 5 ; i++) {
				System.out.println(Thread.currentThread().getName() + "\t" + i + "\t" + totalLoop);
			}
			
			//3.唤醒
			number = 2;
			condition2.signal();
			
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	public void loopB(int totalLoop) {
		lock.lock();
		try {
			
			//1.判断
			if(number != 2) {
				condition2.await();
			}
			
			//2.打印
			for(int i = 1 ; i <= 10 ; i++) {
				System.out.println(Thread.currentThread().getName() + "\t" + i + "\t" + totalLoop);
			}
			
			//3.唤醒
			number = 3;
			condition3.signal();
			
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	public void loopC(int totalLoop) {
		lock.lock();
		try {
			
			//1.判断
			if(number != 3) {
				condition3.await();
			}
			
			//2.打印
			for(int i = 1 ; i <= 15 ; i++) {
				System.out.println(Thread.currentThread().getName() + "\t" + i + "\t" + totalLoop);
			}
			
			//3.唤醒
			number = 1;
			condition1.signal();
			
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
}

十、线程八锁

1、一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方

​ 法了，其它的线程都只能等待，换句话说，某一个时刻内，只能有唯一一个线程去访问这些synchronized方法

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

3、加个普通方法后发现和同步锁无关

4、换成两个对象后，不是同一把锁了，情况立刻变化。

5、都换成静态同步方法后，情况又变化

6、所有的非静态同步方法用的都是同一把锁——实例对象本身，也就是说如果一个实例对象的非静态同步方法获

​ 取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法释放锁后才能获取锁，可是别的实例对象的

​ 非静态同步方法因为跟该实例对象的非静态同步方法用的是不同的锁，所以毋须等待该实例对象已获取锁的非

​ 静态同步方法释放锁就可以获取他们自己的锁。

7、所有的静态同步方法用的也是同一把锁——类对象本身，这两把锁是两个不同的对象，所以静态同步方法与非

​ 静态同步方法之间是不会有竞态条件的。但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等

​ 待该方法释放锁后才能获取锁，而不管是同一个实例对象的静态同步方法之间，还是不同的实例对象的静态同

​ 步方法之间，只要它们同一个类的实例对象！

package com.pengtxyl.juc.Thread8Lock;

//题目：判断打印的是 "one" or "two" ?
/*
	1.两个普通同步方法，两个线程，标准打印 //one two
	2.给 getOne() 新增Thread.sleep方法  //one two
	3.新增普通方法(没有synchronized修饰)getThree() //three  one  two
	4.两个普通同步方法，两个Number对象  //two one
	5.修改getOne()为静态同步方法  //two one
	6.修改两个方法均为静态同步方法，一个Number对象 //one two
	7.一个静态同步方法，一个非静态同步方法，两个Number对象  //two one
	8.两个静态同步方法，两个Number   //one two
	
	线程8锁的关键：
		①、非静态方法的锁默认为this，静态方法的锁为对应的 Class 实例
		②、某一个时刻内，只能有一个线程持有锁，无论几个方法
 */
public class TestThread8Monitor {

	public static void main(String[] args) {
		Number number = new Number();
		
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				number.getOne();
			}
		}).start();
		
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				number.getTwo();
			}
		}).start();
		
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				number.getThree();
			}
		}).start();
	}
	
}

class Number{
	//1.
	/*public synchronized void getOne() {
		System.out.println("one");
	}
	
	public synchronized void getTwo() {
		System.out.println("two");
	}*/
	//2、3
	public synchronized void getOne() {
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println("one");
	}
	
	public synchronized void getTwo() {
		System.out.println("two");
	}
	
	public void getThree() {
		System.out.println("three");
	}
}

十一、ReadWriteLock读写锁

​ 1、ReadWriteLock 维护了一对相关的锁，一个用于只读操作，另一个用于写入操作。只要没有 writer，读取锁

​ 可以由多个 reader 线程同时保持。写入锁是独占的。

​ 2、ReadWriteLock 读取操作通常不会改变共享资源，但执行写入操作时，必须独占方式来获取锁。对于读取操

​ 作占多数的数据结构。 ReadWriteLock 能提供比独占锁更高的并发性。而对于只读的数据结构，其中包含的

​ 不变性可以完全不需要考虑加锁操作。

package com.pengtxyl.juc.ReadWriteLock;

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/*
	ReadWriteLock: 读写锁
	写写/读写 需要"互斥"
	读读 不需要互斥
 */
public class TestReadWriteLock {

	public static void main(String[] args) {
		ReadWriteLockDemo rw = new ReadWriteLockDemo();
		
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				rw.set((int)(Math.random() * 101));
			}
		}, "Write:").start();
		
		for(int i = 0 ; i < 100 ; i++) {
			new Thread(new Runnable() {
				
				@Override
				public void run() {
					rw.get();
				}
			}).start();
		}
	}
	
}

class ReadWriteLockDemo{
	private int number = 0;
	
	private ReadWriteLock lock = new ReentrantReadWriteLock();
	
	//读
	public void get() {
		lock.readLock().lock(); //上锁
		try {
			System.out.println(Thread.currentThread().getName() + ": " + number);
		} finally {
			lock.readLock().unlock(); //释放锁
		}
	}
	
	//写
	public void set(int number) {
		lock.writeLock().lock();
		try {
			System.out.println(Thread.currentThread().getName());
			this.number = number;
		} finally {
			lock.writeLock().unlock();
		}
	}
}

十二、线程池

1、第四种获取线程的方法：线程池，一个 ExecutorService，它使用可能的几个池线程之一执行每个提交的任

​ 务，通常使用 Executors 工厂方法配置。

2、线程池可以解决两个不同问题：由于减少了每个任务调用的开销，它们通常可以在执行大量异步任务时提供增

​ 强的性能，并且还可以提供绑定和管理资源（包括执行任务集时使用的线程）的方法。每个

​ ThreadPoolExecutor 还维护着一些基本的统计数据，如完成的任务数。

3、为了便于跨大量上下文使用，此类提供了很多可调整的参数和扩展钩子 (hook)。但是，强烈建议程序员使用较

​ 为方便的 Executors 工厂方法 ：

​ ■ Executors.newCachedThreadPool()（无界线程池，可以进行自动线程回收）

​ ■ Executors.newFixedThreadPool(int)（固定大小线程池）

​ ■ Executors.newSingleThreadExecutor()（单个后台线程）

​ 它们均为大多数使用场景预定义了设置。

package com.pengtxyl.juc.ThreadPool;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/*
	一、线程池：提供了一个线程队列，队列中保存着所有等待状态的线程。避免了创建与销毁的
			额外开销，提高了响应的速度
	二、线程池的体系结构：
		java.util.concurrent.Executor: 负责线程的使用与调度的根接口
			|--**ExecutorService 子接口：线程池主要接口
				|--ThreadPoolExecutor：线程池的实现类
				|--ScheduleExecutorService 子接口：负责线程的调度
					|--ScheduledThreadPoolExecutor：继承ThreadPoolExecutor，
							实现了ScheduleExecutorService
	三、工具类：Executors
		ExecutorService newFixedThreadPool(): 创建固定大小的线程池
		ExecutorService newCachedThreadPool(): 缓存线程池，线程池的数据不固定，可以根据
												需求自动地更改数量
		ExecutorService newSingleThreadExecutor(): 创建单个线程池。线程池中只有一个线程
		
		ExecutorService newScheduledThreadPool(): 创建固定大小的线程，可以延迟或定时执行任务
 */

public class TestThreadPool {

	public static void main(String[] args) throws Exception {
		
		/*new Thread(tpd).start();
		new Thread(tpd).start();*/
		
		//1.创建线程池
		ExecutorService pool = Executors.newFixedThreadPool(5);
		
		/*ThreadPoolDemo tpd = new ThreadPoolDemo();
		
		//2.为线程池
		for(int i = 0 ; i < 10 ; i++) {
			pool.submit(tpd);
		}
		//3.关闭线程池
		pool.shutdown();*/
		
		List<Future<Integer>> list = new ArrayList<>();
		
		for(int i = 0 ; i < 10 ; i++) {
			Future<Integer> future = pool.submit(new Callable<Integer>() {
	
				@Override
				public Integer call() throws Exception {
					int sum = 0;
					for(int i = 0 ; i <= 100 ; i++) {
						sum += i;
					}
					return sum;
				}
			});
			
//			System.out.println(future.get());
			list.add(future);
		}
		
		pool.shutdown();
		
		for(Future<Integer> future : list) {
			System.out.println(future.get());
		}
	}
	
}

class ThreadPoolDemo implements Runnable{
	
	private int i = 0;

	@Override
	public void run() {
		while(i <= 100) {
			System.out.println(Thread.currentThread().getName() + ": " + i++);
		}
	}
	
}

十三、线程调度

​ 一个 ExecutorService，可安排在给定的延迟后运行或定期执行的命令。

package com.pengtxyl.juc.ScheduledThreadPool;

import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class TestScheduledThreadPool {

	public static void main(String[] args) throws Exception {
		ScheduledExecutorService pool = Executors.newScheduledThreadPool(5);
		
		for(int i = 0 ; i < 5 ; i++) {
			Future<Integer> result = pool.schedule(new Callable<Integer>() {

				@Override
				public Integer call() throws Exception {
					int num = new Random().nextInt(100); //生成随机数
					System.out.println(Thread.currentThread().getName() + ": " + num);
					return num;
				}
			}, 3, TimeUnit.SECONDS);
			
			System.out.println(result.get());
		}
		
		pool.shutdown();
	}
	
}

十四、ForkJoinPool分支/合并框架以及工作窃取

​ Fork/Join 框架：就是在必要的情况下，将一个大任务，进行拆分成若干个小任务（拆到不可再拆时），再将一

​ 个个的小任务运算的结果进行汇总。

Fork/Join 框架与线程池的区别

​ ● 采用 “工作窃取”模式（work-stealing）:

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

​ 程的队列中偷一个并把它放在自己的队列中。

​ ● 相对于一般的线程池实现， fork/join框架的优势体现在对其中包含的任务的处理方式上.在一般的线程池中，

​ 如果一个线程正在执行的任务由于某些原因无法继续运行， 那么该线程会处于等待状态。 而在fork/join框架

​ 实现中，如果某个子问题由于等待另外一个子问题的完成而无法继续运行。 那么处理该子问题的线程会主动

​ 寻找其他尚未运行的子问题来执行.这种方式减少了线程的等待时间， 提高了性能

package com.pengtxyl.juc.ForkJoinPool;

import java.time.Duration;
import java.time.Instant;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;

import org.junit.Test;

public class TestForkJoinPool {
	
	public static void main(String[] args) {
		
		Instant start = Instant.now();
		
		ForkJoinPool pool = new ForkJoinPool();
		
		ForkJoinTask<Long> task = new ForkJoinSumCalculate(0L, 100000000L);
		
		Long sum = pool.invoke(task);
		
		System.out.println(sum);
		
		Instant end = Instant.now();
		
		System.out.println("耗费时间为: " + Duration.between(start, end).toMillis()); //54
	}
	
	@Test
	public void test1() {
		
		Instant start = Instant.now();
		
		long sum = 0L;
		
		for(long i = 0 ; i < 100000000L ; i++) {
			sum += i;
		}
		
		System.out.println(sum);
		
		Instant end = Instant.now();
		
		System.out.println("耗费时间为: " + Duration.between(start, end).toMillis()); //34
	}

}

class ForkJoinSumCalculate extends RecursiveTask<Long>{

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	
	private long start;
	private long end;
	
	private static final long THURSHOLD = 10000L; //临界值
	
	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 += i;
			}
			return sum;
		} else {
			long middle = (start + end) / 2;
			ForkJoinSumCalculate left = new ForkJoinSumCalculate(start, middle);
			left.fork(); //进行拆分，同时压入线程队列
			
			ForkJoinSumCalculate right = new ForkJoinSumCalculate(middle + 1, end);
			right.fork();
			
			return left.join() + right.join(); //将结果进行合并
		}
	}
	
}