1,什么是JUC
java。util工具包
业务:普通的线程代码 Thread
Runnable 没有返回值,效率相比Callable相对较低
2,线程和进程
进程:一个程序,QQ.exe Music.exe程序的集合:
一个进程往往可以包含多个线程,至少包含一个!
java默认有几个线程:两个,main GC
线程:开了一个进程:功能由线程实现
线程的五种状态:新建,可运行,运行,阻塞,死亡。
并发,并行
并发编程:并发,并行
并发(多线程操作同一个资源)
- CPU一核,模拟出来多条线程,快速交替
并行(多个人同时进行)
- CPU多核,多个线程可以同时执行:
并发编程的本质:充分利用CPU的资源
wait/sleep区别
1,来自不同的类
wait==>Object
sleep==>Thread
2,关于锁 的释放
wait会释放锁,sleep睡觉了,抱着锁睡觉,不会释放
3,使用的范围是不同的
wait:必须在同步代码块中
sleep:可以在任何地方睡
4,是否需要捕获异常
wait:不需要捕获异常
sleep:必须要捕获异常
3,Lock锁(重点)
传统synchronized锁
public class SaleTicketDemo01 {
public static void main(String[] args) {
Ticket ticket = new Ticket();
new Thread(()->{
for (int i = 0; i < 20; i++) {
ticket.dale();
}
},"小红").start();
new Thread(()->{
for (int i = 0; i < 30; i++) {
ticket.dale();
}},"小蓝").start();
}
}
// 属性,方法
class Ticket{
//属性,方法
private int number = 50;
//买票的方式
public synchronized void dale(){
if (number>0){
System.out.println(Thread.currentThread().getName()+"买了第"+(number--)+"张,剩余:"+ number);
}
}
}
Lock锁
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class SaleTicketDemo02 {
public static void main(String[] args) {
Ticket2 ticket2 = new Ticket2();
new Thread(()->{ for (int i = 0; i < 20; i++) ticket2.dale();},"小红").start();
new Thread(()->{ for (int i = 0; i < 30; i++) ticket2.dale();},"小蓝").start();
}
}
class Ticket2{
//属性,方法
private int number = 50;
Lock lock = new ReentrantLock();
//买票的方式
public void dale(){
lock.lock();//加锁
try {
if (number>0){
System.out.println(Thread.currentThread().getName()+"买了第"+(number--)+"张,剩余:"+ number);
}
}catch (Exception e){
e.printStackTrace();
}finally {
lock.unlock();//解锁
}
}
}
synchronized 和Lock区别
1,synchronized 内置的java关键字,Lock是一个java类
2,synchronized 无法判断获取锁的状态,Lock可以判断是否获取到了锁
3,synchronized会自动释放锁,lock必须要手动释放锁!如果不释放锁,死锁!
4,synchronized线程1(获得锁,阻塞)线程2(等待)lock锁不会一直等待下去
5,synchronized 可重入锁,不可以中断的,非公平;lock,可重入锁,可以判断锁,非公平(可以自己设置)
6,synchronized 适当锁少量的代码同步问题,lock适合锁大量的同步代码!
4,生产者消费者问题
传统的消费者生产者问题 synchronized
/*
线程之间的通信问题:生产者和消费者问题
线程交替执行
*/
public class A {
public static void main(String[] args) {
Data data = new Data();
new Thread(()->{
for (int i = 0; i<10; i++){
try {
data.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"a").start();
new Thread(()->{
for (int i = 0; i<10; i++){
try {
data.decrement();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"b").start();
}
}
class Data{
private int number = 0;
public synchronized void increment()throws InterruptedException{
if(number !=0){
//等待
this.wait();
}
number++;
System.out.println(Thread.currentThread().getName()+"==>"+number);
//通知其他线程,我+1完了
this.notifyAll();
}
public synchronized void decrement()throws InterruptedException{
if(number == 0){
//等待
this.wait();
}
number--;
System.out.println(Thread.currentThread().getName()+"==>"+number);
//通知其他线程,我-1完了
this.notifyAll();
}
}
存在虚假唤醒 多个线程A,B,C,D
解决办法; if改成while
class Data{
private int number = 0;
public synchronized void increment()throws InterruptedException{
while(number !=0){
//等待
this.wait();
}
number++;
System.out.println(Thread.currentThread().getName()+"==>"+number);
//通知其他线程,我+1完了
this.notifyAll();
}
public synchronized void decrement()throws InterruptedException{
while(number == 0){
//等待
this.wait();
}
number--;
System.out.println(Thread.currentThread().getName()+"==>"+number);
//通知其他线程,我-1完了
this.notifyAll();
}
JUC版的生产者消费者问题
public class B {
public static void main(String[] args) {
Data2 data2 = new Data2();
new Thread(()->{
for (int i = 0; i<10; i++){
try {
data2.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"a").start();
new Thread(()->{
for (int i = 0; i<10; i++){
try {
data2.decrement();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"b").start();
new Thread(()->{
for (int i = 0; i<10; i++){
try {
data2.decrement();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"c").start();
new Thread(()->{
for (int i = 0; i<10; i++){
try {
data2.increment();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},"d").start();
}
}
class Data2 {
private int number = 0;
Lock lock = new ReentrantLock();
Condition condition = lock.newCondition();
public void increment()throws InterruptedException{
lock.lock();
try {
while (number != 0){
condition.await();
}
number++;
System.out.println(Thread.currentThread().getName() + "==>" + number);
condition.signalAll();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void decrement() throws InterruptedException {
lock.lock();
try {
while (number == 0) {
//等待
condition.await();
}
number--;
System.out.println(Thread.currentThread().getName() + "==>" + number);
//通知其他线程,我-1完了
condition.signalAll();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
Condition精确的通知和唤醒线程
public class C {
public static void main(String[] args) {
Data3 data3 = new Data3();
new Thread(()->{
for (int i = 0; i < 10; i++) {
data3.printA();
}
},"A").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
data3.printB();
}
},"B").start();
new Thread(()->{
for (int i = 0; i < 10; i++) {
data3.printC();
}
},"C").start();
}
}
class Data3{//资源类 Lock
private Lock lock = new ReentrantLock();
private Condition condition1 = lock.newCondition();
private Condition condition2 = lock.newCondition();
private Condition condition3 = lock.newCondition();
private int number = 1;//1=A 2=B 3=C
public void printA() {
lock.lock();
try {
while (number != 1) {
condition1.await();
}
System.out.println(Thread.currentThread().getName() + "=AAAAA");
number = 2;
condition2.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void printB () {
lock.lock();
try {
while (number != 2) {
condition2.await();
}
System.out.println(Thread.currentThread().getName() + "=BBBBB");
number = 3;
condition3.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
public void printC () {
lock.lock();
try {
while (number != 3) {
condition3.await();
}
System.out.println(Thread.currentThread().getName() + "=CCCCC");
number = 1;
condition1.signal();
} catch (Exception e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
5,8锁现象
如何判断锁的是谁!永远的知道什么锁,
package com.yang.lock8;
import java.util.concurrent.TimeUnit;
/**
* 8锁,就是关于锁的8个问题
* 1,在标准情况下,两个线程打印 先发短信还是先打电话、、、、1,发短信 2,打电话
* 2,在sendSms睡眠4秒情况下,两个线程打印 先发短信还是先打电话、、、、1,发短信 2,打电话
*/
public class Test01 {
public static void main(String[] args) {
phone phone = new phone();
new Thread(()->{
phone.sendSms();
},"A").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone.call();
},"B").start();
}
}
class phone{
//synchronized 锁的对象是方法的调用者
//两个方法用到的是同一个锁,谁先拿到谁执行
public synchronized void sendSms(){
try {
TimeUnit.SECONDS.sleep(4);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("发短信");
}
public synchronized void call(){
System.out.println("打电话");
}
}
package com.yang.lock8;
import java.util.concurrent.TimeUnit;
/**
* 3,增加了一个普通方法,先调用哪一个? 1,hello 2, 发短信
* 4,两个对象,两个同步方法,先发短信还是先打电话 1,打电话,2,发短信
*/
public class Test02 {
public static void main(String[] args) {
//两个对象,两个调用者,两把锁
phone2 phone1 = new phone2();
phone2 phone2 = new phone2();
new Thread(()->{
phone1.sendSms();
},"A").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone2.call();
},"B").start();
}
}
class phone2{
//synchronized 锁的对象是方法的调用者
//没有锁,不受锁的影响
public synchronized void sendSms(){
System.out.println("发短信");
}
public synchronized void call(){
System.out.println("打电话");
}
public void hello(){
System.out.println("hello");
}
}
package com.yang.lock8;
import java.util.concurrent.TimeUnit;
/**
*5,增加两个静态的同步方法,只有一个对象,先打印 1,发短信 2,打电话
*6,两个对象,增加两个静态的同步方法,先打印 1,发短信 2,打电话
*/
public class Test03 {
public static void main(String[] args) {
//两个对象的Class类模板只有一个,static,锁的是Class
phone3 phone1 = new phone3();
phone3 phone2 = new phone3();
new Thread(()->{
phone1.sendSms();
},"A").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone2.call();
},"B").start();
}
}
//phone3是唯一一个class对象
class phone3{
//synchronized 锁的对象是方法的调用者
//static 静态方法
//类一加载就有了!锁的是class
public static synchronized void sendSms(){
System.out.println("发短信");
}
public static synchronized void call(){
System.out.println("打电话");
}
}
package com.yang.lock8;
import java.util.concurrent.TimeUnit;
/**
*7,1个静态同步方法,一个普通同步方法 一个对象,先打印?
*8,1个静态同步方法,一个普通同步方法 两个对象,先打印?
*/
public class Test04 {
public static void main(String[] args) {
phone4 phone1 = new phone4();
phone4 phone2 = new phone4();
new Thread(()->{
phone1.call();
},"A").start();
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
new Thread(()->{
phone2.sendSms();
},"B").start();
}
}
class phone4{
//静态的同步方法 锁的是Class类模板
public static synchronized void sendSms(){
System.out.println("发短信");
}
//普通的同步方法 锁的是调用者
public synchronized void call(){
System.out.println("打电话");
}
}
6,集合不安全类
list 不安全
public static void main(String[] args) {
//并发下 ArrayList 是不安全的
//List<String> list = new ArrayList<>();
/**
* 解决方案
* 1,List<String> list = new Vector<>();(synchronized比lock锁效率低)
* 2,List<String> list = Collections.synchronizedList(new ArrayList<>());
* 3,List<String> list = new CopyOnWriteArrayList<>(); JUC
*/
//CopyOnWrite 写入时复制 COM 计算机程序设计领域的一种优化策略;写入的时候,避免覆盖,造成数据问题 (lock锁)
//多个资源调用的时候,list读取的时候,固定的 写入会覆盖
// 读写分离 mycat
List<String> list = new CopyOnWriteArrayList<>();
for (int i = 1; i < 10; i++) {
new Thread(()->{
list.add(UUID.randomUUID().toString().substring(0,5));
System.out.println(list);
}).start();
}
}
set不安全
//java.util.ConcurrentModificationException 并发修改异常
public static void main(String[] args) {
/**
* 解决方案
* 1,Set<String> set = Collections.synchronizedSet(new HashSet<>());
* 2,Set<String> set = Collections.synchronizedSet(new HashSet<>());
*/
Set<String> set = new CopyOnWriteArraySet<>();
for (int i = 1; i < 30; i++) {
new Thread(()->{
set.add(UUID.randomUUID().toString().substring(0,5));
System.out.println(set);
},String.valueOf(i)).start();
}
}
HashSet的底层是什么?HashMap
public HashSet() {
map = new HashMap<>();
}
//add set 本质就是 map key是无法重复的
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
Map 不安全
//java.util.ConcurrentModificationException
public static void main(String[] args) {
// Map<String,String> map = Collections.synchronizedMap(new HashMap<>());
Map<String,String> map = new ConcurrentHashMap<>();
for (int i = 1; i < 10; i++) {
new Thread(()->{
map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
System.out.println(map);
},String.valueOf(i)).start();
}
}
7,Callable
1,可以有返回值
2,可以跑出异常
3,方法不同,run()、call()
代码测试
public class CallableTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//new Thread(new Runnable()).start(); 怎么启动Callable
//new Thread(new FutureTask()).start();
//new Thread(new FutureTask<>(Callable)).start();
MyThread thread = new MyThread();
FutureTask futureTask = new FutureTask(thread);//适配器
new Thread(futureTask,"A").start();
Integer o = (Integer) futureTask.get();//获取Callable的返回结果
System.out.println(o);
}
}
class MyThread implements Callable<Integer>{
@Override
public Integer call(){
System.out.println("call");
return 1024;
}
}
细节:有缓冲,结果可能需要等待,会阻塞
8,常用的辅助类
8.1,CountDownLatch
import java.util.concurrent.CountDownLatch;
public class CountDownLatchDome {
public static void main(String[] args) throws InterruptedException {
CountDownLatch countDownLatch = new CountDownLatch(5);
for (int i = 1; i < 6; i++) {
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"-->go out");
countDownLatch.countDown();//数量-1
},String.valueOf(i)).start();
}
countDownLatch.await();//等待计数器归零,然后才能向下执行
System.out.println("close door");
}
}
countDownLatch.countDown();//数量-1
countDownLatch.await();//等待计数器归零,然后才能向下执行
如果计数器大于或小于执行次数,会永远等待或者提前向下执行
8.2,CyclicBarrier
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class CyclicBarrierDome {
public static void main(String[] args){
CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
System.out.println("全收集了");
});
for (int i = 1; i < 8; i++) {
new Thread(()->{
System.out.println(Thread.currentThread().getName()+" come in");
try {
cyclicBarrier.await();//等待计数器加到7
} catch (InterruptedException e) {
e.printStackTrace();
} catch (BrokenBarrierException e) {
e.printStackTrace();
}
},String.valueOf(i)).start();
}
}
}
8.3,semaphore
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
public class SemaphoreDome {
public static void main(String[] args) {
//线程数量,限流
Semaphore semaphore = new Semaphore(4);
for (int i = 1; i < 8; i++) {
new Thread(()->{
//acquire() 得到 (如果满了,等待释放)
try {
semaphore.acquire();
System.out.println(Thread.currentThread().getName()+" 抢到车位");
TimeUnit.SECONDS.sleep(3);
System.out.println(Thread.currentThread().getName()+" 离开车位");
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
semaphore.release(); //释放
}
},String.valueOf(i)).start();
}
}
}
9,读写锁
ReadWriteLock
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
* ReadWriteLock
* 独占锁:(写锁)(排它锁)
* 共享锁 (读锁)
*/
public class ReadWriteLockDome {
public static void main(String[] args) {
MyCache myCache = new MyCache();
for (int i = 1; i <6; i++) {
int fmp = i;
new Thread(()->{
myCache.put(fmp+"",fmp+"");
},String.valueOf(i)).start();
}
for (int i = 1; i <6; i++) {
int fmp = i;
new Thread(()->{
myCache.get(fmp+"");
},String.valueOf(i)).start();
}
}
}
class MyCache{
private volatile Map<String,Object> map = new HashMap<>();
//读写锁: 更加细粒度的控制
private ReadWriteLock lock = new ReentrantReadWriteLock();
private Lock lock1 = new ReentrantLock();
//存,写入的时候,只希望同时只有一个线程来写
public void put(String key,Object value){
lock.writeLock().lock();
try {
System.out.println(Thread.currentThread().getName()+"写入"+key);
map.put(key,value);
System.out.println(Thread.currentThread().getName()+"成功写入");
} catch (Exception e) {
e.printStackTrace();
}finally {
lock.writeLock().unlock();
}
}
//取,读,的时候,所有人都可以读
public void get(String key){
lock.readLock().lock();
try {
System.out.println(Thread.currentThread().getName()+"读取"+key);
map.get(key);
System.out.println(Thread.currentThread().getName()+"读取成功");
} catch (Exception e) {
e.printStackTrace();
}finally {
lock.readLock().unlock();
}
}
}
10,阻塞队列
阻塞队列
什么情况下我们会使用队列:多线程并发处理,线程池!
学会使用队列
添加,移除
四组API
方式 | 抛出异常 | 有返回值,不抛出异常 | 阻塞,等待 | 超时等待 |
---|---|---|---|---|
添加 | add | offer | put() | offer() |
移除 | remove | poll() | take() | poll() |
检测队首元素 | element | peek |
1,抛出异常
2,不会抛出异常
3,阻塞等待
4,超时等待
例:
public static void test1(){
//队列的大小
ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue(3);
System.out.println(arrayBlockingQueue.add("a"));
System.out.println(arrayBlockingQueue.add("b"));
System.out.println(arrayBlockingQueue.add("c"));
System.out.println("===============");
System.out.println(arrayBlockingQueue.remove());
System.out.println(arrayBlockingQueue.remove());
System.out.println(arrayBlockingQueue.remove());
}
}
true
true
true
===============
a
b
c
SynchronousQueue同步队列
/**
* 同步队列
* 和其他的BlockingQueue不一样,SynchronousQueue不存储元素
* put了一个元素,必须取出来,否则不能添加put
*/
public class SynchronousQueueDemo {
public static void main(String[] args) {
BlockingQueue<String> blockingDeque = new SynchronousQueue<>();
new Thread(()->{
try {
System.out.println(Thread.currentThread().getName()+"put 1");
blockingDeque.put("1");
System.out.println(Thread.currentThread().getName()+"put 2");
blockingDeque.put("2");
System.out.println(Thread.currentThread().getName()+"put 3");
blockingDeque.put("3");
} catch (InterruptedException e) {
e.printStackTrace();
}
},"A").start();
new Thread(()->{
try {
TimeUnit.SECONDS.sleep(2);
System.out.println(Thread.currentThread().getName()+"=>"+blockingDeque.take());
TimeUnit.SECONDS.sleep(2);
System.out.println(Thread.currentThread().getName()+"=>"+blockingDeque.take());
TimeUnit.SECONDS.sleep(2);
System.out.println(Thread.currentThread().getName()+"=>"+blockingDeque.take());
} catch (InterruptedException e) {
e.printStackTrace();
}
},"B").start();
}
}
11,线程池
线程池:三大方法,,七大参数,四种拒绝策略
池化技术
程序的运行,本质:占用系统的资源!优化资源的使用!==》池化技术
线程池,连接池,内存池,对象池///…创建销毁十分浪费资源
池化技术:事先准备好的一些资源,有人要用,直接拿取,用完即返
线程池的好处
-
降低资源上的浪费
-
提高响应的速度
-
方便管理
线程复用,可以控制最大并发数,管理线程
线程池:三大方法
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//Executors 工具类,,三大方法 不建议使用Executors
public class Demo01 {
public static void main(String[] args) {
ExecutorService service = Executors.newSingleThreadExecutor(); // 单个线程
// ExecutorService service = Executors.newFixedThreadPool(5); //创建一个固定的线程池大小
// ExecutorService service = Executors.newCachedThreadPool(); //可伸缩的,
try {
for (int i = 1; i <10 ; i++) {
//使用了线程池之后,使用线程池来创建线程
service.execute(()->{
System.out.println(Thread.currentThread().getName()+" ok");
});
}
} finally {
service.shutdown();
}
}
}
七大参数
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
============================================================================
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}
===========================================================================
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}
===============================================================================
//本质ThreadPoolExecutor
public ThreadPoolExecutor(int corePoolSize, //核心线程池大小
int maximumPoolSize,//最大核心线程池大小
long 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;
}
手动创建一个线程池和四种拒绝策略
/**
* new ThreadPoolExecutor.AbortPolicy()拒绝策略,人满了还有人来,抛出异常
* new ThreadPoolExecutor.CallerRunsPolicy() 哪里来的去哪里处理、、例如main ok
* new ThreadPoolExecutor.DiscardPolicy() 队列满了,丢掉多余,但不会抛出异常
* new ThreadPoolExecutor.DiscardOldestPolicy() 队列满了,尝试去和最早的去竞争,不会抛出异常,不一定成功
*/
public class Demo01 {
public static void main(String[] args) {
//自定义线程池!工作中 使用ThreadPoolExecutor
ThreadPoolExecutor executor = new ThreadPoolExecutor(2, 5, 3,
TimeUnit.SECONDS,
new LinkedBlockingDeque<>(4),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.DiscardOldestPolicy());
try {
//最大承载:max+Deque
for (int i = 1; i <11; i++) {
//使用了线程池之后,使用线程池来创建线程
executor.execute(()->{
System.out.println(Thread.currentThread().getName()+" ok");
});
}
} finally {
executor.shutdown();
}
}
}
总结 ,小结
了解:IO密集型,CPU密集型(调优)
//最大线程池该如何定义
//1,CPU 密集型:几核,可以保证CPU的效率最高
//2,IO 密集型 判断你程序中十分消耗IO的线程 可以设置大于两倍的线程数 防止过度io占用资源
//Runtime.getRuntime().availableProcessors(),
//自定义线程池!工作中 使用ThreadPoolExecutor
ThreadPoolExecutor executor = new ThreadPoolExecutor(
2,
Runtime.getRuntime().availableProcessors(),
3,
TimeUnit.SECONDS,
new LinkedBlockingDeque<>(4),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.DiscardOldestPolicy());
12,四大函数式接口(重点 掌握)
lambda表达式,链式编程,函数式接口,Stream流式计算
所有的函数式接口都可以用lambda表达式
函数式接口:只有一个方法的接口
@FunctionalInterface
public interface Runnable {
public abstract void run();
}
举例 ||
代码测试并用lambda简化
Function函数接口
public class function {
public static void main(String[] args) {
// Function<Integer, Integer> function = new Function<Integer, Integer>() {
// @Override
// public Integer apply(Integer integer) {
// return integer;
// }
// };
Function function = (str)->{return str;};
System.out.println(function.apply("ssd"));
}
}
Predicate断定型接口
/**
* 断定型接口:有一个输入参数,返回值只能是布尔值!
*/
public class predicateDome {
public static void main(String[] args) {
//判断字符串是否为空
// Predicate<String> predicate = new Predicate<String>() {
// @Override
// public boolean test(String o) {
// return o.isEmpty();
// }
// };
Predicate<String> predicate = (str)->{
return str.isEmpty();
};
System.out.println(predicate.test(""));
}
}
Consumer 消费者接口
import java.util.function.Consumer;
/**
* Consumer 消费型接口:只有输入,没有返回值
*/
public class consumer {
public static void main(String[] args) {
// Consumer<String> consumer = new Consumer<String>() {
// @Override
// public void accept(String s) {
// System.out.println(s);
// }
// };
Consumer consumer = (str)->{
System.out.println(str);
};
consumer.accept("sad");
}
}
Supplier供给型接口
import java.util.function.Supplier;
/**
* Supplier 供给型接口 没有参数,只有返回值
*/
public class supplier {
public static void main(String[] args) {
// Supplier<Integer> supplier = new Supplier<Integer>() {
// @Override
// public Integer get() {
// System.out.println("get运行了");
// return 1024;
// }
// };
Supplier supplier = ()->{
return 1024;
};
System.out.println(supplier.get());
}
}
13,Stream流式计算
什么是Stream流式计算
大数据:存储+计算
集合,mysql 本质本质就是存东西的
计算都应该交给流来操作
import java.util.Arrays;
import java.util.List;
/**
* 题目要求,只能用一行代码
* 现在有五个用户!筛选
* 1,ID必须是偶数
* 2,年龄必须大于23岁
* 3,用户名转为大写
* 4,用户名字母倒着排序
* 5,只输出一个用户
*/
public class Test {
public static void main(String[] args) {
User user1 = new User(1,"ada",21);
User user2 = new User(2,"bds",22);
User user3 = new User(3,"lisa",23);
User user4 = new User(4,"tom",24);
User user5 = new User(6,"pet",25);
//集合就是存储
List<User> list = Arrays.asList(user1, user2, user3, user4, user5);
//计算交给stream流
list.stream().filter(user -> {return user.getId()%2==0;})
.filter(user -> {return user.getAge()>23;})
.map(user -> {return user.getName().toUpperCase();})
.sorted((u1,u2)->{return u1.compareTo(u2);})
.limit(1)
.forEach(System.out::println);
}
}
class User{
private int id;
private String name;
private int age;
public User() {
}
public User(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder("User{");
sb.append("id=").append(id);
sb.append(", name='").append(name).append('\'');
sb.append(", age=").append(age);
sb.append('}');
return sb.toString();
}
}
14,,ForkJoin
什么是forkjoin
并行执行任务!提高效率。大数据量
大数据:MapReduce(把大任务拆分为小任务)
ForkJoin特点:工作窃取
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.stream.LongStream;
public class Test {
public static void main(String[] args) throws ExecutionException, InterruptedException {
// test1();// 411
//test2();
test3(); //256
}
public static void test1(){
long sum = 0L;
long start = System.currentTimeMillis();
for (long i = 0L; i <=10_0000_0000; i++) {
sum += i;
}
long end = System.currentTimeMillis();
System.out.println("sum="+sum+"时间; "+(end-start));
}
//ForkJoin
public static void test2() throws ExecutionException, InterruptedException {
long start = System.currentTimeMillis();
ForkJoinPool pool = new ForkJoinPool();
ForkJoinTask<Long> task = new ForkJoinDome(0L,10_0000_0000L);
ForkJoinTask<Long> submit = pool.submit(task);
Long sum = submit.get();
long end = System.currentTimeMillis();
System.out.println("sum="+sum+" 时间; "+(end-start));
}
//用Stream 并行流效率最高
public static void test3(){
long start = System.currentTimeMillis();
//Stream并行流
long sum = LongStream.rangeClosed(0L,10_0000_0000L).parallel().reduce(0,Long::sum);
long end = System.currentTimeMillis();
System.out.println("sum="+sum+"时间; "+(end-start));
}
}
1,5,异步回调
16,JMM
请你谈谈对Volatile 的理解
Volatile是java虚拟机提供的轻量级的同步机制
- 保证可见性
- 不保证原子性
- 禁止指令重排
什么是JMM
JMM:java内存模型,不存在的东西,是一个概念!约定
关于JMM的一些同步的约定:
- 线程解锁前,必须把共享变量立刻刷回内存。
- 线程加锁前,必须读取主存中的最新值到工作内存中
- 加锁和解锁必须是同一把锁
内存交互操作有8种,虚拟机实现必须保证每一个操作都是原子的 ,不可在分的(对于double和long类型的变量来说, load.store、read和write操作在某些平台 上允许例外)
- lock (锁定) :作用于主内存的变量,把-个变量标识为线程独占状态
- unlock ( 解锁) :作用于主内存的变量,它把一个处于锁定状态的变量释放出来 ,释放后的变量才可以被其他线程锁定
- read (读取) :作用于主内存变量,它把-一个变量的值从主内存传输到线程的工作内存中,以便随后的load动作使用
- load (载入) :作用于工作内存的变量,它把read操作从主存中变量放入工作内存中
- use (使用) :作用于工作内存中的变量,它把工作内存中的变量传输给执行引擎,每当虚拟机遇到-个需要使用到变量
的值,就会使用到这个指令 - assign (赋值) :作用于工作内存中的变量,它把一个从执行引擎中接受到的值放入工作内存的变量副本中
- store (存储) :作用于主内存中的变量,它把一个从工作内存中一一个变量的值传送到主内存中,以便后续的write使用
- write (写入) :作用于主内存中的变量,它把store操作从工作内存中得到的变量的值放入主内存的变量中
JMM对这八种指令的使用,制定了如下规则:
。 不允许read和load. storewrite操作之- 单独出现。 即使用了read必须load ,使用了store必须write
。不允许线程丢弃他最近的assign操作,即工作变量的数据改变了之后,必须告知主存
。不允许一个线程将没有assign的数据从工作内存同步回主内存
。一个新的变量必须在主内存中诞生,不允许工作内存直接使用一个未被初始化的变量。就是怼变量实施use. store操作之前,必须经过assign和load操作
。一个变量同一时间只有一一个线程能对其进行lock,多次lock后 ,必须执行相同次数的unlock才能解锁)如果对-个变量进行lock操作。会清空所有工作内存中此变量的值,在执行引擎使用这个变量前,必须重新load或assign操作初始化变量的值
。如果一个变量没有被lock ,就不能对其进行unlock操作。也不能unlock- 个被其他线程锁住的变量
。对一个变量进行unlock操作之前。必须把此变量同步回主内存
17,Volatile
1,保证可见性
import java.util.concurrent.TimeUnit;
public class JMMDemo {
//
private volatile static int sum = 0;
public static void main(String[] args) {
new Thread(()->{ // 线程1 不加volatile 对主内存的变化是不知道的
while (sum == 0){
}
}).start();
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
sum = 1; //main线程
System.out.println(sum);
}
}
2,不保证原子性
原子性:不可分割
线程A在执行任务的时候,不能被打扰的,也不能被分割。
public class VDemo02 {
//volatile 不保证原子性
private volatile static int sum = 0;
public static void add(){
sum++;
}
//理论上是20000
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(Thread.currentThread().getName()+" "+sum);
}
}
使用原子类解决原子性问题
import java.util.concurrent.atomic.AtomicInteger;
public class VDemo02 {
//volatile 不保证原子性
//解决方案: 原子类:Integer
// private volatile static AtomicInteger sum = new AtomicInteger();
private volatile static AtomicInteger sum = new AtomicInteger();
public static void add(){
sum.getAndIncrement(); //AtomicInteger +1方法,CAS
}
//理论上是20000
public static void main(String[] args) {
for (int i = 1; i <= 20; i++) {
new Thread(()->{
for (int j = 0; j < 1000; j++) {
add();
}
}).start();
}
while (Thread.activeCount()>2){
Thread.yield();
}
System.out.println(Thread.currentThread().getName()+" "+sum);
}
}
这些类的底层都是直接和操作系统挂钩的! 在内存中修改值!Unsafe类是一个特殊的存在
指令重排
什么是指令重排:你写的程序,计算机并没有按照你写的顺序进行执行
源代码—》编译器优化的重排—》指令并行也有可能重排–》内存系统也有可能重排–》执行
处理器再进行指令重排的时候,考虑:数据之间的依赖性
volatile可以避免指令重排:
内存屏障。CPU指令。作用:
- 保证特定的操作的执行顺序
- 可以保证某些变量的内存可见性!
总结:volatile只可以保持 可见性 ,不能保证原子性。由于内存屏障,可以避免指令重排的现象产生
18,彻底玩转单例模式
//饿汉式单例
public class Hungry {
//可能会浪费空间
private byte[] data1 = new byte[1024*1024];
private byte[] data2 = new byte[1024*1024];
private byte[] data3 = new byte[1024*1024];
private byte[] data4 = new byte[1024*1024];
private Hungry(){
}
private final static Hungry HUNGRY = new Hungry();
private static Hungry getInstance(){
return HUNGRY;
}
}
//懒汉式单例
public class LazyMan {
private LazyMan(){
System.out.println(Thread.currentThread().getName()+" OK");
}
private volatile static LazyMan lazyMan;
//双重检测锁模式的 懒汉式单例 DCL懒汉式
public static LazyMan getInstance() {
if (lazyMan == null) {
synchronized (LazyMan.class) {
if (lazyMan == null) {
lazyMan = new LazyMan();// 不是一个原子性操作
/**
* 1,分配内存空间
* 2,执行构造方法,初始化对象
* 3,把对象指向这个空间
*/
}
}
} return lazyMan;
}
//
public static void main (String[]args){
for (int i = 0; i < 10; i++) {
new Thread(() -> {
LazyMan.getInstance();
}).start();
}
}
}
19,深入理解CAS
import java.util.concurrent.atomic.AtomicInteger;
public class CASDemo {
//CAS compareAndSet :比较并交换
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(2020,2021));
System.out.println(atomicInteger.get());
}
}
CAS:比较当前工作内存中的值和内存中的值,如果这个值是期望的,那么执行操作,否则一直循环
缺点:
- 循环耗时间
- 一次性只能保证一个共享变量的原子性
- ABA问题
20,原子引用
解决了ABA问题,引入原子引用!对应的思想:乐观锁
带版本号 的原子操作
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicStampedReference;
//AtomicStampedReference<> 如果泛型是一个包装类,注意对象引用问题
public class CASDemo {
static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(1,1);
//CAS compareAndSet :比较并交换
public static void main(String[] args) {
new Thread(()->{
int stamp = atomicStampedReference.getStamp(); //获取版本号
System.out.println("a1 ==>"+stamp);
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(atomicStampedReference.compareAndSet(1, 2,
atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
System.out.println("a2 ==>"+atomicStampedReference.getStamp());
System.out.println(atomicStampedReference.compareAndSet(2, 1,
atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
System.out.println("a3 ==>"+atomicStampedReference.getStamp());
},"a").start();
new Thread(()->{
int stamp = atomicStampedReference.getStamp();
System.out.println("b1 ==>"+stamp);
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
atomicStampedReference.compareAndSet(1,3,stamp,stamp+1);
System.out.println("b2==>"+atomicStampedReference.getStamp());
},"b").start();
}
}
注意:
Integer使用了对象缓存机制,默认范围是-128~127。
21,各种锁的理解
1,公平锁,非公平锁
公平锁非常公平,不能够插队,必须先来后到!
非公平锁:不公平,可以插队(默认的都是非公平)
2,可重入锁(递归锁)
可重入锁意味着:若一个程序或子程序可以“在任意时刻被中断然后操作系统调度执行另外一段代码,这段代码又调用了该子程序不会出错”,则称其为可重入(reentrant或re-entrant)的。
synchronized
public class Demo02 {
public static void main(String[] args) {
phone1 phone = new phone1();
new Thread(()->{phone.sms();},"A").start();
new Thread(()->{phone.sms();},"b").start();
}
}
class phone1{
public synchronized void sms(){
System.out.println(Thread.currentThread().getName()+ "sms");
call();
}
public synchronized void call(){
System.out.println(Thread.currentThread().getName()+ "call");
}
}
lock锁
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Demo01 {
public static void main(String[] args) {
phone phone = new phone();
new Thread(()->{phone.sms();},"A").start();
new Thread(()->{phone.sms();},"b").start();
}
}
class phone{
Lock lock = new ReentrantLock();
public void sms(){
lock.lock(); //lock.lock(); lock.unlock(); 必须配对,否则会产生死锁
try {
System.out.println(Thread.currentThread().getName()+ "sms");
call();
}finally {
lock.unlock();
}
}
public void call(){
lock.lock();
try {
System.out.println(Thread.currentThread().getName()+ "call");
}finally {
lock.unlock();
}
}
}
3,自旋锁
4,死锁
两个线程自己拥有锁,同时想要拿到对方的锁。
},“b”).start();
}
}
注意:
Integer使用了对象缓存机制,默认范围是-128~127。
## 21,各种锁的理解
### 1,公平锁,非公平锁
公平锁非常公平,不能够插队,必须先来后到!
非公平锁:不公平,可以插队(默认的都是非公平)
### 2,可重入锁(递归锁)
可重入锁意味着:若一个程序或子程序可以“在任意时刻被中断然后操作系统调度执行另外一段代码,这段代码又调用了该子程序不会出错”,则称其为可重入(reentrant或re-entrant)的。
> **synchronized**
```java
public class Demo02 {
public static void main(String[] args) {
phone1 phone = new phone1();
new Thread(()->{phone.sms();},"A").start();
new Thread(()->{phone.sms();},"b").start();
}
}
class phone1{
public synchronized void sms(){
System.out.println(Thread.currentThread().getName()+ "sms");
call();
}
public synchronized void call(){
System.out.println(Thread.currentThread().getName()+ "call");
}
}
lock锁
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class Demo01 {
public static void main(String[] args) {
phone phone = new phone();
new Thread(()->{phone.sms();},"A").start();
new Thread(()->{phone.sms();},"b").start();
}
}
class phone{
Lock lock = new ReentrantLock();
public void sms(){
lock.lock(); //lock.lock(); lock.unlock(); 必须配对,否则会产生死锁
try {
System.out.println(Thread.currentThread().getName()+ "sms");
call();
}finally {
lock.unlock();
}
}
public void call(){
lock.lock();
try {
System.out.println(Thread.currentThread().getName()+ "call");
}finally {
lock.unlock();
}
}
}
3,自旋锁
4,死锁
两个线程自己拥有锁,同时想要拿到对方的锁。