Java-JUC篇

JUC

JUC是java.util .concurrent工具包的简称

线程和进程

• 进程：一个程序，例如QQ.exe Music.exe 程序；

• 一个线程默认有2个线程：main线程（主线程）和GC线程（垃圾回收）

• java并不能开启线程，因为java运行在虚拟机之上，不能直接调用硬件，通过调用本地方法（native）开启线程。

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

• 并发：多线程操作统一资源。CPU一核，通过快速切换线程，实现线程的并发执行。

• 并行：CPU多核，多个线程可以同时执行。

//获取CPU的核数
System.out.Println(Runtime.getRuntime().availableProcessors());

• 线程的6种状态：创建(NEW)、RUNNABLE(运行)、BLOCKED(阻塞)、WAITING(等待)、TIMED_WAITING(超时等待)、TERMINATED(终止)

wait和sleep的区别

1.所属的类不同：wait属于Object, sleep属于Thread

2.锁的释放：wait会释放锁，sleep不会释放锁

3.使用的范围不同：wait在同步代码块和同步方法中，sleep没有范围的限制

Lock锁

Synchronized

public class SynchronizedTest {

    public static void main(String[] args) {

        Ticket ticket = new Ticket();
        new Thread(()-> {for (int i = 0; i < 40; i++) { ticket.saleTicket();}},"A").start();
        new Thread(()-> {for (int i = 0; i < 40; i++) { ticket.saleTicket();}},"B").start();
        new Thread(()-> {for (int i = 0; i < 40; i++) { ticket.saleTicket();}},"C").start();
    }

}

/**
 * 公司使用多线程开发时，线程就是一个单独的资源类，
 * 没有任何附属的操作，从而降低耦合性
 *
 */
class Ticket
{
    private int tickets = 60;
    //卖票
    public synchronized void saleTicket()
    {
         if(tickets > 0){
             System.out.println(Thread.currentThread().getName()+"买了第"+tickets+"张票"+"剩余票数："+ --tickets);
         }
    }
}

Lock接口

• 所有实现类：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7UyU7a9E-1603071924216)(C:\Users\yxz\AppData\Roaming\Typora\typora-user-images\image-20200927193530376.png)]

• 在ReentranLock类中可以设置公平锁（先来后到）和非公平锁（可以插队–默认）

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

public class ReentranLockTest {

    public static void main(String[] args) {

        TicketClass ticket = new TicketClass();
        new Thread(()-> {for (int i = 0; i < 40; i++) { ticket.saleTicket();}},"A").start();
        new Thread(()-> {for (int i = 0; i < 40; i++) { ticket.saleTicket();}},"B").start();
        new Thread(()-> {for (int i = 0; i < 40; i++) { ticket.saleTicket();}},"C").start();
    }
}

/**
 * 资源类
 */
class TicketClass
{
    private int tickets = 60;
    Lock lock = new ReentrantLock();
    //卖票
    public  void saleTicket()
    {
        //加锁
        lock.lock();
        try {
            if(tickets > 0){
                System.out.println(Thread.currentThread().getName()+"买了第"+tickets+"张票"+"剩余票数："+ --tickets);
            }
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally {
            //释放锁
            lock.unlock();
        }
    }
}

Synchronized和Lock的区别

• Synchronized 内置的Java关键字， Lock 是一个Java类
• Synchronized 无法判断获取锁的状态，Lock 可以判断是否获取了锁
• Synchronized 会自动释放锁，Lock 必须要手动释放锁，如果不释放锁，有可能造成死锁
• Synchronized中的线程 1获得了锁但进入阻塞态，此时线程2会一直等待下去；在Lock锁中线程不一定会等待
• Synchronized和Lock锁都是可重入锁。Synchronized不可以中断，非公平锁。Lock锁可以设置是否为公平锁并且可以判断是否获得了锁
• Synchronized 适合锁少量的代码同步问题，Lock 适合锁大量的同步代码

生产者和消费者问题

Synchronized处理生产者和消费者问题

public class SynProCon {

    public static void main(String[] args) {

       ProCon proCon = new ProCon();
       new Thread(()->{for (int i = 0; i < 40; i++) {proCon.Produce();}},"A").start();
       new Thread(()->{for (int i = 0; i < 40; i++) {proCon.Consume();}},"B").start();
    }

}

/*
* 判断等待-->业务-->通知
*/
class ProCon{

    private int number = 0;

