JUC学习

JUC

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-88jKDj5L-1630342824510)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210729001824675.png)]

JAVA.util工具包

业务:普通线程代码Thread

Runnable 没有返回值,效率相比Callable相对较低

对于java而言开启线程

Thread,Runable,Callable

线程和进程

java默认有几个线程?

2个:main,GC

java真的能开启进程吗?

    public synchronized void start() {
 
        if (threadStatus != 0)
            throw new IllegalThreadStateException();


        group.add(this);

        boolean started = false;
        try {
            start0();
            started = true;
        } finally {
            try {
                if (!started) {
                    group.threadStartFailed(this);
                }
            } catch (Throwable ignore) {

            }
        }
    }
	//本地方法,底层的C++,java无法直接操作硬件
    private native void start0();

并发和并行

并发编程：并发,并行

• 并发:多线程,多个线程操作同一个资源
  • CPU 一核,模拟出来多条线程,天下武功,唯快不破.快速交替.
• 并行:多个人一起行走
  • CPU多核,多个线程同时执行.

        //获取cpu的核数
		//CPU密集型,IO密集型
        System.out.println(Runtime.getRuntime().availableProcessors());

并发编程的本质:充分利用CPU的资源

线程状态

    public enum State {
		//新生
        NEW,
		//运行
        RUNNABLE,
		//阻塞
        BLOCKED,
		//等待,死等
        WAITING,
		//超时等待
        TIMED_WAITING,
		//终止
        TERMINATED;
    }

wait,sleep

1. 来自不同的类

   wait --> Object

   sleep --> Thread

2. 关于锁的释放

   wait需要释放锁,

   sleep睡觉了,抱着锁睡,不会释放锁

3. 使用范围是不同的

   wait :必须用在同步代码块中

   sleep: 可以在任何地方睡觉

4. 是否需要捕获异常*

Lock锁(重点)

传统 Synchronized

使用多线程,应该使用这种形式

package com.example.demo.saleTicket;
/**
 * 真实的多线程开发
 * 线程就是一个单独的资源类,没有任何附属的操作
 * 1.属性,方法
 */
public class SaleTicketDemo01 {

    public static void main(String[] args) {
        //并发:多线程操作一个资源类,把资源类丢入线程
        //多线程操作
        Ticket ticket = new Ticket();
        //@FunctionalInterface函数式接口
//        lambda表达式  ()->{}
        new Thread(() -> {
            for (int i = 0; i < 120; i++) {
                ticket.sale();
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 0; i < 120; i++) {
                ticket.sale();
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 0; i < 120; i++) {
                ticket.sale();
            }
        }, "C").start();

//        匿名内部类
//        new Thread(new Runnable() {
//            @Override
//            public void run() {
//
//            }
//        }).start();
    }
}
//资源类OOP
class Ticket {
    //    属性
    private int number = 100;

    //    方法
    public synchronized void sale() {
        if (number > 0) {
            System.out.println(Thread.currentThread().getName() + "卖出了" + (number--) + "张票,还剩下" + number + "张");
        }
    }

}

Lock接口

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-djD660nJ-1630342824513)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210805003101453.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MsSfDPNt-1630342824515)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210805003433343.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8oZKLfSo-1630342824519)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210805004629309.png)]

• 公平锁-> 十分公平:必须先来后到 --> 3h > 3s (一个线程只需要实行3s,缺要等待3小时)
• 非公平锁 -> 十分不公平:可以插队 --> 3s > 3h (直接插队)

package com.example.demo.saleTicket;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 * 真实的多线程开发
 * 线程就是一个单独的资源类,没有任何附属的操作
 * 1.属性,方法
 */
public class SaleTicketDemo02 {
    public static void main(String[] args) {
        Ticket2 ticket = new Ticket2();
        new Thread(() -> {
            for (int i = 0; i < 120; i++) {
                ticket.sale();
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 0; i < 120; i++) {
                ticket.sale();
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 0; i < 120; i++) {
                ticket.sale();
            }
        }, "C").start();
    }
}
//Lock 3步曲
//1. Lock lock = new ReentrantLock(); //创建锁
//2. lock.lock(); //加锁
//3. finally-> lock.unlock(); //解锁
class Ticket2 {
    private int number = 100;
    Lock lock = new ReentrantLock(); //创建锁
    public void sale() {
        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 锁就不一定会一直等下去;(可以通过trylock尝试获取锁)
5. Synchronized 可重入锁,不可以中断,非公平的;Lock 可重入锁,可以判断 (可不可中断),非公平的(可以直接设置)
6. Synchronized 适合锁少量的代码块同步问题,Lock 适合锁大量的同步代码块

锁是什么,如何判断锁是谁的

生产者和消费者问题

面试重点:单例模式,排序算法,生产者消费者,死锁

Synchronezed 的 生产者和消费者问题

package com.example.demo.produceAndCumtomer;
/**
 * 线程之间的通信问题:生产者和消费者问题!
 * 等待唤醒,唤醒通知
 * 线程之间交替执行 A B 操作同一个变量 num = 0
 * num 为0加1 ,num为1减1
 * A num +1
 * B num -1
 */
public class Demo01 {
    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();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
    }
}
//等待判断->业务->通知
//资源类
class Data {
    private int num = 0;
    public synchronized void increment() throws InterruptedException {
        if (num != 0){
            //等待判断
            this.wait();
        }
        //业务
        num ++;
        System.out.println(Thread.currentThread().getName() +"==>"+ num);
        //通知
        this.notifyAll();
    }
    public synchronized void decrement() throws InterruptedException {
        if (num == 0){
            //等待判断
            this.wait();
        }
        //业务
        num --;
        System.out.println(Thread.currentThread().getName() +"==>"+ num);
        //通知
        this.notifyAll();
    }
}

线程之间交替执行

A==>1
B==>0
A==>1
B==>0
A==>1
B==>0
A==>1
B==>0
A==>1
B==>0
A==>1
B==>0
A==>1
B==>0
A==>1
B==>0
A==>1
B==>0
A==>1
B==>0

注意 增加几个线程就会发生问题A++ B-- C++ D–

!!!

**关键在于:在A在if中进入wait等待了, 下次其他线程唤醒了他,然后再次执行A线程时直接进行if后面的方法 .所有不应该使用if,而是使用while() 让他一直进行判断 **

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-12IAekHs-1630342824523)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210805234116091.png)]

package com.example.demo.produceAndCumtomer;


/**
 * 线程之间的通信问题:生产者和消费者问题!
 * 等待唤醒,唤醒通知
 * 线程之间交替执行 A B 操作同一个变量 num = 0
 * num 为0加1 ,num为1减1
 * A num +1
 * B num -1
 */
