JUC就是java.util.concurrent下面的类包，专门用于多线程的开发。
//获取cpu的核数
Runtime.getRuntime().availableProcessors()
public enum State(){
NEW, // 新生
RUNNABLE // 运行
BLOCKED // 阻塞
WAITING // 等待
TIME_WAITING // 超时等待
TERMINATED // 中止
}
1、new this 调用的是这个对象，是一个具体的对象！
2、static class 唯一的一个模板！
常见异常：java.util.ConcurrentModificationException：并发修改异常
public class ListTest {
public static void main(String[] args) {
//List list = new ArrayList(); 线程不安全
/**
* 解决方案：
* 1. List list = new Vector();
* 2. List list = Collections.synchronizedList(new ArrayList<>());
* 3. List list = new CopyOnWriteArrayList();
*/
List list = new CopyOnWriteArrayList();
for (int i = 0; i < 20; i++) {
new Thread(() -> {
list.add(UUID.randomUUID().toString().substring(0, 5));
System.out.println(list);
}, String.valueOf(i)).start();
}
}
}
CopyOnWrite写入时复制：在不同的线程访问同一个资源的时候，只有更新操作，才回去复制一份新的数据并进行更换，否则都是访问同一资源。
public class SetTest {
public static void main(String[] args) {
//Set<String> set = new HashSet<>(); 线程不安全
/**
* 解决方法：
* 1. Set<String> set = Collections.synchronizedSet(new HashSet<>());
* 2. Set<String> set = new CopyOnWriteArraySet<>();
*/
Set<String> set = new CopyOnWriteArraySet<>();
for (int i = 0; i < 20; i++) {
new Thread(()->{
set.add(UUID.randomUUID().toString().substring(0,5));
System.out.println(set);
}).start();
}
}
}
public class MapTest {
public static void main(String[] args) {
//Map<String,String> map = new HashMap<String,String>(16, 0.75f); 线程不安全
/**
* 解决方法：
* 1. Map map = Collections.synchronizedMap(new HashMap<String,String>());
* 2. Map<String,String> map = new ConcurrentHashMap<String,String>();
*/
Map<String,String> map = new ConcurrentHashMap<String,String>();
for (int i = 0; i < 20; i++) {
new Thread(()->{
map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
System.out.println(map);
},String.valueOf(i)).start();
}
}
}
public class CallableTest {
public static void main(String[] args) {
MyThread thread = new MyThread();
FutureTask task = new FutureTask(thread);// 适配类
new Thread(task, "a").start();
new Thread(task, "b").start(); // 结果会被缓存，效率高
try {
Integer o = (Integer) task.get(); //这个get 方法可能会产生阻塞！把他放到 后
System.out.println(o);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
class MyThread implements Callable<Integer> {
@Override
public Integer call() throws Exception {
System.out.println("call()");
return 1024;
}
}
ReadWriteLock维护一对关联的locks ，一个用于只读操作，一个用于写入。 read lock可以由多个阅读器线程同时进行，只要没有作者。 write lock是独家的。
Queue另外支持在检索元素时等待队列变为非空的操作，并且在存储元素时等待队列中的空间变得可用。
| 方式 | 抛出异常 | 有返回值不抛出异常 | 阻塞等待 | 超时等待 |
|---|---|---|---|---|
| 添加 | add(e) | offer(e) | put(e) | offer(e,time,unit) |
| 删除 | remove | poll | take | poll(time,unit) |
| 队首元素 | element | peek | - | - |
其中每个插入操作必须等待另一个线程相应的删除操作，反之亦然。 同步队列没有任何内部容量，甚至没有一个容量。
ExecutorService threadPool = Executors.newSingleThreadExecutor(); //单一线程
ExecutorService threadPool = Executors.newFixedThreadPool(5); //创建一个固定的线程池大小
ExecutorService threadPool = Executors.newCachedThreadPool(); //可伸缩的
public ThreadPoolExecutor(int corePoolSize, //核心线程池大小
int maximumPoolSize, //最大核心线程池大小
long keepAliveTime, //非核心线程的超时时长，当系统中非核心线程闲置时间超过keepAliveTime之后，则会被回收
TimeUnit unit,//第三个参数的单位，
BlockingQueue<Runnable> 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.acc = System.getSecurityManager() == null ?
null :
AccessController.getContext();
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.workQueue = workQueue;
this.keepAliveTime = unit.toNanos(keepAliveTime);
this.threadFactory = threadFactory;
this.handler = handler;
}
public class ExecutorDemo2 {
public static void main(String[] args) {
ExecutorService threadPool = new ThreadPoolExecutor(
2,
5,
2,
TimeUnit.SECONDS,
new ArrayBlockingQueue<>(3),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy()
);
try {
for (int i = 0; i < 10; i++) {
threadPool.execute(()->{
System.out.println(Thread.currentThread().getName()+" ok");
});
}
} catch (Exception e) {
e.printStackTrace();
} finally {
threadPool.shutdown();
}
}
}
public class Function1 {
public static void main(String[] args) {
// 1. Function 函数型接口, 有一个输入参数，有一个输出
Function<String, String> function = (str) -> {
return str;
};
System.out.println(function.apply("aaaa"));
// 2. 断定型接口：有一个输入参数，返回值只能是 布尔值！
Predicate<String> predicate = (str)->{
return str.isEmpty();
};
System.out.println(predicate.test("aaaa"));
//3. Consumer 消费型接口: 只有输入，没有返回值
Consumer<String> consumer = (str)->{
System.out.println("正在消费 "+str);
};
consumer.accept("快餐");
//4. 供给型接口:没有参数只有返回值
Supplier<String> supplier = ()->{
return "供给成功";
};
System.out.println(supplier.get());
}
}
public class StreamTest {
/**
* 题目要求：一分钟内完成此题，只能用一行代码实现！
* * 现在有5个用户！筛选：
* * 1、ID 必须是偶数
* * 2、年龄必须大于23岁
* * 3、用户名转为大写字母
* * 4、用户名字母倒着排序
* * 5、只输出一个用户！
*/
public static void main(String[] args) {
User u1 = new User(1, "a", 21);
User u2 = new User(2, "b", 22);
User u3 = new User(3, "c", 23);
User u4 = new User(4, "d", 24);
User u5 = new User(6, "e", 25);
List<User> list = Arrays.asList(u1, u2, u3, u4, u5);
list.stream()
.filter(u -> {
return u.getId() % 2 == 0;
})
.filter(u -> {
return u.getAge() > 23;
})
.map(u -> {
return u.getName().toUpperCase();
})
.sorted((uu1, uu2) -> {
return uu2.compareTo(uu1);
})
.limit(1)
.forEach(System.out::println);
}
}
import java.util.concurrent.RecursiveTask;
public class ForkJoinDemo extends RecursiveTask<Long> {
private Long start;
private Long end;
private Long temp = 10000L;
public ForkJoinDemo(Long start, Long end) {
this.start = start;
this.end = end;
}
@Override
protected Long compute() {
if ((end - start) < temp) {
Long sum = 0L;
for (Long i = start; i <= end; i++) {
sum += i;
}
return sum;
} else {
Long mid = (end + start) / 2;
ForkJoinDemo task1 = new ForkJoinDemo(start, mid);
task1.fork();
ForkJoinDemo task2 = new ForkJoinDemo(mid + 1, end);
task2.fork();
return task1.join() + task2.join();
}
}
}
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.stream.LongStream;
public class ForkJoin1 {
public static void main(String[] args) {
sum1();
sum2();
sum3();
sum4(0L, 1000_000_000L);
sum5plus(1000_000_000L);
}
//for循环
public static void sum1() {
Long sum = 0L;
long start = System.currentTimeMillis();
for (int i = 0; i <= 1000_000_000L; i++) {
sum += i;
}
long end = System.currentTimeMillis();
System.out.println("sum = " + sum + " 时间 " + (end - start));
}
//ForkJoin
public static void sum2() {
long start = System.currentTimeMillis();
ForkJoinDemo forkJoinDemo = new ForkJoinDemo(0L, 1000_000_000L);
ForkJoinPool forkJoinPool = new ForkJoinPool();
ForkJoinTask<Long> submit = forkJoinPool.submit(forkJoinDemo); // 提交任务
Long sum = 0L;
try {
sum = submit.get();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
long end = System.currentTimeMillis();
System.out.println("sum = " + sum + " 时间 " + (end - start));
}
// Stream并行流 () (]
public static void sum3() {
long start = System.currentTimeMillis();
long sum = LongStream.rangeClosed(0L, 1000_000_000L).parallel().reduce(0, Long::sum);
long end = System.currentTimeMillis();
System.out.println("sum = " + sum + " 时间 " + (end - start));
}
//递归方法一
public static void sum4(Long start, Long end) {
long startTime = System.currentTimeMillis();
Long temp = 250_000_000L;
Long sum = 0L;
if (end - start >= temp) {
for (Long i = start; i <= end; i++) {
sum += i;
}
} else {
Long mid = (start + end) / 2;
sum4(start, mid);
sum4(mid + 1, end);
}
long endTime = System.currentTimeMillis();
System.out.println("sum = " + sum + " 时间 " + (endTime - startTime));
}
//递归方法二 数值太大会产生 java.lang.StackOverflowError
public static void sum5plus(Long n) {
long startTime = System.currentTimeMillis();
Long sum = sum5(n);
long endTime = System.currentTimeMillis();
System.out.println("sum = " + sum + " 时间 " + (endTime - startTime));
}
public static Long sum5(Long n) {
if (n == 1L) {
return 1L;
} else return n + sum5(n - 1);
}
}
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
public class CompletableFuture1 {
public static void main(String[] args) {
// 没有返回值的 runAsync 异步回调
/*CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(()->{
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"=====> runAsync");
});
System.out.println("异步处理");
try {
completableFuture.get();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}*/
// 有返回值的 supplyAsync 异步回调
CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(()->{
System.out.println(Thread.currentThread().getName()+"=====> supplyAsync");
int i = 1/0;
return 1024;
});
completableFuture.whenComplete((t,u)->{
System.out.println(t);// 正常的返回结果
System.out.println(u); // 错误信息：
}).exceptionally(e->{
System.out.println(e.getMessage());
return 2333; // 可以获取到错误的返回结果
});
try {
System.out.println(completableFuture.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
import java.util.concurrent.TimeUnit;
/**
* @author bro
* @date 2020/10/3 11:29
* @desc
*/
public class Volatile1 {
private volatile static int num = 0;
public static void main(String[] args) {
new Thread(() -> {
while (num == 0) {
}
}).start();
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
num = 1;
System.out.println(num);
}
}
public class Volatile2 {
private volatile static int num = 0;
public static void add() {
/**
* 不是原子性操作
* javap -c xxx.class
*
* public static void add();
* Code:
* 0: getstatic #2 // Field num:I
* 3: iconst_1
* 4: iadd
* 5: putstatic #2 // Field num:I
*/
num++;
}
public static void main(String[] args) {
for (int i = 0; i < 20; i++) {
new Thread(() -> {
for (int j = 0; j < 1000; j++) {
add();
}
}).start();
}
while (Thread.activeCount() > 2) Thread.yield();
System.out.println(num);
}
}
可以使用java.util.concurrent.atomic包下的原子类，解决原子性问题。
package com.peng;
import java.util.concurrent.atomic.AtomicInteger;
public class Volatile3 {
private static AtomicInteger num = new AtomicInteger();
public static void add() {
num.getAndIncrement();
}
public static void main(String[] args) {
for (int i = 0; i < 20; i++) {
new Thread(() -> {
for (int j = 0; j < 1000; j++) {
add();
}
}).start();
}
while (Thread.activeCount() > 2) Thread.yield();
System.out.println(num);
}
}
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
注意
优点：
1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
2、避免对资源的多重占用（比如写文件操作）。
缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。
public class LazyMan {
private LazyMan(){
}
public static LazyMan lazyMan;
public static LazyMan getInstance(){
if (lazyMan == null){
lazyMan = new LazyMan();
}
return lazyMan;
}
}
//饿汉式
public class Hungry {
private Hungry(){
}
private final static Hungry HUNGRY = new Hungry();
public static Hungry getInstance(){
return HUNGRY;
}
}
//双检锁/双重校验锁
public class Singleton {
private Singleton(){
}
public volatile static Singleton singleton;
// 双重检测锁模式的 懒汉式单例 DCL懒汉式
public static Singleton getInstance(){
if (singleton == null){
synchronized (Singleton.class){
if (singleton == null){
singleton = new Singleton();
}
}
}
return singleton;
}
}
public enum Singleton {
INSTANCE;
public void whateverMethod() {
}
}
CAS是英文单词CompareAndSwap的缩写，中文意思是：比较并替换。CAS需要有3个操作数：内存地址V，旧的预期值A，即将要更新的目标值B。
CAS指令执行时，当且仅当内存地址V的值与预期值A相等时，将内存地址V的值修改为B，否则就什么都不做。整个比较并替换的操作是一个原子操作。
import java.util.concurrent.atomic.AtomicInteger;
public class CASDemo {
public static void main(String[] args) {
AtomicInteger atomicInteger = new AtomicInteger(2020);
// 期望、更新
// public final boolean compareAndSet(int expect, int update)
// 如果我期望的值达到了，那么就更新，否则，就不更新, CAS 是CPU的并发原语！
// ============== 捣乱的线程 ==================
System.out.println(atomicInteger.compareAndSet(2020, 2021));
System.out.println(atomicInteger.get());
System.out.println(atomicInteger.compareAndSet(2021, 2020));
System.out.println(atomicInteger.get());
atomicInteger.getAndIncrement();
// ============== 期望的线程 ==================
System.out.println(atomicInteger.compareAndSet(2020, 6666));
System.out.println(atomicInteger.get());
}
}
CAS的缺点：
CAS虽然很高效的解决了原子操作问题，但是CAS仍然存在三大问题。
解决ABA 问题，引入原子引用！ 对应的思想：乐观锁！
import java.sql.Time;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicStampedReference;
public class CASDemo2 {
static AtomicStampedReference atomicStampedReference = new AtomicStampedReference(1, 1);
public static void main(String[] args) {
new Thread(() -> {
int stamp = atomicStampedReference.getStamp();
System.out.println("a1 ==> " + stamp);
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
atomicStampedReference.compareAndSet(1, 2, stamp, stamp + 1);
System.out.println("a2 ==> " + atomicStampedReference.getStamp());
atomicStampedReference.compareAndSet(2, 1, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1);
System.out.println("a3 ==> " + atomicStampedReference.getStamp());
}).start();
}
}
公平锁：多个线程按照申请锁的顺序去获得锁，线程会直接进入队列去排队，永远都是队列的第一位才能得到锁。
非公平锁：多个线程去获取锁的时候，会直接去尝试获取，获取不到，再去进入等待队列，如果能获取到，就直接获取到锁。
可重入锁又名递归锁，是指在同一个线程在外层方法获取锁的时候，再进入该线程的内层方法会自动获取锁（前提锁对象得是同一个对象或者class），不会因为之前已经获取过还没释放而阻塞。Java中ReentrantLock和synchronized都是可重入锁，可重入锁的一个优点是可一定程度避免死锁。
import java.util.concurrent.atomic.AtomicReference;
public class SpinLockDemo {
AtomicReference atomicReference = new AtomicReference();
public void lock() {
Thread thread = Thread.currentThread();
System.out.println(Thread.currentThread().getName() + "===> lock");
while (!atomicReference.compareAndSet(null, thread)) {
}
}
public void unlock() {
Thread thread = Thread.currentThread();
System.out.println(Thread.currentThread().getName()+"=====> unlock");
atomicReference.compareAndSet(thread,null);
}
}
import java.util.concurrent.TimeUnit;
public class SpinLockTest {
public static void main(String[] args) {
SpinLockDemo spinLock = new SpinLockDemo();
new Thread(()->{
spinLock.lock();
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
spinLock.unlock();
}
},"T1").start();
new Thread(()->{
spinLock.lock();
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
spinLock.unlock();
}
},"T2").start();
}
}
所谓死锁，是指多个进程在运行过程中因争夺资源而造成的一种僵局，当进程处于这种僵持状态时，若无外力作用，它们都将无法再向前推进。
死锁产生的4个必要条件？
排除死锁：