多线程进阶-JUC并发编程学习

最新推荐文章于 2022-06-15 15:48:23 发布

一个渣渣i

最新推荐文章于 2022-06-15 15:48:23 发布

阅读量217

点赞数

分类专栏： javase 文章标签： java 多线程

本文链接：https://blog.csdn.net/qq_45960397/article/details/109698467

版权

javase 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

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

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

解决办法; 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版的生产者消费者问题

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

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

$外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Dk03xMCd-1605367063421)(C:\Users\独白\AppData\Roaming\Typora\typora-user-images\image-20201109220318649.png)$

1,可以有返回值

2，可以跑出异常

3，方法不同，run（）、call（）

代码测试

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

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

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

$外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qRt8Q5ti-1605367063427)(C:\Users\独白\AppData\Roaming\Typora\typora-user-images\image-20201109224003960.png)$

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

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

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

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

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，阻塞队列

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

阻塞队列

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

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

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

什么情况下我们会使用队列：多线程并发处理，线程池！

学会使用队列

添加，移除

四组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;
    }

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

手动创建一个线程池和四种拒绝策略

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

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

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

举例 ||

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

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

代码测试并用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断定型接口

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

/**
 * 断定型接口：有一个输入参数，返回值只能是布尔值！
 */
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 消费者接口

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

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供给型接口

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

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 本质本质就是存东西的

计算都应该交给流来操作

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

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（把大任务拆分为小任务）

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

ForkJoin特点：工作窃取

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

$外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7S6j9eM6-1605367063438)(C:\Users\独白\AppData\Roaming\Typora\typora-user-images\image-20201112112741810.png)$

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

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

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

}

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

使用原子类解决原子性问题

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，死锁

两个线程自己拥有锁，同时想要拿到对方的锁。

一个渣渣i

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
多线程进阶-JUC并发编程学习

1，什么是JUCjava。util工具包业务：普通的线程代码 ThreadRunnable 没有返回值，效率相比Callable相对较低2，线程和进程进程：一个程序，QQ.exe Music.exe程序的集合：一个进程往往可以包含多个线程，至少包含一个！java默认有几个线程：两个，main GC线程：开了一个进程：功能由线程实现线程的五种状态：新建，可运行，运行，阻塞，死亡。并发，并行并发编程：并发，并行并发（多线程操作同一个资源）CPU一核，模拟出来多条线程，快速交
复制链接

扫一扫