public class Demo01 {
    public static void main(String[] args) {
        Data data = new Data();
        new Thread(()->{
            for (int i = 0; i < 20; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 20; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 20; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
        new Thread(()->{
            for (int i = 0; i < 20; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }
}
//等待判断->业务->通知
//资源类
class Data {
    private int num = 0;
    public synchronized void increment() throws InterruptedException {
        while (num != 0){
            //等待判断
            this.wait();
        }
        //业务
        num ++;
        System.out.println(Thread.currentThread().getName() +"==>"+ num);
        //通知
        this.notifyAll();
    }
    public synchronized void decrement() throws InterruptedException {
        while (num == 0){
            //等待判断
            this.wait();
        }
        //业务
        num --;
        System.out.println(Thread.currentThread().getName() +"==>"+ num);
        //通知
        this.notifyAll();
    }
}

J

通过lock找到condition

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YivJnpGD-1630342824525)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210806003917735.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jD2culHh-1630342824527)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210806004027943.png)]

package com.example.demo.produceAndCumtomer;


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

/**
 * 线程之间的通信问题:生产者和消费者问题!
 * 等待唤醒,唤醒通知
 * 线程之间交替执行 A B 操作同一个变量 num = 0
 * num 为0加1 ,num为1减1
 * A num +1
 * B num -1
 */
public class Demo02 {
    public static void main(String[] args) {
        Data2 data = new Data2();
        new Thread(() -> {
            for (int i = 0; i < 20; i++) {
                data.increment();
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 0; i < 20; i++) {
                data.decrement();

            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 0; i < 20; i++) {
                data.increment();

            }
        }, "C").start();
        new Thread(() -> {
            for (int i = 0; i < 20; i++) {
                data.decrement();

            }
        }, "D").start();
    }
}
//等待判断->业务->通知
//资源类
class Data2 {
    private int num = 0;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
//            condition.await(); 等待
//        condition.signalAll(); 唤醒
    public void increment() {
        lock.lock();
        try {
            while (num != 0) {
                condition.await();
            }
            num++;
            System.out.println(Thread.currentThread().getName() + "==>" + num);
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void decrement() {
        lock.lock();
        try {
            while (num == 0) {
                condition.await();
            }
            num--;
            System.out.println(Thread.currentThread().getName() + "==>" + num);
            condition.signalAll();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

condition实现精确唤醒

package com.example.demo.produceAndCumtomer;


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

/**
 * 实现condition的精确唤醒
 * A B C 3个线程一次执行 ->a 执行完执行 b,b 执行完 执行c ,c执行完执行a
 */
public class Demo03 {
    public static void main(String[] args) {

        Data3 data = new Data3();

        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.priventA();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.priventB();

            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.priventC();
            }
        },"C").start();
    }
}
//资源类
class Data3 {

    Lock lock = new ReentrantLock();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();
    int num = 1;
    public void priventA(){
        lock.lock();
        try {
            //业务,判断-->执行-->通知
            while (num != 1){
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"===> AAAAAAAAAAA");
            //唤醒制定的线程
            num = 2;
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void priventB(){
        lock.lock();
        try {
            //业务,判断-->执行-->通知
            while (num != 2){
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+"===> BBBBBBBBBBB");
            //唤醒制定的线程
            num = 3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void priventC(){
        lock.lock();
        try {
            //业务,判断-->执行-->通知
            while (num != 3){
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+"===> CCCCCCCCCCCC");
            //唤醒制定的线程
            num = 1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

8锁现象(问题)

8锁问题就是关于锁的8个问题

标准情况下,两个线程先打印 发短信还是打电话 ?

先发短信,再打电话=>因为发短信先获取到锁,只要没有释放,就不会执行打电话,

synchronized 使用在普通方法中是锁的当前对象(this)

package com.example.demo.lock8;


import java.util.concurrent.TimeUnit;

/**
 * 1.标准情况下,两个线程先打印 发短信还是打电话 ?
 */
public class Demo01 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{
            phone.sendSms();
        },"A").start();
        //睡眠1s
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone.call();
        },"B").start();
    }
}
class Phone{
    public synchronized void sendSms(){
        
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");

    }
}

2.SendSms 延迟4s ,两个线程先打印 发短信还是打电话 ?

先发短信,再打电话=>因为发短信先获取到锁,只要没有释放,就不会执行打电话,

package com.example.demo.lock8;


import java.util.concurrent.TimeUnit;

/**
 * 1.标准情况下,两个线程先打印 发短信还是打电话 ?
 * 2.SendSms 延迟4s ,两个线程先打印 发短信还是打电话 ?
 */
public class Demo01 {

    public static void main(String[] args) {

        Phone phone = new Phone();


        new Thread(()->{
            phone.sendSms();
        },"A").start();
        //睡眠1s
        try {
            TimeUnit.SECONDS.sleep(6);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone.call();
        },"B").start();
    }
}
class Phone{
    //synchronized 锁的是对象是方法的调用者
    // 两个方法用的是同一个锁,谁先拿到谁先执行
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

3. 增加了一个普通方法后，发短信还是hello?

先hello 后发短信

普通方法没有加锁

package com.example.demo.lock8;
import java.util.concurrent.TimeUnit;
/**
 * 3.  增加了一个普通方法后，发短信还是hello
 */
public class Demo03 {

    public static void main(String[] args) {

        Phone3 phone = new Phone3();


        new Thread(()->{
            phone.sendSms();
        },"A").start();
        //睡眠1s
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone.hello();
        },"B").start();
    }
}

class Phone3{
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
//	这里没有锁!
    public  void hello(){
        System.out.println("hello");
    }

}

4. 两个对象,两个同步方法,是先发短信还是先打电话?

两个对象,而synchronized 锁的普通同步方法,锁的是当前方法,

这里是两个对象

package com.example.demo.lock8;
import java.util.concurrent.TimeUnit;
/**
 * 4.两个对象,两个同步方法,是先发短信还是先打电话
 */
public class Demo03 {

    public static void main(String[] args) {

        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();


        new Thread(()->{
            phone1.sendSms();
        },"A").start();
        //睡眠1s
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}

class Phone3{
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }


}

5.增加两个静态的同步方法,只有一个对象是先输出什么?

先执行发短信再执行打电话

static 静态方法锁的类方法

package com.example.demo.lock8;
import java.util.concurrent.TimeUnit;
/**
 * 5.增加两个静态的同步方法,只有一个对象是先输出什么?
 * static 静态方法锁的类方法
 */
public class Demo03 {

    public static void main(String[] args) {
        Phone3 phone = new Phone3();
        new Thread(()->{
            phone.sendSms();
        },"A").start();
        //睡眠1s
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone.call();
        },"B").start();
    }
}
class Phone3{
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public static synchronized void call(){
        System.out.println("打电话");
    }
}

6. 两个对象,增加两个静态的同步方法,是先发短信还是打电话?

package com.example.demo.lock8;
import java.util.concurrent.TimeUnit;
/**
 * 6. 两个对象,增加两个静态的同步方法,是先发短信还是打电话?
 还先发短信
 * static 静态方法锁的类方法
 */
public class Demo03 {

    public static void main(String[] args) {
        //两个对象的class类模板只有一个,static,锁的是class
        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();

        new Thread(()->{
            phone1.sendSms();
        },"A").start();
        //睡眠1s
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}
class Phone3{
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public static synchronized void call(){
        System.out.println("打电话");
    }
}

7. 一个静态的同步方法,一个普通的同步方法,一个对象,先打印 发短信还是打电话

锁的不是同一个对象,一个是锁类,一个是锁对象没有关系

static 静态方法锁的类方法

package com.example.demo.lock8;
import java.util.concurrent.TimeUnit;

/**
 * 6. 一个静态的同步方法,一个普通的同步方法,一个对象,先打印 发短信还是打电话
 * 锁的不是同一个对象,一个是锁类,一个是锁对象没有关系
 * static 静态方法锁的类方法
 */
public class Demo04 {

    public static void main(String[] args) {
        Phone4 phone = new Phone4();

        new Thread(()->{
            phone.sendSms();
        },"A").start();
        //睡眠1s
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone.call();
        },"B").start();
    }
}

class Phone4{
//    静态的同步方法 锁的class类模板
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
//    普通的同步方法 锁的是调用者
    public  synchronized void call(){


        System.out.println("打电话");
    }
}

7. 一个静态的同步方法,一个普通的同步方法,两个个对象,先打印 发短信还是打电话

两个对象,

而锁的是类和一个对象

package com.example.demo.lock8;
import java.util.concurrent.TimeUnit;

/**
 * 7. 一个静态的同步方法,一个普通的同步方法,两个个对象,先打印 发短信还是打电话
 * 锁的不是同一个对象,一个是锁类,一个是锁对象没有关系
 * static 静态方法锁的类方法
 */
public class Demo04 {

    public static void main(String[] args) {
        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();

        new Thread(()->{
            phone1.sendSms();
        },"A").start();
        //睡眠1s
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}

class Phone4{
//    静态的同步方法 锁的class类模板
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
//    普通的同步方法 锁的是调用者
    public  synchronized void call(){


        System.out.println("打电话");
    }
}

小结

new this 具体的一个手机,

static Class唯一的一个模板类

集合类不安全

list不安全

ArrayList在并发下是不安全的,回报ConcurrentModificationException 并发时修改异常

package com.example.demo.collection;
import java.util.ArrayList;
import java.util.UUID;

public class Demo01 {
    public static void main(String[] args) {

        ArrayList<Object> list = new ArrayList<>();
        //ConcurrentModificationException 并发时修改异常
        //并发下ArrayList是不安全的
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            }).start();
        }

    }

}

解决方案

public class Demo01 {
    public static void main(String[] args) {
        /**
         * 解决方案
         * 1. List<String> list =  new Vector();
         */
//        List<Object> list = new ArrayList<>();
        List<String> list =  new Vector();
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            }).start();
        }
    }
}

