什么是JUC
-java.util.concurrent
-java.util.concurrent.atomic
-java.util.concurrent.locks
业务：普通的线程代码 Thread
Runable 没有返回值、效率相比Callable较低
2.线程和进程
进程：一个程序
一个进程往往可以包含多个线程，至少包含一个
Java默认有两个线程：mian 和 GC
线程：开了进程Typora，鞋子，自动保存等
对于java而言：Thread、Runnable、Callable
并发和并行
并发编程：
- 并发（多线程同时操作一个资源）
-CPU，模拟出多条线程快速交替 - 并行（多个线程一起走）
并发编程的本质：充分利用CPU的资源
真正的多线程开发，公司中的开发，降低耦合性，线程就是一个单独的资源类，没有任何附属操作 属性、方法
传统锁synchronized:本质：队列、锁
lock锁
ReentranLock：可重入锁（常用）
ReentranReadWriteLock.ReadLock：读锁
ReentranReadWriteLock.WriteLock：写锁
公平锁：new FairSync（）十分公平，可以先来后到
非公平锁：new NonFairSync（）十分不公平，可以插队（默认）
lock锁和Synchronized的区别
1.Synchronized 内置java关键字，lock是一个java类
2.Synchronized 无法判断获取锁的状态，lock是可以判断是否获得锁
3.Synchronized 会自动释放锁，lock必须手动释放
4.Synchronized 线程1（获得锁、阻塞）线程二（等待），lock就不一定会等待下去
5.Synchronized 可重入锁，不可以中断的 ，非公平，lock，可重入锁可以判断锁，可以自己设置。
6.Synchronized 适应少量的代码同步，lock适合大量的代码
锁是什么，如何判断锁的是谁
8锁现象
对象、Class
Condition
创建方式：Condition condition = lock.newCondition();
Condition中的await()对应Object的wait()；
Condition中的signal()对应Object的notify()；
Condition中的signalAll()对应Object的notifyAll()。
可以实现对应锁的等待和开始
集合不安全
list、set
java.util.ConcurrentModficationException 并发修改异常
1.List<String> list = new Vector<>()
2.List<String> list = Collections.synchronizedList(new ArrayList<>())
3.List<String> list = new CopOnWriteArrayList<>()
CopOnWrite 写入时复制 COW 计算机程序设计领域的一种优化策略
写入时避免覆盖，造成数据问题
CopOnWrite 对比 Vector：vector用的是synchronized锁 而CopOnWrite用的是lock锁
Map
1.Map<String,String> map = Collections.synchronizedMap(new HashMap<>())
2.Map<String,String> map = new ConcurrentHashMap<>()
Callable对比Runnable
1.可以有返回值
2.可以抛出异常.
3.方法不同 run\call
new Thread(new FutureTask(Callable)).start()
有缓存、可能有阻塞
常用的辅助类
1.CountDownLatch
private void psvm() {
// TODO 自动生成的方法存根
// 总数是6
CountDownLatch cdl = new CountDownLatch(6);
for (int i = 0; i <= 6; i++) {
new Thread(() -> {
cdl.countDown();// -1
}).start();
}
try {
cdl.await();//等待计数器归零再向下执行
} catch (InterruptedException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
System.err.println("关门");
}
原理：
-countDown();// -1
-await();//等待计数器归零再向下执行
-每次有线程调用countDown()数量-1，当计数器为0，调用await()就会被唤醒继续执行
2.CyclicBarrier
加法计数器
public static void main(String[] args) {
CyclicBarrier cyclicBarrier = new CyclicBarrier(6,()->{
System.out.println("数量达到6的时候调用");
});
for (int i = 1; i < 7; i++) {
int a=i;
new Thread(()->{
try {
System.out.println(a);
cyclicBarrier.await();//+1
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
}).start();
}
}
1.当声明的屏障和线程调用的await次数相等时,先执行我们预声明的线程,
然后再执行调用await方法线程的后续代码.
2.重新调用count方法时,结果和第一次执行一样,说明CyclicBarrier的await方法是可以重复使用的.
3.CyclicBarrier就像团队中的领导,parties声明的屏障就是领导管理的员工数,线程就是员工,线程调用await方法就像是员工开会时报道,等全部员工报完道,
CyclicBarrier开始开会,会议开完后,然后员工再继续接着回去工作.
3.Semaphore
信号量
public static void main(String[] args) {
//线程数量
Semaphore semaphore = new Semaphore(3);
for (int i = 0; i < 6; i++) {
new Thread(()->{
try {
//acquire()得到
semaphore.acquire();
System.out.println(Thread.currentThread().getName()+"抢到车位");
TimeUnit.SECONDS.sleep(2);
System.out.println(Thread.currentThread().getName()+"离开车位");
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
//.release()释放
semaphore.release();
}
},String.valueOf(i)).start();
}
}
作用：多个共享资源互斥的使用，并发限流，控制最大的线程数