    //生产商品
    public synchronized void Produce(){
        if(number != 0){
            try {
                //等待
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"生产完成");
        this.notifyAll();
    }
    //消费商品
    public synchronized void Consume(){
        if(number == 0){
            try {
                //等待
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"消费完成");
        this.notifyAll();
    }

}

当有两个或者两个以上的生产者（消费者）会存在虚假唤醒----number的会出现大于1的情况。

解决方法：线程的等待要在循环中，而不是for中

 while(number == 0){
            try {
                //等待
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

JUC处理生产者和消费者问题

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

public class LockContionTest {

    public static void main(String[] args) {

        ProConClass proCon = new ProConClass();
        new Thread(()->{for (int i = 0; i < 40; i++) {proCon.Produce();}},"A").start();
        new Thread(()->{for (int i = 0; i < 40; i++) {proCon.Consume();}},"B").start();
    }
}

/*
 * 判断等待-->业务-->通知
 */
class ProConClass{

    private int number = 0;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    //生产商品
    public void Produce(){
        try {
            lock.lock();
            while(number != 0){
                //等待
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName()+"生产完成");
            condition.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }
        finally {
            lock.unlock();
        }
    }

    //消费商品
    public void Consume(){
        try {
            lock.lock();
            while(number == 0){
                //等待
                condition.await();
            }
            number--;
            System.out.println(Thread.currentThread().getName()+"消费完成");
            condition.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }
        finally {
            lock.unlock();
        }
    }
}

Condition可以准确的唤醒某个线程或者让某个线程等待

例：A、B、C三个线程按顺序执行 A–>B–>C

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

public class ThreadOrderExe {

    public static void main(String[] args) {

        Model  model = new Model();
        new Thread(()->{for (int i = 0; i < 40; i++) model.PrintA();},"A").start();

        new Thread(()->{for (int i = 0; i < 40; i++) {model.PrintB();}},"B").start();

        new Thread(()->{for (int i = 0; i < 40; i++) {model.PrintC();}},"C").start();

    }
}

/*
 * 判断等待-->业务-->通知
 */
class Model{

    private int number = 1;
    Lock lock = new ReentrantLock();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();

    //打印A
    public void PrintA(){
        lock.lock();
        try{
            if(number != 1){
                condition1.await();
            }
            System.out.println("AAAAAAAAAAAAAAAA");
            number = 2;
            condition2.signal();
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally {
            lock.unlock();
        }
    }
    //打印B
    public void PrintB(){
        lock.lock();
        try{
            if(number != 2){
                condition2.await();
            }
            System.out.println("BBBBBBBBBBBBBBB");
            number = 3;
            condition3.signal();
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally {
            lock.unlock();
        }
    }
    //打印C
    public void PrintC(){
        lock.lock();
        try{
            if(number != 3){
                condition3.await();
            }
            System.out.println("CCCCCCCCCCCCCCCCCCCCC");
            number = 1;
            condition1.signal();
        }
        catch(Exception e){
            e.printStackTrace();
        }
        finally {
            lock.unlock();
        }
    }

}

8锁现象

synchronized 锁的对象是方法的调用者！

1.先发短信，再打电话

2.先发短信，再打电话

import java.util.concurrent.TimeUnit;
/**
 * 8锁，就是关于锁的8个问题
 * 1、标准情况下，两个线程先打印 发短信还是 打电话？ 1/发短信 2/打电话
 * 2、sendSms延迟4秒，两个线程先打印 发短信还是 打电话？ 1/发短信 2/打电话
 */
public class Test1 {
    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("打电话");
    }
}

3.先Hello，再短信

4.先打电话，在发短信

import java.util.concurrent.TimeUnit;
/**
 * 3、 增加了一个普通方法后！先执行发短信还是Hello？ 普通方法
 * 4、 两个对象，两个同步方法， 发短信还是 打电话？ // 打电话
 */
public class Test2 {
    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(){
        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");
    }
}

5.先发短信，在打电话

6.先发短信，在打电话

import java.util.concurrent.TimeUnit;
/**
 * 5、增加两个静态的同步方法，只有一个对象，先打印 发短信？打电话？
 * 6、两个对象！增加两个静态的同步方法， 先打印 发短信？打电话？
 */
public class Test3 {
    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(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public static synchronized void call(){
        System.out.println("打电话");
    }
}

7.先打电话，在发短信

8…先打电话，在发短信

package com.kuang.lock8;
import java.util.concurrent.TimeUnit;
/**
 * 7、1个静态的同步方法，1个普通的同步方法 ，一个对象，先打印 发短信？打电话？
 * 8、1个静态的同步方法，1个普通的同步方法 ，两个对象，先打印 发短信？打电话？
 */
public class Test4 {
    public static void main(String[] args) {
// 两个对象的Class类模板只有一个，static，锁的是Class
        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();
//锁的存在
        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 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("打电话");
    }

集合类不安全

List不安全

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

public class ListUnsafeTest {

    public static void main(String[] args) {

        //多线程操作List集合时，导致List不安全:java.util.ConcurrentModificationException
//        List<String> list = new ArrayList<>();

        //1.解决方案1
//      List<String> list = new Vector<>();

        //解决方案二
//        List<String> list = Collections.synchronizedList(new ArrayList<>());

        //解决方案三
        List<String> list = new CopyOnWriteArrayList<>();

        for (int i = 1; i <= 6; i++) {
            new Thread(()->{
                list.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(list);
            },String.valueOf(i)).start();

        }
        
    }
}

• Vector方案效率不如CopyOnWriteArrayList，因为Vector的add方法用Synchronized修饰
• CopyOnWriteArrayList为写入时复制，COW是计算机设计领域的一种优化策略

set不安全

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

public class SetUnsafeTest {

    public static void main(String[] args) {

        //Set<String> set = new HashSet<>();

        //解决方案1：
       //Set<String> set = Collections.synchronizedSet(new HashSet<>());
        //解决方案2：
        Set<String> set = new CopyOnWriteArraySet<>();

        for (int i = 1; i <= 6; i++) {
            new Thread(()->{
                set.add(UUID.randomUUID().toString().substring(0,5));
                System.out.println(set);
            },String.valueOf(i)).start();

        }
    }
}

• HashSet底层是HashMap，add set 本质是map key 是无法重复的

Map不安全

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

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

        //Map不安全
//        Map<String,String> map = new HashMap<>();
        //解决方案
        Map<String,String> map = new ConcurrentHashMap<>();
        for (int i = 1; i <= 6; i++) {
            new Thread(()->{
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
                System.out.println(map);
            },String.valueOf(i)).start();
        }
   }
}

• 工作中一般不用HashMap,默认等价于new HashMap<>(16,0.75)

Callable

• 与runnable的区别：可以有返回值，可以抛出异常，方法不同call()

  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 integer = (Integer) futureTask.get();
          System.out.println(integer);
      }
  }
  
  class MyThread implements Callable<Integer>{
      @Override
      public Integer call()  {
  
          System.out.println(Thread.currentThread().getName()+"call()");
          return 1024;
      }
  }
  

  常用的辅助类

countDownLatch: 只有计数结束后，才往下执行

import java.util.concurrent.CountDownLatch;

public class CountDownLatchTest {

    public static void main(String[] args) throws InterruptedException {
        //定义CountDownLatch
        CountDownLatch count = new CountDownLatch(6);

        for (int i = 1; i <= 6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+" go out");
                //减一操作
                count.countDown();
            },String.valueOf(i)).start();
        }
        //等待计数器减为0
        count.await();
        System.out.println("close door");
    }
}

CyclicBarrier: 加法计算器

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

public class CyclicBarrierTest {