​ 使用Vector可以,应为Vector是线程安全的,但是效率很慢

​ 因为add使用的是synchronized .

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y2KZQXi7-1630342824529)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210809001616066.png)]

List list = Collections.synchronizedList(new ArrayList<>());

package com.example.demo.collection;


import java.util.*;

public class Demo01 {
    public static void main(String[] args) {


        /**
         * 解决方案
         * 1. List<String> list =  new Vector();
         * 2. List<Object> list = Collections.synchronizedList(new ArrayList<>());
         */

//        List<Object> list = new ArrayList<>();
//        List<String> list =  new Vector();
        List<String> list = Collections.synchronizedList(new ArrayList<>());
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            }).start();
        }

    }

}

3. juc方法

package com.example.demo.collection;


import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;

public class Demo01 {
    public static void main(String[] args) {
        /**
         * 解决方案
         * 1. List<String> list =  new Vector();
         * 2. List<Object> list = Collections.synchronizedList(new ArrayList<>());
         */
//        List<Object> list = new ArrayList<>();
//        List<String> list =  new Vector();
//        List<String> list = Collections.synchronizedList(new ArrayList<>());
        // CopyOnWriteArrayList 写入时复制COW计算机程序设计的一种优化策略
        // 多个线程在调用时候, list 读取的时候是固定的,写入的时候会覆盖
        //在写入的时候避免覆盖,造成数据问题
        List<String> list = new CopyOnWriteArrayList();
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            }).start();
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SGdmAuGI-1630342824531)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210809002324926.png)]

使用的是Lock锁,没有使用synronized锁

就是在add时候回会先复制,在添加数据,再然后就将新的的添加到List中

Set不安全

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y4mQUJ2O-1630342824533)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210809225606989.png)]

package com.example.demo.collection;

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArraySet;

public class SetList {
    public static void main(String[] args) {
        //ConcurrentModificationException set不是线程安全的
        //HashSet<String> set = new HashSet<>();
        //解决方法1
        //Set<String> set = Collections.synchronizedSet(new HashSet<>());
        //解决方法1
        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

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JBB3X4CC-1630342824535)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210809230757775.png)]

hashset中的add方法

map中的key是不能重复的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qi41Fwmb-1630342824537)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210809230841241.png)]

HashMap

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MQWl66UJ-1630342824538)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210809232211491.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-F5aVOjxP-1630342824541)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210809232258421.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WnsA8hYc-1630342824542)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210809232750843.png)]

package com.example.demo.collection;

import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

public class MapTest {


    public static void main(String[] args) {
//        Map<String, String> map = new HashMap<>(16,0.75);
//         线程不安全的ConcurrentModificationException
//        Map<String, String> map = new HashMap<>();
        Map<String, String> map = new ConcurrentHashMap<>();
        for (int i = 1; i < 30; i++) {
            new Thread(()->{
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
                System.out.println(map);
            },String.valueOf(i)).start();
        }
    }
}

Callable

相较于Rannable的好处

有返回值

可以抛出异常

package com.example.demo.callable;


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

public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //new Thread(new Runnable()).start;
        //new Thread(new FutureTask<V>()).start;
        //new Thread(new FutureTask<V>(callable)).start;
        new Thread().start();//怎么启动Callable


        MyThread thread = new MyThread();
        FutureTask futureTask = new FutureTask(thread);//适配类
        new Thread( futureTask,"A").start();

        //返回Callable结果
        Integer o = (Integer) futureTask.get();
        System.out.println(o);

    }
}
class MyThread implements Callable<Integer>{

    @Override
    public Integer call() {
        System.out.println("call");
        return 1024;
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JQ1Mde05-1630342824544)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210809235520341.png)]

package com.example.demo.callable;


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

public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        MyThread thread = new MyThread();
        FutureTask futureTask = new FutureTask(thread);
        new Thread( futureTask,"A").start();
        new Thread( futureTask,"B").start();
        //返回结果
        Integer o = (Integer) futureTask.get();
        //可能会产生阻塞,因为要等线程返回,可能有点慢
        //我们把这个方法放在最后,或者使用异步的方式
        System.out.println(o);
    }
}

class MyThread implements Callable<Integer>{

    @Override
    public Integer call() {
        System.out.println("call");
        return 1024;
    }
}

**这里的结果只执行了一次,因为Funture中有state值,第二次执行时候state已经非new状态了,此时会结束对应线程,导致任务不执行知识在第一次执行的时候保存了结果 **

细节: 有缓存,结果可能需要等待

三个常见的辅助类

CountDownLatch

//就是一个减法计数器

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QN1MqToh-1630342824546)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210812235705574.png)]

package com.example.demo.helperClass;
import java.util.concurrent.CountDownLatch;
//就是一个计数器
public class CountDownLatchTest {
    public static void main(String[] args) throws InterruptedException {
        //总数是6,执行任务时候使用
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 1; i <= 6; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "goOut");
                //计数器减一,有6->5->4...
                countDownLatch.countDown();
            }, String.valueOf(i)).start();
        }
        // 等待 计数器归零,在向下执行,
        countDownLatch.await();
        System.out.println("Close Door");
    }
}

//原理
CountDownLatch countDownLatch = new CountDownLatch(6);
countDownLatch.countDown();//数量-1
countDownLatch.await();//等待计数器归0,然后再向下执行
//每次有点线程用countDown(),假设计数器变为0,countDownLatch.await()就会被唤醒,继续执行

CyclicBarrier

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-23cS1qb9-1630342824548)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210813001800297.png)]

不能使用i

package com.example.demo.helperClass;


import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

//加法计数器
public class CyclicBarrierTest {
    public static void main(String[] args) {

        CyclicBarrier cyclicBarrier = new CyclicBarrier(8, () -> {
            System.out.println("成功集成7颗龙珠,成功召唤神龙");
        });
        for (int i = 1; i <= 7; i++) {
            final int temp = i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"收集到第"+temp+"颗龙珠");
                try {
                    cyclicBarrier.await();//+1 操作,等待达到7,才会执行上面的那个线程,对其他没有任何影响
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }
        System.out.println("结束");//什么时候执行,是在看那7次线程,与main线程谁先执行
    }
}

Semaphore

信号量 就好比一个抢车位,有6台车,只有3个车位,当车位沾满了,只有车出来了,才能有车进去

限流

package com.example.demo.helperClass;


import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class SemaphoreTest {
    public static void main(String[] args) {
        //设置为只有3个车位,
        //3为线程数量
        Semaphore semaphore = new Semaphore(3);
        for (int i = 1; i <= 6; i++) {
            new Thread(()->{
                //acquire() 得到线程
                //release() 释放线程
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"得到车位,可以执行");
                    TimeUnit.SECONDS.sleep(2);//占用2s
                    System.out.println(Thread.currentThread().getName()+"离开车位,释放位置");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release();
                }
            },String.valueOf(i)).start();
        }
    }
}

//原理

Semaphore semaphore = new Semaphore(3);
semaphore.acquire();//获得,假设已经满了,就等待,等待有释放的位置
semaphore.release();//释放,会将当前的信号量减一,然后唤醒等待的线程

//作用:多个共享资源互斥的使用!并发限流,控制最大的线程数!

读写锁

读与读 可以共存

写与读 不可以共存

写与写 不可以共存

//读写锁,,相较与lock而言,更加细粒度,
//读时候可以多个线程,写的时候只能一个线程

package com.example.demo.wr;

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

//读写锁
public class ReadWriteLockDemo {
    public static void main(String[] args) {

        MyCacheLock myCache = new MyCacheLock();

        for (int i = 1; i <= 10; i++) {
            final int temp = i;
            new Thread(()->{
                myCache.put(temp+"",temp+"");
            },String.valueOf(i)).start();
        }
        for (int i = 1; i <= 10; i++) {
            final int temp = i;
            new Thread(()->{
                myCache.get(temp+"");
            },String.valueOf(i)).start();
        }

    }
}

