1.什么是JUC?
JUC全称 java.util.concurrent 是在并发编程中很常用的实用工具类
2. volatile 关键字内存可见性
2.1 内存可见性问题，先看下面这段代码
package juc;
public class TestVolatile {
public static void main(String[] args) {
ThreadDemo td = new ThreadDemo();
new Thread(td).start();
while (true){
if(td.isFlag()){
System.out.println("-----------------------------");
break;
}
}
}
}
class ThreadDemo implements Runnable{
private boolean flag = false;
@Override
public void run() {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
flag = true;
System.out.println("flag="+flag);
}
public boolean isFlag(){
return flag;
}
}
将上面的代码拿到IDEA去运行，发现控制台只打印输出了flag=true，按照正常的情况，应该将 System.out.println("-----------------------------");，此段代码也执行了才对，为什么这里却没有执行呢？这里涉及到了一个内存可见性问题，原因是此段代码中有两个
线程在执行，一个是主线程Main，一个是子线程，JDK会默认为每一个线程都提供一个缓存，提升效率，这就导致了一个问题，两个线程都拥有一个缓存的flag值，子线程虽然执行了flag = true;但此时修改的flag值只是自己副本的flag值，Main也是读取自己的flag值，
所以导致上述的问题存在。
PS：内存可见性问题是，当多个线程操作共享数据时，彼此不可见。
2.2 如何解决？
2.2.1 synchronized 关键字，同步锁能保证数据的及时更新，能够解决问题，但是这样用会导致线程阻塞，影响效率。
while (true){
synchronized (td) {
if (td.isFlag()) {
System.out.println("-----------------------------");
break;
}
}
}
2.2.2 volatile 关键字：当多个线程操作共享数据时，可以保证内存中的数据可见，相较于synchronized是一种较为轻量级的同步策略。注意：1.volatile 不具备“互斥性”，2.volatile 不能保证变量的“原子性”
private volatile boolean flag = false;
3.原子性
3.1原子性问题，先看下面这段代码
package juc;
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 int serialNumber = 0;
@Override
public void run() {
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getSerialNumber());
}
public int getSerialNumber(){
return serialNumber++;
}
}
将上面的代码运行，我们发现有几率会出现，原子性问题，那么为什么会出现此问题呢，我们得研究一下i++的原理，i++的操作实际上分为三个步骤“读-改-写”
int i = 10;
i = i ++;
int temp = i;
i = i + 1;
i = temp;
通过上面的分析我们可以得出，即使在serialNumber上修饰volatile关键字，也无法将此问题解决，那么我们要如何解决？
3.2 JUC( java.util.concurrent.atomic ) 提供了原子变量
3.2.1 通过观察里面的类，可以发现，里面的类的变量都是用volatile修饰，保证内存可见性，CAS（compare-and-swap）算法保证数据的原子性，CAS算法时硬件对于并发操作共享数据的支持，CAS包含了三个操作数：内存值V预估值A更新值 ，当且仅当
V==A时，V=B，否则，将不做任何操作
// private int serialNumber = 0;
private AtomicInteger serialNumber = new AtomicInteger(0);
将代码修改为原子变量，即可解决上述的原子性问题
4.ConcurrentHashMap锁分段机制
4.1 Java5.0在java.util.concurrent 包中提供了多种并发容器来改进同步容器的性能
4.2 ConcurrentHashMap同步容器是Java5增加的一个线程安全的哈希表，对与多线程的操作，介于HashMap与HashTable之间。内部采用“锁分段”机制代替Hashtable的独占锁。进而提高性能。
4.3 此包还提供了设计用于多线程上下文中的Collection实现：ConcurrentHashMap、ConcurrentSkipListMap、ConcurrentSkipListSet、CopyOnWriteArrayList和CopyOnWriteArraySet。当期望许多线程访问一个给定collection时， ConcurrentHashMap通
常优于同步的HashMap，ConcurrentSkipListMap通常优于同步的TreeMap.当期望的读数和遍历远远大于列表的更新数时，CopyOnWriteArrList优于同步的ArrayList
5.CountDownLatch闭锁操作
5.1 Java5.0在Java.util.concurrent包中提供了多种并发容器类来改进同步容器的性能
5.2 CountDownLatch 一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。
5.3 闭锁可以延迟线程的进度直到其达到终止状态，闭锁可以用来确保某些活动直到其他活动都完成才继续执行：
5.3.1 确保某个计算在其需要的所有资源都被初始化之后才继续执行
5.3.2 确保某个服务在其依赖的所有其他服务都已经启动之后才启动
5.3.3 等待直到某个操作所有参与者都准备就绪在继续执行
5.4 CountDownLatch：闭锁，在完成某些运算时，只有其他所有的线程的运算全部完成，当前运算才算执行。以下代码是用通过闭锁计算10线程执行的时间
5.5 CountDownLatch演示示例代码：
package juc;
import java.util.concurrent.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<5;i++){
new Thread(ld).start();
}
try {
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();
}
}
}
}
6.实现Callable接口
6.1 创建执行线程的方式三：实现Callble接口。相较于实现Runnable接口的方式，方法可以有返回值，并且可以抛出异常
6.2 Callable演示示例代码：
package juc;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class TestCallable {
public static void main(String[] args) {
ThreadDemo td = new ThreadDemo();
// 1.执行Callable方式,需要FutureTask实现类的支持,用于接收运算结果。
FutureTask<Integer> result = new FutureTask<Integer>(td);
new Thread(result).start();
// 2.接收线程运算后的结果
try {
Integer sum = result.get();
System.out.println(sum);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (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++){
System.out.println(i);
sum+=i;
}
return sum;
}
}
7.Lock同步锁
7.1 用于解决多线程安全问题的方式，synchronized：隐式锁，同步代码块、同步方法Jdk1.5后：同步锁Lock，是一种显式锁 ，需要通过lock()方式上锁，必须通过unlock方法进行释放锁；
7.2 同步锁演示示例代码:
package juc;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class TestLock {
public static void main(String[] args) {
Ticket tk = new Ticket();
new Thread(tk,"1 号").start();
new Thread(tk,"2 号").start();
new Thread(tk,"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(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "完成售票，余票：" + --tick);
}
} catch (Exception e) {
e.printStackTrace();
}finally {
lock.unlock();
}
}
}
}
8.如何使用Lock实现等待唤醒机制
8.1 Lock实现等待唤醒机制演示示例代码：
package juc;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
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,"消费者 ").start();
}
}
class Clerk{
private int product = 0;
private Lock lock = new ReentrantLock();
private Condition condition = lock.newCondition();
public void get(){
lock.lock();
try {
while (product >= 1) {
System.out.println("产品已满");
try {
//this.wait();
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + ":" + ++product);
//this.notifyAll();
condition.signalAll();
}finally {
lock.unlock();
}
}
public synchronized void sale(){
lock.lock();
try {
while (product <= 0) {
System.out.println("缺货");
try {
// this.wait();
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + ":" + --product);
//this.notifyAll();
condition.signalAll();
}finally {
lock.unlock();
}
}
}
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++){
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();
}
}
}
9.线程按序交替
9.1 线程按序交替演示示例代码:
package juc;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class TestABCAlternate {
public static void main(String[] args) {
final AlternateDemo ad = new AlternateDemo();
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 1;i<=20;i++){
ad.loopA(i);
}
}
},"A").start();
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 1;i<=20;i++){
ad.loopB(i);
}
}
},"B").start();
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 1;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);
}
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<=15;i++){
System.out.println(Thread.currentThread().getName() + "\t" + i +"\t"+ totalLoop);
}
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<=20;i++){
System.out.println(Thread.currentThread().getName() + "\t" + i +"\t"+ totalLoop);
}
number = 1;
condition1.signal();
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock();
}
}
}
10.ReadWriteLock 读写锁
10.1 ReadWriteLock读写锁演示示例代码：
package juc;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* 1. ReadWriteLock: 读写锁
* 写写/读写 需要“互斥”
* 读读不需要互斥
*/
public class TestReadWriteLock {
public static void main(String[] args) {
final 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();
}
},"Read:").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();
}
}
}
11.线程八锁
11.1线程八锁演示示例代码：
package juc;
/**
* 题目：判断打印的“one” or “two”？
*
* 1.两个普通同步方法,两个线程，标准打印，打印 // one two
* 2.新增Thread.sleep() 给getOne() ,打印 // one two
* 3.新增普通方法getThread(),打印 // one two
* 4.两个普通同步方法，两个Number对象,打印// two one
* 5.修改getOne() 为静态同步方法,打印 // two one
* 6.修改两个方法均为静态同步方法，一个Number对象 one two
* 7.一个静态同步方法，一个非静态同步方法，两个Number对象 two one
* 8.两个静态同步方法，两个Number对象
*
* 线程八锁的关键:
* ① 非静态方法的锁默认为 this,静态方法的锁对应为Class 实例
* ② 某一个时刻内，只能有一个线程持有锁，无论几个方法
*/
public class TestThread8Monitor {
public static void main(String[] args) {
final 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{
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");
}
}
12.线程池
12.1 线程池：提供了一个线程队列，队列中保存着所有等待状态的线程，避免了创建与销毁额外开销，提高了响应的速度
12.2 线程池的体系结构:
Java.util.concurrent.Executor: 负责线程的使用与调度的根接口；
|-- ExecutorService 子接口: 线程池的主要接口；
|-- ThreadPoolExecutor 线程池的实现类；
|-- ScheduledExecutorService 子接口:负责线程的调度；
|-- ScheduledThreadPoolExecutor:继承ThreadPoolExecutor，实现ScheduledExecutorService；
12.3 工具类：Executors
ExecutorService newFixedThreadPool():创建固定大小的线程池；
ExecutorService newCachedThreadPool():缓存线程池,线程池的数量不固定，可以根据需求自动的更改数量；
ExecutorService newSingleThreadExecutor():创建单个线程池，线程池中只有一个线程；
ScheduledExecutorService newScheduledThreadPool():创建固定大小的线程,可以延迟或定时的执行任务；
12.4 线程池演示示例代码：
package juc;
import java.util.concurrent.*;
public class TestThreadPool {
public static void main(String[] args) throws ExecutionException, InterruptedException {
// 1.创建线程池
ExecutorService pool = Executors.newFixedThreadPool(5 );
Future<Integer> future = pool.submit(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
int num = 0;
for (int i = 0; i < 100; i++) {
num +=i;
}
return num;
}
});
System.out.println(future.get());
pool.shutdown();
/*ThreadPoolDemo tpd = new ThreadPoolDemo();
// 2.为线程池中的线程分配任务
for (int i = 0; i < 20; i++) {
pool.submit(tpd);
}
// 3.关闭线程池
pool.shutdown();
*/
}
}
class ThreadPoolDemo implements Runnable{
private int i = 0;
@Override
public void run() {
for (int j = 0; j < 20; j++) {
System.out.println(Thread.currentThread().getName() + ":" +j );
}
}
}
12.5 线程调度演示示例代码：
package juc;
import java.util.Random;
import java.util.concurrent.*;
public class TestScheduledThreadPool {
public static void main(String[] args) throws ExecutionException, InterruptedException {
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();
}
}
13.ForkJoinPool分支/合并框架工作窃取
13.1 分支合并框架演示示例代码:
package juc;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;
public class TestForkJoinPool {
public static void main(String[] args) {
ForkJoinPool pool = new ForkJoinPool();
ForkJoinTask<Long> task = new ForkJoinSumCalculate(0L,100000L);
Long sum = pool.invoke(task);
System.out.println(sum);
}
}
class ForkJoinSumCalculate extends RecursiveTask<Long>{
private long start;
private long end;
private static final long THURSHOLD = 1000L; // 临界值
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();
}
}
}