    public static void main(String[] args){
        
        //加法计算器
        CyclicBarrier cyclicBarrier = new CyclicBarrier(6,()->{
            System.out.println("执行完成");
        });
         
        for (int i = 1; i <= 6; i++) {
            
            final int temp = i;
            new Thread(()->{
                System.out.println("当前累积计数:"+ temp);
                //累积完成，执行剩余任务
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

Semaphore: 信号量，多个共享资源互斥的使用，并发限流，控制最大的线程数

Semaphore.acquire( ): 获得信号量，假设信号量为0，线程等待直至其它线程释放信号量为止。

Semaphore.release( ): 释放信号量，唤醒等待的线程

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

public class SemaphoreTest {

    public static void main(String[] args) {
        //定义信号量个数
        Semaphore semaphore = new Semaphore(3);

        for (int i = 1; i <= 6; i++) {
            new Thread(()->{

                try {
                    //获取信号量
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + "抢到车位");
                    //休息2s
                    TimeUnit.SECONDS.sleep(2);

                    System.out.println(Thread.currentThread().getName()+"离开车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                finally {
                    //释放信号量
                    semaphore.release();
                }
            },String.valueOf(i)).start();
        }
    }
}

读写锁

ReadWriteLock：实现类ReentrantReadWriteLock，读可以被多线程同时读，写的时候只能有一个线程去写。

import java.sql.Time;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockTest {

    public static void main(String[] args) {

        MyCache cache = new MyCache();
        final int temp = 1;

        //10个写线程
        for (int i = 1; i <= 10; i++) {
            new Thread(()->{
                try {
                    cache.put("Thread", temp);

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }

        //10个读线程
        for (int i = 1; i <= 10; i++) {
            new Thread(()->{
                cache.get("Thread");

            },String.valueOf(i)).start();
        }
    }
}

/**
 * 自定义缓存
 */
class MyCache{

    private volatile Map<String,Object> map = new HashMap<>();
    //定义读写类
    ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

    //存储数据:写线程不能同时进行
    public void put(String key, int value) throws InterruptedException {
        readWriteLock.writeLock().lock();
        System.out.println(Thread.currentThread().getName()+":正在存储数据");
        map.put(key,value);
        TimeUnit.SECONDS.sleep(1);
        System.out.println(Thread.currentThread().getName()+":数据存储成功");
        readWriteLock.writeLock().unlock();
    }

    //读取数据：读写线程不能同时进行，读线程可以同时进行
    public void get(String key){

        readWriteLock.readLock().lock();
        System.out.println(Thread.currentThread().getName()+":正在读取数据");
        Object data = map.get(key);
        System.out.println(Thread.currentThread().getName()+":数据读取成功");
        readWriteLock.readLock().unlock();
    }
}

BlockingQueue----使用场景：多线程并发操作和线程池

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

• 队列添加和移除：四组API

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

add方法中，如果队列已满，抛出 IllegalStateException: Queue full异常

remove方法中，如果为空队列，抛出java.util.NoSuchElementException异常

offer方法中。如果队列未满，返回true。如果对列已满，返回false,不抛出异常

poll方法中，如果队列未空，返回true。如果对列已空，返回null,不抛出异常

offer(“d”,2,TimeUnit.SECONDS) – 等待超过2秒就退出

SynchronousQueue 同步队列:没有容量，放一个元素，必须取出来之后，才能放下一个元素

import jdk.nashorn.internal.ir.Block;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;

public class SynchronousQueueTest {

    public static void main(String[] args) {

        //定义同步队列
        BlockingQueue<String> queue = new SynchronousQueue<>();

        new Thread(()->{

            try {
                System.out.println(Thread.currentThread().getName()+"put 1");
                queue.put("1");
                System.out.println(Thread.currentThread().getName()+"put 2");
                queue.put("2");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"P1").start();

        new Thread(()->{

            try {

                TimeUnit.SECONDS.sleep(2);
                System.out.println(Thread.currentThread().getName()+"take" + queue.take());
                TimeUnit.SECONDS.sleep(2);
                System.out.println(Thread.currentThread().getName()+"take" + queue.take());

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

}

线程池（重点）

线程池：三大方法，7大参数，4种拒绝策略

池化技术：优化资源的使用

线程池的好处：

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

4、线程复用、可以控制最大并发数、管理线程

线程池的三大方法：

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

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

public class ThreadPoolTest {

    public static void main(String[] args) {

        //线程池三大方法
        //方法一: 单个线程
        ExecutorService service = Executors.newSingleThreadExecutor();
        //方法二: 创建固定大小的线程池
//        ExecutorService service = Executors.newFixedThreadPool(6);
        //方法三：创建动态大小的线程池
//        ExecutorService service = Executors.newCachedThreadPool();

        for (int i = 1; i <= 20; i++) {
            service.execute(()->{
                System.out.println(Thread.currentThread().getName()+"ok");
            });
        }

        //执行完成，关闭线程池
        service.shutdown();
    }
}

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-yKZTT5uK-1603071924227)(C:\Users\yxz\AppData\Roaming\Typora\typora-user-images\image-20201013190855948.png)]

4大拒绝策略：

new ThreadPoolExecutor.AbortPolicy() // 银行满了，还有人进来，不处理这个人的，抛出异常
new ThreadPoolExecutor.CallerRunsPolicy() // 哪来的去哪里！
new ThreadPoolExecutor.DiscardPolicy() //队列满了，丢掉任务，不会抛出异常！
new ThreadPoolExecutor.DiscardOldestPolicy()//队列满了，尝试去和最早任务竞争，不会抛出异常！

创建线程池

import java.util.concurrent.*;

public class ThreadPoolDemo {

    public static void main(String[] args) {

        //自定义线程池
        ExecutorService service = new ThreadPoolExecutor(
                2,
                5,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardOldestPolicy() // 若队列已满，尝试最早任务竞争，不会抛出异常
        );

        for (int i = 1; i <= 10; i++) {
            service.execute(()->{
                System.out.println(Thread.currentThread().getName()+"ok");
            });
        }
        //关闭线程池
        service.shutdown();
    }
}

设置线程池的大小

1. CPU 密集型：电脑几核，线程池的数量就设置为几，可以保证CPU的效率最高！
2. IO 密集型 ： 判断程序中十分耗IO的线程（线程池中线程的大小可设置为耗IO的线程的两倍）

import java.util.concurrent.*;

public class ThreadPoolDemo {

    public static void main(String[] args) {

        //自定义线程池
        ExecutorService service = new ThreadPoolExecutor(
                2,
                Runtime.getRuntime().availableProcessors(),
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardOldestPolicy() // 若队列已满，尝试与其它元素竞争，不会抛出异常
        );

        for (int i = 1; i <= 10; i++) {
            service.execute(()->{
                System.out.println(Thread.currentThread().getName()+"ok");
            });
        }
        //关闭线程池
        service.shutdown();
    }
}

四大函数式接口（必须掌握）

新时代的程序员：lambda表达式、链式编程、函数式接口、Stream流式计算

函数式接口：只有一个方法的接口

**四大函数式接口：**Consumer, Function, predicate, Supplier

Function函数式接口: 接口中只有一个未实现的方法

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

import java.util.function.Function;

public class FunctionInterfaceTest {

    public static void main(String[] args) {

        Function<String,String> function = (str)->{
            return  str;
        };

        System.out.println(function.apply("wy"));
    }
}

Predicate：断定型接口，有一个输入参数，返回值是布尔值

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

判断字符串是否为空：

public class Demo02 {
    public static void main(String[] args) {
    // 判断字符串是否为空
    // Predicate<String> predicate = new Predicate<String>(){
     @Override
     public boolean test(String str) {
     return str.isEmpty();
     }
     };
    Predicate<String> predicate = (str)->{return str.isEmpty(); };
    System.out.println(predicate.test(""));
    }
}

Consumer：消费型接口

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

import java.util.function.Consumer;
    /**
    * Consumer 消费型接口: 只有输入，没有返回值
    */
    public class Demo03 {
    public static void main(String[] args) {
    // Consumer<String> consumer = new Consumer<String>() {
    // @Override
    // public void accept(String str) {
    // System.out.println(str);
    // }
    // };
    Consumer<String> consumer = (str)->{System.out.println(str);};
    consumer.accept("sdadasd");
    }
}

Supplier：供给型接口

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

/**
* Supplier 供给型接口 没有参数，只有返回值
*/
public class Demo04 {
public static void main(String[] args) {
    // Supplier supplier = new Supplier<Integer>() {
    // @Override
    // public Integer get() {
    // System.out.println("get()");
    // return 1024;
    // }
    // };
    Supplier supplier = ()->{ return 1024; };
    System.out.println(supplier.get());
    }
}

Stream流式计算

题目要求：一分钟内完成此题，只能用一行代码实现！

题目：从6个用户中筛选满足条件的用户

1.ID 必须是偶数

2.年龄必须大于24岁

3.用户名转为大写字母

4.用户名字母倒着排序

5.只输出一个用户

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class StreamDemo {

    public static void main(String[] args) {

        //定义6个用户
        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);
        User user6 = new User(6,"f",26);

        //定义用户列表
        List<User> user =  Arrays.asList(user1,user2,user3,user4,user5,user6);//数组转化为列表
        //Stream负责计算操作
        user.stream()
                .filter((u)->{return u.getID()%2 == 0;})
                .filter((u)->{return u.getAge() > 23;})
                .map((u)->{return u.getName().toUpperCase();})
                .sorted((u1,u2)->{return u2.compareTo((u1));})
                .limit(1)
                .forEach(System.out::println);
    }

}

class User{

    private int ID;
    private String name ;
    private int age;

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

三种方法比较：实现累积求和

import java.util.concurrent.RecursiveTask;

public class ForkJoinDemo extends RecursiveTask<Long> {

    private long start;
    private long end;

    public ForkJoinDemo(long start, long end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
        long sum = 0;
        long temp = 0;

        temp = end - start;
        if(temp <= 1000){
            for (; start <= end; start++) {
                sum = sum + start;
            }
            return sum;
        }
        else{
            long middle = (start + end) /2;
            ForkJoinDemo demo1 = new ForkJoinDemo(start , middle);
            demo1.fork(); //拆分任务并压入线程队列
            ForkJoinDemo demo2 = new ForkJoinDemo(middle+1 , end);
            demo2.fork(); //拆分任务并压入线程队列
            return  demo1.join() + demo2.join();
        }

    }
}

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.stream.LongStream;

public class ForkJoinTest {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        //方法一
        ForkJoinTest.test1(0,1000000000);
        //方法二
        ForkJoinTest.test2(0,1000000000);
        //方法三
        ForkJoinTest.test3(0,1000000000);

    }

    /**
     * 普通累积求和方法
     * @param start
     * @param end
     */
    public static void test1(long start,long end){

        long startTime = System.currentTimeMillis();
        long sum = 0;
        for (long i = start; i <= end; i++) {
            sum = sum + i;
        }
        long endTime = System.currentTimeMillis();
        System.out.println("执行时间："+ (endTime-startTime) +"------>"+sum);
    }

    /**
     * ForkJoin方法实现累积求和
     * @param start
     * @param end
     */
    public static void test2(long start,long end) throws ExecutionException, InterruptedException {

        long startTime = System.currentTimeMillis();
        long sum = 0;

        ForkJoinPool pool = new ForkJoinPool();
        ForkJoinTask<Long> task = new ForkJoinDemo(start,end);
        ForkJoinTask<Long> submit = pool.submit(task);
        sum = submit.get();
        long endTime = System.currentTimeMillis();
        System.out.println("执行时间："+ (endTime-startTime) +"------>"+sum);
    }

    /**
     * Stream流计算实现累积求和
     * @param start
     * @param end
     */
    public static void test3(long start,long end){

        long startTime = System.currentTimeMillis();
        long sum = LongStream.rangeClosed(start,end).parallel().reduce(start,Long::sum);
        long endTime = System.currentTimeMillis();
        System.out.println("执行时间："+ (endTime-startTime) +"------>"+sum);
    }
}

异步回调

异步调用：CompletableFuture

1.异步执行

2.成功回调

3.失败回调

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

public class CompletableFutureDemo {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

//        CompletableFutureDemo.syncRun();
        CompletableFutureDemo.syncRunWithValue();
    }

    /**
     * 没有返回值的异步回调---->runAsync
     */
    public  static  void syncRun() throws ExecutionException, InterruptedException {
        CompletableFuture<Void> future = CompletableFuture.runAsync(()->{
            try {
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        System.out.println("线程继续执行");
        future.get(); // 阻塞等待结果
    }

    /**
     * 有返回值的异步回调
     */
    public static void syncRunWithValue()
    {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(()->{

            int i = 10/0;
            return 404;
        });

        try {
            System.out.println(future.whenComplete((t,u)->{

                System.out.println("正常的返回结果："+t);
                System.out.println("错误的返回结果："+u);

            }).exceptionally((e)->{
                System.out.println(e.getMessage());
                return 233;
                    }).get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

JMM

Volatile

1.保证可见性

2.不保证原子性

3.禁止指令重排

JMM：Java内存模型，是一种约定概念并不真实存在。

1.线程解锁前，必须把共享变量立刻刷回主存。

2.线程加锁前，必须读取主存中的最新值到工作内存中。

3.加锁和解锁是同一把锁

线程、工作内存和主内存关系图

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

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

• lock （锁定）：作用于主内存的变量，把一个变量标识为线程独占状态

• unlock （解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量
  才可以被其他线程锁定

• read （读取）：作用于主内存变量，它把一个变量的值从主内存传输到线程的工作内存中，以便
  随后的load动作使用

• load （载入）：作用于工作内存的变量，它把read操作从主存中变量放入工作内存中

• use （使用）：作用于工作内存中的变量，它把工作内存中的变量传输给执行引擎，每当虚拟机
  遇到一个需要使用到变量的值，就会使用到这个指令

• assign （赋值）：作用于工作内存中的变量，它把一个从执行引擎中接受到的值放入工作内存的变
  量副本中

• store （存储）：作用于主内存中的变量，它把一个从工作内存中一个变量的值传送到主内存中，
  以便后续的write使用

• write （写入）：作用于主内存中的变量，它把store操作从工作内存中得到的变量的值放入主内
  存的变量中

JMM对这八种指令的使用，制定了如下规则:

• 不允许read和load、store和write操作之一单独出现。即使用了read必须load，使用了store必须
  write
• 不允许线程丢弃他最近的assign操作，即工作变量的数据改变了之后，必须告知主存
• 不允许一个线程将没有assign的数据从工作内存同步回主内存
• 一个新的变量必须在主内存中诞生，不允许工作内存直接使用一个未被初始化的变量。就是怼变量
  实施use、store操作之前，必须经过assign和load操作
• 一个变量同一时间只有一个线程能对其进行lock。多次lock后，必须执行相同次数的unlock才能解
  锁
• 如果对一个变量进行lock操作，会清空所有工作内存中此变量的值，在执行引擎使用这个变量前，
  必须重新load或assign操作初始化变量的值
• 如果一个变量没有被lock，就不能对其进行unlock操作。也不能unlock一个被其他线程锁住的变量
• 对一个变量进行unlock操作之前，必须把此变量同步回主内存

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

Volatile

保证可见性

import java.util.concurrent.TimeUnit;

public class VolatileDemo {

      //不加volatile修饰符，程序会死循环
     //加volatile可以保证可见性

    public volatile static int num = 0;

    public static void main(String[] args) {

        new Thread(()->{        //该线程对主内存的变化不清楚
            while(num == 0){

            }
        }).start();

        try {

            TimeUnit.SECONDS.sleep(2);
            num = 1;
            System.out.println(num);

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

不保证原子性

原子性：操作不可分割

线程A在执行任务的时候，不能被中断，也不能被分割。要么同时成功，要么同时失败。

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

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

    public static void add(){
        num++;   
    }
}

在不加lock和synchronized的情况下，使用原子类解决原子性问题

import java.util.concurrent.atomic.AtomicInteger;

public class VolatileDemo3 {

    //原子类的Integer
    private volatile static AtomicInteger num = new AtomicInteger();

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

    public static void add(){

        num.getAndIncrement(); //原子类加1操作
    }

}

指令重排：程序并不是按照写的顺序执行

源代码–>编译器优化的重排–> 指令并行也可能会重排–> 内存系统也会重排—> 执行

处理器在进行指令重排时，考虑数据之间的依赖性

int x = 1; // 1
int y = 2; // 2
x = x + 5; // 3
y = x * x; // 4
我们所期望的：1234 但是可能执行的时候回变成 2134 1324
可不可能是 4123！

线程A	线程B
x = a	y = b
b = 1	a =2

正常的结果： x = 0；y = 0；但是可能由于指令重排

线程A	线程B
b = 1	a = 2
x =a	y = b

指令重排导致的诡异结果： x = 2；y = 1；

volatile可以通过内存屏障避免指令重排
作用：
1、保证特定的操作的执行顺序！
2、可以保证某些变量的内存可见性 （利用这些特性volatile实现了可见性）

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

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

玩转单列模式

饿汉式

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

DCL懒汉式

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

public class LazyMan {

    private volatile static LazyMan lazyMan;
    private static boolean flag = false;

    private LazyMan(){

       synchronized (LazyMan.class){
           if(flag == false){
               flag = true;
           }
           else{
               throw new RuntimeException("不要试图使用反射破坏异常");
           }
       }
    }

    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 instance1 = LazyMan.getInstance();

        //使用反射
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan instance1 = declaredConstructor.newInstance();

        Field flag = LazyMan.class.getDeclaredField("flag");
        flag.setAccessible(true);
        flag.set(instance1,false);
        LazyMan instance2 = declaredConstructor.newInstance();
        System.out.println(instance1);
        System.out.println(instance2);
    }
}

静态内部类: 单例模式

import javax.xml.ws.Holder;

public class StaticInnerClassDemo {
    
    private StaticInnerClassDemo(){
        
    }
    
    public static StaticInnerClassDemo getInstance(){
        return InnerClass.demo;
    }
    
    public static class InnerClass{
        
        private static final StaticInnerClassDemo demo = new StaticInnerClassDemo(); 
    }
}

可以使用反射机制验证单例模式的不安全

枚举

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

public enum EnumDemo {

    INSTANCE;

    public EnumDemo getInstance(){
        return INSTANCE;
    }
}

class Test {

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {

        EnumDemo instance1 = EnumDemo.INSTANCE;
        Constructor<EnumDemo> demo = EnumDemo.class.getDeclaredConstructor(String.class,int.class);
        demo.setAccessible(true);
        EnumDemo instance2 = demo.newInstance();

        System.out.println(instance1);
        System.out.println(instance2);
        
    //抛出异常：Cannot reflectively create enum objects    
    }
}

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

反编译：jad -sjava EnumDemo.class 编译成java文件

深入理解CAS

CAS：只有设置的预期值达到了，才会去执行下面的操作

import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo {

    public static void main(String[] args) {

        AtomicInteger atomic = new AtomicInteger(2020);
        System.out.println(atomic.compareAndSet(2020,2021));
        System.out.println(atomic.get());

        atomic.getAndIncrement();
        System.out.println(atomic.compareAndSet(2020,2021));
        System.out.println(atomic.get());
    }
}

Unsafe类

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

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

CAS ： 比较当前工作内存中的值和主内存中的值，如果这个值是期望的，那么则执行操作！如果不是就
一直循环！

缺点：

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

CAS：ABA问题（狸猫换太子）

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

import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo1 {

    public static void main(String[] args) {

        AtomicInteger atomic = new AtomicInteger(2020);

        //捣乱线程
        System.out.println(atomic.compareAndSet(2020,2022));
        System.out.println(atomic.compareAndSet(2022,2020));

        //期望线程
        System.out.println(atomic.compareAndSet(2020,6666));
    }
}

原子引用，解决CAS中的ABA问题

带有版本号的原子操作：

import java.sql.SQLOutput;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicStampedReference;

public class CASABADemo {

    static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<>(1,1);

    public static void main(String[] args) {
        new Thread(()->{

            int stamp = atomicStampedReference.getStamp();//获得版本号
            System.out.println("版本号1：" + 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("版本号2："+atomicStampedReference.getStamp());
            System.out.println(atomicStampedReference.compareAndSet(2, 1, atomicStampedReference.getStamp(), atomicStampedReference.getStamp() + 1));
            System.out.println("版本号3："+atomicStampedReference.getStamp());
        }).start();

        new Thread(()->{

            int stamp = atomicStampedReference.getStamp();//获得版本号
            System.out.println("版本号4："+atomicStampedReference.getStamp());
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(atomicStampedReference.compareAndSet(1,6,stamp,stamp+1));
            System.out.println("版本号5："+atomicStampedReference.getStamp());

        }).start();
    }
}

各种锁的理解

公平锁和非公平锁

公平锁： 非常公平， 不能够插队，必须先来后到！
非公平锁：非常不公平，可以插队 （默认都是非公平）

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

可重入锁（递归锁）

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

Synchronized和Lock都可以实现可重入锁:

import java.sql.SQLOutput;

public class SynReenLock {

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

        new Thread(()->{
            phone.SMS();
        },"A").start();

        new Thread(()->{
            phone.SMS();
        },"B").start();

    }
}
class Phone{

    public synchronized  void SMS(){
        System.out.println(Thread.currentThread().getName() + "正在发信息中");
        call();
    }
    public synchronized void call(){
        System.out.println(Thread.currentThread().getName() + "正在打电话中");
    }
}

自旋锁

自定义自旋锁：

import java.util.concurrent.TimeUnit;

public class SpinLockTest {

    public static void main(String[] args) {

        SpinLockDemo spinLockDemo = new SpinLockDemo();

        new Thread(()->{
            spinLockDemo.myLock();
            try {
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            finally {
                spinLockDemo.unLock();
            }
        },"A").start();

        new Thread(()->{
            spinLockDemo.myLock();
            try{
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            finally {
                spinLockDemo.unLock();
            }
        },"B").start();
    } 
}

死锁

import java.util.concurrent.TimeUnit;

public class DeadLockDemo {

    public static void main(String[] args) {

        String lockA = "lockA";
        String lockB = "lockB";

        new Thread(new DeadThread(lockA,lockB),"T1").start();
        new Thread(new DeadThread(lockB,lockA),"T2").start();
    }
}

class DeadThread implements Runnable{

    private String lockA;
    private String lockB;

    public DeadThread(String lockA, String lockB) {
        this.lockA = lockA;
        this.lockB = lockB;
    }

    @Override
    public void run() {

        synchronized (lockA){
            System.out.println(Thread.currentThread().getName()+"获得锁："+lockA+"----想要获得锁："+lockB);
            try {
                TimeUnit.SECONDS.sleep(6);
            } catch (InterruptedException e){
                e.printStackTrace();
            }
            synchronized (lockB){
                System.out.println(Thread.currentThread().getName()+"获得锁："+lockB);
            }
        }
    }
}

使用jps -l 定位进程号

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

使用jstack 进程号找到死锁问题

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

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