//使用了读写锁的
class MyCacheLock{
    private volatile Map<String,Object> map = new HashMap<>();
    //读写锁,,相较与lock而言,更加细粒度,
    //读时候可以多个线程,写的时候只能一个线程
    ReadWriteLock lock = new ReentrantReadWriteLock();
    //写入的时候,只希望同时只有一个线程写
    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()+"写入完成"+key);
        } 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);
            Object o = map.get(key);
            System.out.println(Thread.currentThread().getName()+"读取完成"+key);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.readLock().unlock();
        }
    }
}
//普通方式的资源类
class MyCache{
    private volatile Map<String,Object> map = new HashMap<>();
    public void put(String key,Object value){
        System.out.println(Thread.currentThread().getName()+"开始写入"+key);
        map.put(key,value);
        System.out.println(Thread.currentThread().getName()+"写入完成"+key);
    }
    public void get(String key){
        System.out.println(Thread.currentThread().getName()+"开始读取"+key);
        Object o = map.get(key);
        System.out.println(Thread.currentThread().getName()+"读取完成"+key);
    }
}

阻塞队列

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-z7GoIzzW-1630342824550)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210814150244364.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IUoX3o1s-1630342824552)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210814150528414.png)]

• BlockingDeque :双端队列
• BlockingQueue:阻塞队列

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QMBStqfM-1630342824554)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210814150850670.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yK6Oy08x-1630342824555)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210815234504509.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6Lyd8kqY-1630342824560)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210815234715395.png)]

学会使用队列

1. 抛出异常
2. 不会抛出异常
3. 阻塞等待
4. 超时等待

方式	抛出异常	不会抛出异常,有返回值	阻塞等待	超时等待
添加	add()	offer()	put	offer(,)
移除	remove()	poll()	take	poll(,)
检查队首元素	element()	peek()	-	-

    //抛出异常
	public static void test1(){
        ArrayBlockingQueue<Object> blockingQueue = new ArrayBlockingQueue<>(3);

        System.out.println(blockingQueue.add("a"));
        System.out.println(blockingQueue.add("b"));
        System.out.println(blockingQueue.add("c"));
        System.out.println(blockingQueue.element());//获取队首元素


//        System.out.println(blockingQueue.add("d"));抛出异常  Queue full
        System.out.println("==========================");
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
        System.out.println(blockingQueue.remove());
//        System.out.println(blockingQueue.remove());抛出异常  NoSuchElementException
    }

    //不会抛出异常,有返回值
	public static void test2(){
        ArrayBlockingQueue<Object> blockingQueue = new ArrayBlockingQueue<>(3);

        System.out.println(blockingQueue.offer("a"));
        System.out.println(blockingQueue.offer("a"));
        System.out.println(blockingQueue.offer("a"));
        System.out.println(blockingQueue.offer("a"));// 不抛出异常 false
        //System.out.println(blockingQueue.element());//获取队首元素
        System.out.println(blockingQueue.peek());//获取队首元素
        System.out.println("==============================");

        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll()); // 不抛出异常 null

    }

    //阻塞等待(一直阻塞)
    public static void test3() throws InterruptedException {
        ArrayBlockingQueue<Object> blockingQueue = new ArrayBlockingQueue<>(3);

        blockingQueue.put("a");
        blockingQueue.put("b");
        blockingQueue.put("c");
//        blockingQueue.put("d");队列没有位置,一直等待,阻塞了
	    System.out.println("==============================");
        System.out.println(blockingQueue.take());
        System.out.println(blockingQueue.take());
        System.out.println(blockingQueue.take());
//        System.out.println(blockingQueue.take());队列没有元素了,一直等待,阻塞了
    }

    //阻塞超时
    public static void test4() throws InterruptedException {

        ArrayBlockingQueue<Object> blockingQueue = new ArrayBlockingQueue<>(3);

        System.out.println(blockingQueue.offer("a"));
        System.out.println(blockingQueue.offer("b"));
        System.out.println(blockingQueue.offer("c"));
        System.out.println(blockingQueue.offer("d",2, TimeUnit.SECONDS));//等待超过2s就退出

        System.out.println("=============");

        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll());
        System.out.println(blockingQueue.poll(2,TimeUnit.SECONDS));//等待超过2s就退出

    }

SynchronousQueue同步队列

package com.example.demo.bq;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;
//同步队列
/**
 * 同步队列跟BlockingQueue不一样,Synchronousqueue不存储元素
 * put 了一个元素,必须从里面取出来,否则不能再put进去值!
 */
public class SynchronousQueueDemo {

    public static void main(String[] args) {

        BlockingQueue<String> blockingQueue = new SynchronousQueue<>();//同步队列

        new Thread(() -> {
            try {
                System.out.println(Thread.currentThread().getName() + "添加了元素1");
                blockingQueue.put("1");
                System.out.println(Thread.currentThread().getName() + "添加了元素2");
                blockingQueue.put("2");
                System.out.println(Thread.currentThread().getName() + "添加了元素3");
                blockingQueue.put("3");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "T1").start();
        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName() + "获取的元素" + blockingQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName() + "获取的元素" + blockingQueue.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName() + "获取的元素" + blockingQueue.take());

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "T2").start();
    }
}

线程池

线程池:3大方法,7大参数,4种拒绝策略

线程池的好处

1. 降低资源的消耗
2. 提高响应的速度
3. 方便管理

线程的复用,可以控制最大的并发数,管理线程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CSVX52R7-1630342824563)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210816230828473.png)]

线程池Executors使用,3大方法

package com.example.demo.pool;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

//Executors工具类,3大方法
public class Demo01 {
    public static void main(String[] args) {
//        ExecutorService threadPool = Executors.newSingleThreadExecutor();//单例线程池,线程池中只能有一个线程
//        ExecutorService threadPool = Executors.newFixedThreadPool(5);//固定线程池,创建一个线程是固定的线程池
        ExecutorService threadPool = Executors.newCachedThreadPool();//缓存线程池,线程数量可变化的

        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();
        }
    }
}

3种线程底层都是使用了ThreadPoolExecutor

7大参数

    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.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1MmpqcE4-1630342824564)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210817004553757.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OfdxBI3I-1630342824567)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210817004623056.png)]

手动创建一个线程池(原生)

package com.example.demo.pool;

import java.util.concurrent.*;

public class Demo02 {

    public static void main(String[] args) {
        ExecutorService threadPool = new ThreadPoolExecutor(
                2,
                5,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(3),
                Executors.defaultThreadFactory(),
//                new ThreadPoolExecutor.AbortPolicy()//拒绝策略,池子满了之后,不处理新来线程,导出线程
//                new ThreadPoolExecutor.CallerRunsPolicy()//拿来的去哪里
//                new ThreadPoolExecutor.DiscardPolicy()//队列满了,丢弃新线程,不会抛出异常
                new ThreadPoolExecutor.DiscardOldestPolicy()//队列满了,尝试去和最早的竞争,也不会抛出异常
        );
        try {
            //最大值为max+ Qeque,
            //线程数超出最大线程数,就会执行拒绝策略
             for (int i = 1; i <= 8; i++) {
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            threadPool.shutdown();
        }
    }
}

4中拒绝策略

• new ThreadPoolExecutor.AbortPolicy()//拒绝策略,池子满了之后,不处理新来线程,导出线程
• new ThreadPoolExecutor.CallerRunsPolicy()//拿来的去哪里
• new ThreadPoolExecutor.DiscardPolicy()//队列满了,丢弃新线程,不会抛出异常
• new ThreadPoolExecutor.DiscardOldestPolicy()//队列满了,尝试去和最早的竞争,也不会抛出异常

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GYzrvp7b-1630342824570)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210817005101924.png)]

最大线程数定义时候应该注意:

1. CPU 密集型,多少核就是就多少,可以保持CPU效率最高.

2. [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gavcpVWy-1630342824573)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210824224325341.png)]

3. Runtime.getRuntime().availableProcessors//获取当前线程数
   

4. IO 密集型 ,判断你的程序中十分消耗IO的线程数量,大于 这个数量.(一般是两倍)

   ​ IO十分占用资源,

四大函数式接口

当下的程序的重点:lambda表达式,链式编程,函数式接口,Stream流式计算

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dekman9V-1630342824576)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210824224824128.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-g5WMhIZ4-1630342824578)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210824232644607.png)]

@FunctionlInterface->函数式接口,该接口中只有一个方法.通常可以使用lombda表示

简化编程模型,新版本的框架底层大量使用

1. Function : 传入参数T,返回R 函数性接口

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-moZYwXNj-1630342824579)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210824233147597.png)]

   Function<String, String> function = new Function<String, String>() {
       @Override
       public String apply(String o) {
           return o;
       }
   };
   
   System.out.println(function.apply("qwe"));
   
   Function<String, String> function1 = (o)->{return o;};
   System.out.println(function1.apply("asd"));
   

2. Predicate:传入一个参数,返回一个boolean判断性接口

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yM77FeJH-1630342824581)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210824234015973.png)]

//判断性接口
Predicate predicate = new Predicate<String>() {
    @Override
    public boolean test(String o) {
        return false;
    }
};
System.out.println(predicate.test("qwe"));

Predicate predicate1 =(o)->{return true;};

System.out.println(predicate1.test("qwe"));

3. Consumer :消费型接口 只有输入没有返回值

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mClDEGLB-1630342824582)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210824234234173.png)]

   Consumer consumer = new Consumer<String>() {
       @Override
       public void accept(String o) {
           System.out.println(o);
       }
   };
   consumer.accept("qwe");
   
   Consumer consumer1 = (str)->{
       System.out.println(str);
   };
   consumer1.accept("asd");
   

4. Supplier 供给型接口 没有参数只有返回值

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zq8Uh1p4-1630342824584)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210824234929162.png)]

       Supplier supplier = new Supplier<Integer>() {
           @Override
           public Integer get() {
               return 1024;
           }
       };
   
       System.out.println(supplier.get());
   
       Supplier supplier1 = ()->{
           return 1024;
       };
       System.out.println(supplier1.get());
   
   }
   

流式计算

大数据:存储+计算

存储:集合,Mysql

计算:都应该交给流计算

public class Demo {
    public static void main(String[] args) {
        User user1 = new User(1,"a",21);
        User user2 = new User(2,"b",22);
        User user3 = new User(3,"c",23);
        User user4 = new User(4,"d",24);
        User user5 = new User(5,"e",25);
        //集合就是存储
        List<User> users = Arrays.asList(user1, user2, user3, user4, user5);

        //计算交给Stream流
        //lambda表达式,链式编程,函数是接口,Stream流式计算
        Stream<User> stream = users.stream();
        stream.filter( u ->{return u.getId()%2 == 0;})
                .filter(u->{return u.getAge()>23;})
                .map(u->{return u.getName().toUpperCase();})
                .sorted((u1,u2)->{return u1.compareTo(u2);})
                .limit(1)
               .forEach(System.out::println);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LDtLE8Kv-1630342824585)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210825224912248.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WJM8zWWm-1630342824589)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210825224917944.png)]

ForkJoin

后面研究

异步回调

Future 设计的初衷: 对将来的某个事件的结果进行建模

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rrKTlZ2X-1630342824590)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210826211445577.png)]

        //发起一个请求
        //没有返回值的
//        CompletableFuture<Void> future = new CompletableFuture().runAsync(()->{
//            try {
//                TimeUnit.SECONDS.sleep(2);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//            System.out.println(Thread.currentThread().getName()+"runAsync=>Void");
//        });
//
//        System.out.println("1111");
//        future.get();//获取执行结果

        //有返回值
        CompletableFuture<Integer> uCompletableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println("completableFuture");
            int i = 10 / 0;//模拟错误信息
            return 1024;
        });

        System.out.println(uCompletableFuture
                .whenComplete((t, u) -> {
                    System.out.println("t=>" + t);//返回正常的返回值结果,错误时候为null
                    System.out.println("u=>" + u);//错误的信息:   正确的时候为null \
                })
                .exceptionally((e) -> {
                    System.out.println(e.getMessage());
                    return 233;
                }).get());//get() 得到返回值

JMM

请你谈谈你对Vilatile的理解

1. 保证可见性
2. 不保证原子性
3. 禁止指令重排

什么是JMM

JMM:是java内存模型,不存在的东西,概念!约定!

JMM的三个特征

Java内存模型是围绕着并发编程中原子性、可见性、有序性这三个特征来建立的

• 一个操作不能被打断，要么全部执行完毕，要么不执行。在这点上有点类似于事务操作，要么全部执行成功，要么回退到执行该操作之前的状态。
• 一个线程对共享变量做了修改之后，其他的线程立即能够看到（感知到）该变量的这种修改（变化）。
• 对于一个线程的代码而言，我们总是以为代码的执行是从前往后的，依次执行的。这么说不能说完全不对，在单线程程序里，确实会这样执行；但是在多线程并发时，程序的执行就有可能出现乱序。用一句话可以总结为：在本线程内观察，操作都是有序的；如果在一个线程中观察另外一个线程，所有的操作都是无序的。前半句是指“线程内表现为串行语义（WithIn Thread As-if-Serial Semantics）”,后半句是指“指令重排”现象和“工作内存和主内存同步延迟”现象。

关于JMM的一些同步的约定:

1. 线程解锁前,必须把共享变量立刻刷回主存.就是保持可见性,一旦内存区中的变量,在线程中发生变化的时候,要立刻在内存中的变量要跟着变化
2. 线程加锁前,必须读取主存中的最新值到工作内存中.
3. 加锁和解锁是同一把锁.

线程: 工作内存和主内存

JMM的8中操作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DyI4dZJj-1630342824591)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210826223226144.png)]

问题

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-D5WXvxR2-1630342824594)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210826223312786.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-X1r4ES4e-1630342824595)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210826223414290.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YcdffyAW-1630342824602)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210826223622596.png)]

测试

public class tvolatile {

    private static  int num = 0;
    public static void main(String[] args) {//主线程

        new Thread(()->{//线程A
            while (num ==0){
            }
        }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        num =1;
        System.out.println(num);
    }
}

该例子中,有两个线程,A线程会在num=0的时候一直执行,而main线程会在1s后将num改为1,注意是A线程先执行才将num改为1.

此时A线程并不会停止执行,因为在main线程中对进行了num的修改,并不会影响的A线程中的num的值.

valatile

可见性

public class tvolatile {
	//不加volatile就会死循环
    //加了volatile就会保证可见性
    private static volatile int num = 0;
    public static void main(String[] args) {//主线程

        new Thread(()->{//线程1
            while (num ==0){

            }
        }).start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        num =1;
        System.out.println(num);
    }
}

不保证原子性

原子性:不可打扰的,不可分割的

线程A在执行任务的时候,不能被打扰,也不能被分割.要么同时成功,要么同时失败

//不保证原子性,原子性应该输出为20000
public class VDemo02 {
    private static int num = 0;
    public static void add(){
        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){//总线程数量大于2,java有两个默认线程main和gc.大于2就代表还有出了默认的主线程还有线程在执行
            Thread.yield();//礼让其他线程执行;主要目的的让我们自定义的所有的线程全部都执行完成
        }
        System.out.println(Thread.currentThread().getName()+""+num);

    }
}

直接多线程执行,结果不为20000

//不保证原子性,原子性应该输出为20000
public class VDemo02 {
    private static volatile  int num = 0;
    public static void add(){
        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){//总线程数量大于2,java有两个默认线程main和gc.大于2就代表还有出了默认的主线程还有线程在执行
            Thread.yield();//礼让其他线程执行;主要目的的让我们自定义的所有的线程全部都执行完成
        }
        System.out.println(Thread.currentThread().getName()+""+num);

    }
}

添加了volatile结果还是不为20000

//不保证原子性
public class VDemo02 {
    private static  int num = 0;

    public static synchronized void add(){
        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){//总线程数量大于2,java有两个默认线程main和gc.大于2就代表还有出了默认的主线程还有线程在执行
            Thread.yield();//礼让其他线程执行;主要目的的让我们自定义的所有的线程全部都执行完成
        }
        System.out.println(Thread.currentThread().getName()+""+num);

    }
}

加了synchronized锁,就成功输出了20000,保证了原子性

如果不使用lock和synchronized,怎么保证原子性?

public static synchronized void add(){
    num++;//根本不是原子性操作
}

​ 查看字节码文件,

1. 打开target文件中对应类的位置

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-L8KHSLnh-1630342824604)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210826232305524.png)]

2. cmd进入命令栏

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zPQhl7Vp-1630342824609)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210826232342730.png)]

3. 使用javap -c 类名 查看字节码文件

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Zuxzrsh0-1630342824610)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210826232433817.png)]

回到add()中

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WEj3U5gU-1630342824612)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210826232726372.png)]

底层是有3个步骤的,所以add()不是原子性操作

我们可以使用原子类来解决原子类操作

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-u9ZHuipO-1630342824613)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210826232956244.png)]

//不保证原子性
public class VDemo02 {
    private static AtomicInteger num = new AtomicInteger();
    public static void add(){
        num.getAndIncrement();//执行了+1方法
    }
    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){//总线程数量大于2,java有两个默认线程main和gc.大于2就代表还有出了默认的主线程还有线程在执行
            Thread.yield();//礼让其他线程执行;主要目的的让我们自定义的所有的线程全部都执行完成
        }
        System.out.println(Thread.currentThread().getName()+""+num);
    }
}

使用原子类就保证了原子性,底层使用了cas

原子类的效率要高于锁,原子类中的Unsafe类是一个很特殊的存在.

指令重排

什么是指令重排:你写的程序,计算机并不是按照你的写的那样执行的
源代码->编译器优化的重排->指令并行也可能会重排->内存系统也会重排->执行

int x = 1;//1
int y = 2;//2
x = x + 5;//3
y = x + x;//4

我们所希望的执行顺序是1234,但是可能执行的时候变回2134 1324

不会是4123因为

处理器在进行指令重排的时候,考虑:数据之间的会依赖性!!

指令重排的情况:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wuBuVoBz-1630342824615)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210828200232458.png)]

理论上面会发生,但是几率很小.

volatile可以避免指令重排

内存屏障.CPU指令.作用:

1. 保持特定的操作的执行顺序!
2. 可以保证某些变量的内存可见性

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WO7WGI1F-1630342824616)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210828200542338.png)]

Volatile是可以保持可见性,不能保证原子性,由于内存屏障,可以避免指令重排的现象的产生!!!

Volatile在单例模式中使用的最常见

单例模式

恶汉式

package com.example.demo.single;


//单例模式->构造器私有

//恶汉式单例
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 static final Hungry hungry = new Hungry();
    public static Hungry getInstance(){
        return hungry;
    }
}

恶汉式是在类加载的时候就创建了对象,缺点在类中有消耗资源.因为在类加载的时候就创建了一些数组之类的,但是该对象一直没有被使用就一直就一直占据空间.

懒汉式单例

package com.example.demo.single;

public class LazyMan {
    private LazyMan() {
    }
    private static LazyMan lazyMan;
    public static LazyMan getInstance() {
        if (lazyMan == null) {
            lazyMan = new LazyMan();
        }
        return lazyMan;
    }

}

但是只是在单线程下是ok的;

多线程下是会破坏单例的.

多线程下破坏单例模式

package com.example.demo.single;

public class LazyMan {
    private LazyMan() {
        System.out.println(Thread.currentThread().getName()+"ok");
    }
    private static LazyMan lazyMan;

    public static LazyMan getInstance() {
        if (lazyMan == null) {
            lazyMan = new LazyMan();
        }
        return lazyMan;
    }
    //多线程并发
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{LazyMan.getInstance();}).start();
        }
    }
}

结果为:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6TaWBiXe-1630342824618)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210828211503827.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YZyBGHZs-1630342824619)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210828211512681.png)]

创建了不止一个实例.

我们可以通过加锁来解决多线程破坏单例模式

package com.example.demo.single;

public class LazyMan {

   private LazyMan() {
       System.out.println(Thread.currentThread().getName()+"ok");
   }

   private static LazyMan lazyMan;

   public static LazyMan getInstance() {
       if (lazyMan == null){//将多线程中lazyMan为null的几个线程筛选出来
           synchronized (LazyMan.class){//为类加锁,几个lazyman为null的线程只能依次执行,不能同时执行.
                if (lazyMan==null){//使第一个线程进来的时候创建对象,后面的就不在创建对象
                    lazyMan = new LazyMan();
                }
           }
       }
       return lazyMan;
   }

   //多线程并发
   public static void main(String[] args) {

       for (int i = 0; i < 10; i++) {
           new Thread(()->{LazyMan.getInstance();}).start();
       }
   }

}

这个叫双重检测模式的懒汉式单例 也叫DCL懒汉式

单例模式不是原子性操作,可能发生指令重排

package com.example.demo.single;

public class LazyMan {

    private LazyMan() {
        System.out.println(Thread.currentThread().getName()+"ok");
    }


    private volatile static LazyMan lazyMan;

    public static LazyMan getInstance() {
        if (lazyMan == null){
            synchronized (LazyMan.class){
                 if (lazyMan==null){
                     lazyMan = new LazyMan();//不是一个原子性操作
                     /**
                      * 1. 分配内存空间
                      * 2. 执行构造方法
                      * 3. 把这个对象指向这个空间
                      *
                      * 正确情况下123步骤
                      * 所以可能发生指令重排的,我们需要加上volatile
                      * 指令重排的情况下可能132,这样
                      *第一个线程在先执行1->3->第二个线程就可以判断不为null(但是只有内存空间,没有具体对象),
                      *就直接返回了对象,->2造成指令重排
                      */
                 }
            }
        }
        return lazyMan;
    }
    //多线程并发
    public static void main(String[] args) {

        for (int i = 0; i < 10; i++) {
            new Thread(()->{LazyMan.getInstance();}).start();
        }
    }
}

第一个线程在先执行1->3->第二个线程就可以判断不为null(但是只有内存空间,没有具体对象),就直接返回了对象,->2造成指令重排

我们可以加上volatile增加原子性操作

静态内部实现单例模式

package com.example.demo.single;
public class Holder {
    private Holder(){};
    public static Holder getInstance(){
        return InnerClass.holder;
    }
    public static class InnerClass{
        private static final Holder holder = new Holder();
    }
}

也是不安全的.

这些单例都可以通过反射实现暴力破解.

反射暴力破解

在反射面前所有的私有属性都是闹着玩的.

package com.example.demo.single;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class LazyMan {

    private LazyMan() {
        System.out.println(Thread.currentThread().getName()+"ok");
    }
    private volatile static LazyMan lazyMan;
    public static LazyMan getInstance() {
        if (lazyMan == null){
            synchronized (LazyMan.class){
                 if (lazyMan==null){
                     lazyMan = new LazyMan();
                 }
            }
        }
        return lazyMan;
    }
    //反射
    public static void main(String[] args) throws Exception {
        LazyMan instance = LazyMan.getInstance();
        Constructor<LazyMan> constructor = LazyMan.class.getDeclaredConstructor(null);//走了无参构造
        constructor.setAccessible(true);//允许通过反射区的对象中的私有的字段值.无私私有.
        LazyMan instance1 = constructor.newInstance();
        System.out.println(instance);//是使用getInstance方法创建的对象
        System.out.println(instance1);//是直接使用类的构造方法创建的对象
    }


}

结果为

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xZQc7eFh-1630342824621)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210828220001028.png)]

并不是只有一个对象,破坏的单例模式

    System.out.println(instance);//是使用getInstance方法创建的对象
    System.out.println(instance1);//是直接使用类的构造方法创建的对象

我们只在getInstance中加了锁,但是在构造器中没有,可以通过构造器创建多个对象

这样的话我们可以通过给构造方法中加一个判断

package com.example.demo.single;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class LazyMan {
    private LazyMan() {
        synchronized (LazyMan.class){
            if (lazyMan!=null){//在调用构造方法的时候进行判断,如果进行构造过对象就直接抛出异常
                throw new RuntimeException("不试图使用反射破坏异常.");
            }
        }
    }
    private volatile static LazyMan lazyMan;
    public static LazyMan getInstance() {
        if (lazyMan == null){
            synchronized (LazyMan.class){
                 if (lazyMan==null){
                     lazyMan = new LazyMan();
                 }
            }
        }
        return lazyMan;
    }
    //反射
    public static void main(String[] args) throws Exception {
        LazyMan instance = LazyMan.getInstance();
        Constructor<LazyMan> constructor = LazyMan.class.getDeclaredConstructor(null);
        constructor.setAccessible(true);//允许通过反射区的对象中的私有的字段值.无私私有.
        LazyMan instance1 = constructor.newInstance();
        System.out.println(instance);
        System.out.println(instance1);
    }
}

注意:此时是一个getInstance()方法(get静态lazyMan赋值得到的)创建的对象,一个是使用构造器(反射,没有通过静态变量lazyMan直接得到)创建的对象

那么此时我们同时使用反射穿件两个对象,那么我们在构造器中加的判断**if (lazyMan!=null)**就没有用了(因为我们没有使用getInstance(),就没有getlazyMan赋值)

package com.example.demo.single;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class LazyMan {

    private LazyMan() {
        synchronized (LazyMan.class){
            if (lazyMan!=null){
                throw new RuntimeException("不试图使用反射破坏异常.");
            }
        }
    }

    private volatile static LazyMan lazyMan;
    public static LazyMan getInstance() {
        if (lazyMan == null){
            synchronized (LazyMan.class){
                 if (lazyMan==null){
                     lazyMan = new LazyMan();
                 }
            }
        }
        return lazyMan;
    }
    //反射
    public static void main(String[] args) throws Exception {
//        LazyMan instance = LazyMan.getInstance();通过getInstance()getlazyMan赋值得到的对象
        Constructor<LazyMan> constructor = LazyMan.class.getDeclaredConstructor(null);
        constructor.setAccessible(true);//允许通过反射区的对象中的私有的字段值.无私私有.
        LazyMan instance1 = constructor.newInstance();
        LazyMan instance = constructor.newInstance();

        System.out.println(instance);
        System.out.println(instance1);
    }


}

我们此时使用的是两个构造直接创建对象,没有通过getInstance()

结果为

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qjS5NznM-1630342824622)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210828231741038.png)]

这又破坏了单例模式

这样的话,我们又可以通过红绿灯的方式,增加一个无论使用反射(直接使用构造器的),还是使用getInstance()的方法的判断来实现

package com.example.demo.single;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class LazyMan {

    private static boolean qihao = false;//红绿灯

    private LazyMan() {
        synchronized (LazyMan.class){
            if (qihao == false){//无论是反射还是getInstace(),构造对象一次之后qihao就位true了,后面再进行就会抛异常
                qihao = true;
            }else {
                throw new RuntimeException("不试图使用反射破坏异常.");
            }
        }
    }

    private volatile static LazyMan lazyMan;
    public static LazyMan getInstance() {
        if (lazyMan == null){
            synchronized (LazyMan.class){
                 if (lazyMan==null){
                     lazyMan = new LazyMan();
                 }
            }
        }
        return lazyMan;
    }
    //反射
    public static void main(String[] args) throws Exception {
//        LazyMan instance = LazyMan.getInstance();通过getInstance()getlazyMan赋值得到的对象
        Constructor<LazyMan> constructor = LazyMan.class.getDeclaredConstructor(null);
        constructor.setAccessible(true);//允许通过反射区的对象中的私有的字段值.无私私有.
        LazyMan instance1 = constructor.newInstance();
        LazyMan instance = constructor.newInstance();

        System.out.println(instance);
        System.out.println(instance1);
    }
}

这样又保证了单例,

但是反射没有这么简单,因为我们使用了红绿灯,就是字段qihao,来判断的.反射又可以改变的红绿灯的值,所以,反射又能以改变红绿灯的值来继续破解单例模式.

package com.example.demo.single;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

public class LazyMan {

    private static boolean qihao = false;//红绿灯

    private LazyMan() {
        synchronized (LazyMan.class){
            if (qihao == false){//无论是反射还是getInstace(),构造对象一次之后qihao就位true了,后面再进行就会抛异常
                qihao = true;
            }else {
                throw new RuntimeException("不试图使用反射破坏异常.");
            }
        }
    }

    private volatile static LazyMan lazyMan;
    public static LazyMan getInstance() {
        if (lazyMan == null){
            synchronized (LazyMan.class){
                 if (lazyMan==null){
                     lazyMan = new LazyMan();
                 }
            }
        }
        return lazyMan;
    }
    //反射
    public static void main(String[] args) throws Exception {
        Field qihao = LazyMan.class.getDeclaredField("qihao");//获取红绿灯qihao的字段
        qihao.setAccessible(true);//无视他的private私有

        Constructor<LazyMan> constructor = LazyMan.class.getDeclaredConstructor(null);
        constructor.setAccessible(true);
        LazyMan instance1 = constructor.newInstance();
        qihao.set(instance1,false);//将对象的qihao改为false
        LazyMan instance = constructor.newInstance();

        System.out.println(instance);
        System.out.println(instance1);
    }


}

结果为

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-B8fS7yel-1630342824624)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210828233510637.png)]

这样的话,单例模式又被破坏了,原因是红绿灯失去了作用.

到现在我们就需要查看反射的源码,来看反射问题到底怎么解决

使用源码(枚举)来解决反射破坏单例模式

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Gyv4iYE9-1630342824625)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210828233837448.png)]

源码中写了 如果是个枚举类型就不能使用反射创建枚举类型

package com.example.demo.single;
import java.lang.reflect.Constructor;
//enun是什么?本身也是一个class 类,
public enum EnumSingle {
    INSTANCE;
    public EnumSingle getInstance(){
        return INSTANCE;
    }
}
class Test{
    public static void main(String[] args) throws Exception {
        //直接获取
        EnumSingle instance = EnumSingle.INSTANCE;

        //使用反射获取

        Constructor<EnumSingle> constructor = EnumSingle.class.getDeclaredConstructor(null);
        constructor.setAccessible(true);
        EnumSingle instance1 = constructor.newInstance();
        System.out.println(instance);
        System.out.println(instance1);
    }
}

结果为

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4KhlSqiG-1630342824627)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210828234706362.png)]

使用枚举之后,的确不能使用反射创建了,但是结果抛出的异常跟我们之前看的源码不一样

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UR9rqVEW-1630342824628)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210828234804620.png)]

Exception in thread “main” java.lang.NoSuchMethodException: com.example.demo.single.EnumSingle.()

的意思是没有空参构造器,但是idea编译的结果中有一个空参构造器

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-J4DHqM0n-1630342824630)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210828234955569.png)]

我们去反编译查看一下

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-V974jogg-1630342824631)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210828235216408.png)]

反编译中也有一个从参构造器,

我们在通过专业工具jad进行查看:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VduVQHnD-1630342824632)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210828235342577.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-edMqZXCs-1630342824634)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210828235519319.png)]

通过专业构造器我们终于可以看见底层是有一个有参构造器,而不是无参构造器,我们再通过这个有参构造器在代码中进行查看

package com.example.demo.single;


import java.lang.reflect.Constructor;

//enun是什么?本身也是一个class 类,
public enum EnumSingle {
    INSTANCE;

    public EnumSingle getInstance(){
        return INSTANCE;
    }

}
class Test{
    public static void main(String[] args) throws Exception {
        //直接获取
        EnumSingle instance = EnumSingle.INSTANCE;

        //使用反射获取

        Constructor<EnumSingle> constructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        constructor.setAccessible(true);
        EnumSingle instance1 = constructor.newInstance();
        System.out.println(instance);
        System.out.println(instance1);


    }
}

结果为

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9zq9ioew-1630342824635)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210828235918809.png)]

我们终于得到了我们想要的异常.Exception in thread “main” java.lang.IllegalArgumentException: Cannot reflectively create enum objects,意思为不能通过反射创建枚举对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YijDeV0u-1630342824638)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210828234804620.png)]

注意:之前的源码和反编译中的无参构造的欺骗了我们,真正使用的有参构造

深入了解CAS

什么是CAS

//CAS->compareAndSet->比较并交换

package com.example.demo.cas;

import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo {

    //CAS->compareAndSet->比较并交换
    public static void main(String[] args) {
        AtomicInteger atomicInteger = new AtomicInteger(2021);
        //比较并交换
        System.out.println(atomicInteger.compareAndSet(2021, 2022));//如果值为2021,就修改值为2022,并返回true
        System.out.println(atomicInteger.get());

        System.out.println(atomicInteger.compareAndSet(2021, 2023));
        System.out.println(atomicInteger.get());

    }
}

//expect 期望值
//update 更新值
public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0gTh71FG-1630342824639)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210829004827334.png)]

我们点进unsafe得到

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-P2I59RCc-1630342824641)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210829004927454.png)]

Unsafe

java无法操作内存,

java可以调用C++ : java怎么操作C++,通过native

C++可以操作内存

Unsafe相当java的后门,可以通过这个类操作内存

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-x3FXzVUv-1630342824642)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210829005232802.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RqUV40Kz-1630342824643)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210829005349676.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PRDbVopA-1630342824644)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210829005610297.png)]

v1是当前对象(好比数组a)

v2是内存地址的偏移值(好比数组中地址值i)

v5是v1对象在v2地址的值(好比v5=a[i])

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gt3SOiVD-1630342824647)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210829010348080.png)]

CAS:就是比较当前工作内存中的值,与主内存中的值,如果这个值是期望的,那么抉择执行操作!如果不是就一直循环(自旋锁)!

缺点:

1. 循环会耗时
2. 一次性只能保证一个共享变量的原子性
3. ABA问题

原子引用(解决ABA)

ABA问题在乐观锁中也见过

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wOpq7ZZV-1630342824649)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210829012816966.png)]

ABA问题:线程a要在值为1的时候进行操作,但是在a操作之前线程b对值进行了修改并且有改回了1.对此a完全不知情.直接执行了.

我们可以使用原子引用(加一个类似版本号的)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-khXg5umL-1630342824650)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210829013230076.png)]

AtomicStampedReference//在上面的基础上增加了一个版本号

注意事项

Integer使用了对象的缓存机制,默认范围是-128~127,推荐使用今天工厂方法valueOf获取对象实例,而不是new,因为valueOf使用缓存,而new一定会创建新的对象分配新的内存空间

就是说,缓存机制不在-128~127之间会new一个新的对象存值.

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9vGg6uRg-1630342824652)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210829015247264.png)]

new AtomicStampedReference<>(100,1)注意,如果泛型是一包装类要注意对象的引用问题

一般在正常业务中cas不会使用integer,而是使用对象,比较修改对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ttrFRaAM-1630342824654)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210829015947173.png)]

言归正传

package com.example.demo.cas;

import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.AtomicStampedReference;

public class CASDemo {

    public static void main(String[] args) {

        //Integer
        AtomicStampedReference<Integer> AtomicReference = new AtomicStampedReference<>(100,1);
//这里有严重的注意点,new的值不能大于127
        int stamp = AtomicReference.getStamp();
        new Thread(()->{
            System.out.println("a1=>"+stamp);//输出版本号
            try {
                TimeUnit.SECONDS.sleep(1);//两个线程同时休眠2s,这样的话保证两个线程获取的的版本号是同一个.
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(AtomicReference.compareAndSet(100, 101, AtomicReference.getStamp(), AtomicReference.getStamp() + 1));
            System.out.println("a2=>"+AtomicReference.getStamp());//输出版本号

            System.out.println(AtomicReference.compareAndSet(101, 100, AtomicReference.getStamp(), AtomicReference.getStamp() + 1));
            System.out.println("a3=>"+AtomicReference.getStamp());//输出版本号


        },"a").start();


        new Thread(()->{
            System.out.println("b1=>"+AtomicReference.getStamp());//输出版本号
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(AtomicReference.compareAndSet(100, 111,stamp, AtomicReference.getStamp() + 1));
            System.out.println("b3=>"+AtomicReference.getStamp());//输出版本号


        },"b").start();
        
        

    }
}

结果为

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DbJleEHI-1630342824662)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210829015912499.png)]

跟乐观锁的原理是一样的

各种锁

公平锁和非公平锁

3h->3s

公平锁:非常公平,不能插队,必须先来后到!3h->3s

非公平锁:非常不公平,可以插队,可以允许时间短的先执行3s->3h(默认都是非公平锁)看前文Lock介绍。

可重入锁

可重入锁(递归锁)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ywxavjQv-1630342824664)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210829020818799.png)]

相当于一个房子,有了大门钥匙,进入房间,就可以进入里面各个卧室

可重入锁也就是,某个线程已经获取某个锁,可以再次获取锁而不会出现死锁

package com.example.demo.lock;

import java.util.concurrent.TimeUnit;

public class Demo {

    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(()->{
            phone.call();
        },"a").start();

        new Thread(()->{
            phone.call();
        },"b").start();

    }

}
class Phone{
    public synchronized void call()  {
        System.out.println(Thread.currentThread().getName()+"->打电话");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        ems();//里面也有锁
    }
    public synchronized void ems(){
        System.out.println(Thread.currentThread().getName()+"->发短信");
    }

}

package com.example.demo.lock;

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

public class Demo1 {

    public static void main(String[] args) {
        Phone1 phone = new Phone1();

        new Thread(()->{
            phone.call();
        },"a").start();

        new Thread(()->{
            phone.call();
        },"b").start();

    }

}
class Phone1{
    Lock lock =new ReentrantLock();
    public  void call()  {
        lock.lock();//lock锁必须配置不然就要死在里面
        try {
            System.out.println(Thread.currentThread().getName()+"->打电话");
            ems();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public  void ems(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"->发短信");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

自旋锁

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-P0djUpaE-1630342824666)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210829010348080.png)]

package com.example.demo.lock;

import java.util.concurrent.atomic.AtomicReference;
/**
 *  自旋锁
 */
public class SpinlockDemo {
    //默认为null
    AtomicReference<Thread> atomicReference =new AtomicReference<>();
    //加锁
    public void myLock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"=> myLock");
        //自旋锁
        while(!atomicReference.compareAndSet(null,thread)){//如果atomicReference为null就加锁,停止循环.如果不为null,就一直循环
        }
    }
    //解锁
    public void myUnLock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"=> myUnLock");
        atomicReference.compareAndSet(thread,null);
    }
}

package com.example.demo.lock;

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

public class SpinlockDemo2 {

    public static void main(String[] args) throws InterruptedException {
//        ReentrantLock reentrantLock = new ReentrantLock();
//        reentrantLock.lock();
//        reentrantLock.unlock();
        //底层使用自旋锁
        SpinlockDemo lock = new SpinlockDemo();

        new Thread(()->{
            lock.myLock();
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.myUnLock();
            }
        },"T1").start();

        TimeUnit.SECONDS.sleep(1);//让t1先执行

        new Thread(()->{
            lock.myLock();
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.myUnLock();
            }
        },"T2").start();
    }

}

死锁

out.println(Thread.currentThread().getName()+"->打电话");
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
ems();//里面也有锁
}
public synchronized void ems(){
System.out.println(Thread.currentThread().getName()+"->发短信");
}

}

```java
package com.example.demo.lock;

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

public class Demo1 {

    public static void main(String[] args) {
        Phone1 phone = new Phone1();

        new Thread(()->{
            phone.call();
        },"a").start();

        new Thread(()->{
            phone.call();
        },"b").start();

    }

}
class Phone1{
    Lock lock =new ReentrantLock();
    public  void call()  {
        lock.lock();//lock锁必须配置不然就要死在里面
        try {
            System.out.println(Thread.currentThread().getName()+"->打电话");
            ems();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public  void ems(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"->发短信");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

}

自旋锁

[外链图片转存中…(img-P0djUpaE-1630342824666)]

package com.example.demo.lock;

import java.util.concurrent.atomic.AtomicReference;
/**
 *  自旋锁
 */
public class SpinlockDemo {
    //默认为null
    AtomicReference<Thread> atomicReference =new AtomicReference<>();
    //加锁
    public void myLock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"=> myLock");
        //自旋锁
        while(!atomicReference.compareAndSet(null,thread)){//如果atomicReference为null就加锁,停止循环.如果不为null,就一直循环
        }
    }
    //解锁
    public void myUnLock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"=> myUnLock");
        atomicReference.compareAndSet(thread,null);
    }
}

package com.example.demo.lock;

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

public class SpinlockDemo2 {

    public static void main(String[] args) throws InterruptedException {
//        ReentrantLock reentrantLock = new ReentrantLock();
//        reentrantLock.lock();
//        reentrantLock.unlock();
        //底层使用自旋锁
        SpinlockDemo lock = new SpinlockDemo();

        new Thread(()->{
            lock.myLock();
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.myUnLock();
            }
        },"T1").start();

        TimeUnit.SECONDS.sleep(1);//让t1先执行

        new Thread(()->{
            lock.myLock();
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.myUnLock();
            }
        },"T2").start();
    }

}

死锁