JUC

2024-03-22 21:01:52

JUC

什么是JUC
lock锁
生产者和消费者问题
- synchronized版
- JUC版
- condition精准的通知唤醒线程
8锁现象
集合类不安全
Callable
常用的辅助类
读写锁 ReadWriteLock
阻塞队列
线程池
四大函数型接口
Stream流式计算
ForkJoin
异步回调
JMM
Volatile
单例模式
深入理解CAS
原子引用
可重入锁（递归锁）
自旋锁（spinlock）
死锁

什么是JUC

lock锁

公平锁：十分公平，可以先来后到
非公平锁：十分不公平，可以插队（默认）
Synchronized和Lock区别

Synchronized内置的java关键字，Lock是一个java类
Synchronized无法判断获取锁的状态，Lock可以判断是否获取到了锁
Synchronized会自动释放锁，lock必须要手动释放锁！如果不释放锁，死锁
Synchronized线程1（获取锁，阻塞）、线程2（等待）；Lock锁不一定会等待下去
Synchronized可重入锁，不可以中断，非公平；Lock，可重入锁，可以判断锁，非公平（可自己设置）
Synchronized适合锁少量的代码同步问题，Lock适合锁大量的同步代码

生产者和消费者问题

synchronized版

package pc;

/**
 * 线程之间的通信问题：生产者消费者问题 等待唤醒
 *线程交替执行 A B操作同一个变量 num=0
 * A：num+1
 * B：num-1
 */
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;
    //+1
    public synchronized void increment() throws InterruptedException {
        if(number!=0){
            //等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"=>"+number);
        //通知其他线程，+1完毕
        this.notifyAll();
    }


    //-1
    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、D4个线程！虚假唤醒

if改为while判断

JUC版

package pc;

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

public class B {
    public static void main(String[] args) {
        Data2 data=new Data2();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    data.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }


}
//等待、业务、通知
class Data2{//资源类
    private int number=0;
    Lock lock=new ReentrantLock();
    Condition condition = lock.newCondition();
//condition.await();等待
//condition.signalAll();唤醒全部
    //+1
    public  void increment() throws InterruptedException {
        lock.lock();
        try {
            //业务代码
            while (number!=0){
                //等待
                condition.await();
            }
            number++;
            System.out.println(Thread.currentThread().getName()+"=>"+number);
            //通知其他线程，+1完毕
            condition.signalAll();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }
    //-1
    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 (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }

}

condition精准的通知唤醒线程

package pc;

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

public class C {
    public static void main(String[] args) {
        Data3 data=new Data3();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data.printA();
            }
        },"A").start();
        new Thread(()->{ for (int i = 0; i < 10; i++) {
            data.printB();
        }},"B").start();
        new Thread(()->{ for (int i = 0; i < 10; i++) {
            data.printC();
        }},"C").start();
    }
}
class Data3{
    private Lock lock=new ReentrantLock();
    private Condition condition1=lock.newCondition();
    private Condition condition2=lock.newCondition();
    private Condition condition3=lock.newCondition();
    private int num=1;
    public void printA(){
        lock.lock();
        try {
            while (num!=1){
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>AAAAA");
            //唤醒B
            num=2;
            condition2.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }
    public void printB(){
        lock.lock();
        try {
            while (num!=2){
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>BBBBB");
            //唤醒C
            num=3;
            condition3.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void printC(){
        lock.lock();
        try {
            while (num!=3){
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>CCCCC");
            num=1;
            //唤醒A
            condition1.signal();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

8锁现象

1、标准情况下，打印两个线程首先打印send,在打印call

package lock8;

import java.util.concurrent.TimeUnit;

/**
* 8锁，关于锁的8个问题
* 1、标准情况下，打印两个线程 首先打印send,在打印call
* 
*/
public class Test1 {
   public static void main(String[] args) {
       Phone phone=new Phone();
       new Thread(()->{phone.send();},"A").start();
       try {
           TimeUnit.SECONDS.sleep(1);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       new Thread(()->{phone.call();},"B").start();
   }
}
class Phone{
   public synchronized void send(){
       System.out.println("send");
   }
   public synchronized void call(){
       System.out.println("call");
   }
}

2.send方法延迟4秒,打印两个线程首先打印send,在打印call
synchronized 锁的对象是方法的调用者
两个方法用的是同一个锁，谁先拿到谁先执行

package lock8;

import java.util.concurrent.TimeUnit;

/**
* 8锁，关于锁的8个问题
* 1、标准情况下，打印两个线程 首先打印send,在打印call
* 2.send延迟4秒
*/
public class Test1 {
   public static void main(String[] args) {
       Phone phone=new Phone();
       new Thread(()->{phone.send();},"A").start();
       try {
           TimeUnit.SECONDS.sleep(1);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       new Thread(()->{phone.call();},"B").start();
   }
}
class Phone{
   // synchronized 锁的对象是方法的调用者
   //两个方法用的是同一个锁，谁先拿到谁先执行
   public synchronized void send(){
       try {
           TimeUnit.SECONDS.sleep(4);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("send");
   }
   public synchronized void call(){
       System.out.println("call");
   }
}

3.增加一个普通方法hello，先打印hello，在打印send

package lock8;

import java.util.concurrent.TimeUnit;

/**
* 增加一个普通方法，先打印hello，再打印send
*/
public class Test2 {
   public static void main(String[] args) {
       Phone2 phone=new Phone2();
       new Thread(()->{phone.send();},"A").start();
       try {
           TimeUnit.SECONDS.sleep(1);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       new Thread(()->{phone.hello();},"B").start();
   }
}
class Phone2{
   // synchronized 锁的对象是方法的调用者
   public synchronized void send(){
       try {
           TimeUnit.SECONDS.sleep(4);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("send");
   }
   public synchronized void call(){
       System.out.println("call");
   }
   //没有锁，不是同步方法，不受锁的影响
   public void hello(){
       System.out.println("hello");
   }
}

4.两个对象，两个同步方法，先打印call，在打印send
两个对象，两个调用者，两把锁

package lock8;

import java.util.concurrent.TimeUnit;

/**
* 增加一个普通方法，先打印hello，再打印send
*/
public class Test2 {
   public static void main(String[] args) {
       //两个对象，两个调用者，两把锁
       Phone2 phone1=new Phone2();
       Phone2 phone2=new Phone2();

       new Thread(()->{phone1.send();},"A").start();
       try {
           TimeUnit.SECONDS.sleep(1);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       new Thread(()->{phone2.call();},"B").start();
   }
}
class Phone2{
   // synchronized 锁的对象是方法的调用者
   public synchronized void send(){
       try {
           TimeUnit.SECONDS.sleep(4);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("send");
   }
   public synchronized void call(){
       System.out.println("call");
   }
   //没有锁，不是同步方法，不受锁的影响
   public void hello(){
       System.out.println("hello");
   }
}

5.增加两个静态同步方法，只有一个对象，先打印send，在打印call
static 静态方法
类一加载就有了锁的是Class

package lock8;

import java.util.concurrent.TimeUnit;

/**
* 增加两个静态同步方法，只有一个对象，先打印send
*/
public class Test3 {
   public static void main(String[] args) {
  
       Phone3 phone=new Phone3();

       new Thread(()->{phone.send();},"A").start();
       try {
           TimeUnit.SECONDS.sleep(1);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       new Thread(()->{phone.call();},"B").start();
   }
}
//Phone3唯一有个class对象
class Phone3{
   // synchronized 锁的对象是方法的调用者
   //static 静态方法
   //类一加载就有了 锁的是Class
   public static synchronized void send(){
       try {
           TimeUnit.SECONDS.sleep(4);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("send");
   }
   public static synchronized void call(){
       System.out.println("call");
   }

}

6.两个静态同步方法，两个对象，先打印send，在打印call

package lock8;

import java.util.concurrent.TimeUnit;

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

       new Thread(()->{phone1.send();},"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 send(){
       try {
           TimeUnit.SECONDS.sleep(4);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("send");
   }
   public static synchronized void call(){
       System.out.println("call");
   }

}

7.一个静态同步方法，一个同步方法，一个对象，先打印call，再打印send

package lock8;

import java.util.concurrent.TimeUnit;

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

       new Thread(()->{phone1.send();},"A").start();
       try {
           TimeUnit.SECONDS.sleep(1);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       new Thread(()->{phone1.call();},"B").start();
   }
}
//Phone3唯一有个class对象
class Phone4{

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

}

小结：new this 具体的一个对象，static Class唯一的一个模板

集合类不安全

list不安全

package unsafe;

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

// java.util.ConcurrentModificationException并发修改异常
public class Test {
   public static void main(String[] args) {
       //并发下ArrayList 不安全的
       /**
        * 解决方案
        * 1.List<String> list=new Vector<>();
        * 2. List<String> list=Collections.synchronizedList(new ArrayList<>());
        * 3.  List<String> list=new CopyOnWriteArrayList<>();
        */
      //CopyOnWrite 写入时复制 COW  计算机程序设计领域的一种优化策略
       //多个线程调用的时候，list，读取的时候，固定的，写入（覆盖）
       //在写入的时候避免覆盖，造成数据问题
       List<String> list=new CopyOnWriteArrayList<>();

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

set不安全

package unsafe;

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

/*java.util.ConcurrentModificationException
*1. Set<String> set= Collections.synchronizedSet(new HashSet<>());
*2.Set<String> set=new CopyOnWriteArraySet<>();
*/
public class SetTest {
   public static void main(String[] args) {
       //Set<String> set=new HashSet<>();
       //Set<String> set= Collections.synchronizedSet(new HashSet<>());
       Set<String> set=new CopyOnWriteArraySet<>();
       for (int i = 0; i < 30; i++) {
           new Thread(()->{
               set.add(UUID.randomUUID().toString().substring(0,5));
               System.out.println(set);
           },String.valueOf(i)).start();
       }
   }
}

map不安全

package unsafe;

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

//java.util.ConcurrentModificationException
public class MapTest {
    public static void main(String[] args) {
        //Map<String, String> map = new HashMap<>();
        Map<String, String> map = new ConcurrentHashMap<>();

        for (int i = 0; i < 30; i++) {
            new Thread(()->{
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0,5));
                System.out.println(map);
            },String.valueOf(i)).start();
        }
    }
}

Callable

可以有返回值
可以抛出异常
方法不同，run()/call()

package callable;

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

public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //new Thread(new Runnable()).start();
        //new Thread(new FutureTask<V>()).start();
        //new Thread(new FutureTask<V>(Callable)).start();
        new Thread().start();//怎么启动Callable
        NyThread thread=new NyThread();
        FutureTask futureTask = new FutureTask(thread);//适配类
        new Thread(futureTask,"A").start();
         new Thread(futureTask,"B").start();//结果会被缓存，效率高
        Integer o = (Integer) futureTask.get();//这个get()方法可能会产生阻塞，把他放在最后，或者使用异步通信来处理，获取Callable的返回结果
        System.out.println(o);


    }
}
class NyThread implements Callable<Integer> {
    @Override
    public Integer call(){
        System.out.println("call() ");
        return 1024;

    }
}

1.有缓存
2.结果可能需要等待，会阻塞！

常用的辅助类

1.CountDownLatch

package add;

import java.util.concurrent.CountDownLatch;

public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        //总数是6,必须要执行任务的时候，再使用！
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 1; i <= 6; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"GO OUT");
                countDownLatch.countDown();//数量-1
            },String.valueOf(i)).start();
        }
        countDownLatch.await();//等待计数器归零，然后再向下执行

        System.out.println("Close Door");

    }
}

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

2.CyclicBarrier

加法计数器

package add;

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

public class CyclicBarrierDemo {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
            System.out.println("AAAAAA");
        });
        for (int i = 1; i <=7; i++) {
            final int temp=i;
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"=>"+temp);
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

3.Semaphore
信号量

package add;

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

public class SemaphoreDemo {
    public static void main(String[] args) {
        //线程数量:停车位数量为3,限流！
        Semaphore semaphore = new Semaphore(3);
        //6辆车，3个停车位
        for (int i = 1; i <= 6; i++) {
            new Thread(()->{
                //acquire()得到
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName()+"抢到车位");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName()+"离开车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release(); //release()释放
                }

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

        }
    }
}

semaphore.acquire();获得，假设如果已经满了，等待，等待被释放为止
semaphore.release();释放，会将当前的信号量释放，然后唤醒等待的线程
作用：多个共享资源互斥的使用！并发限流，控制最大的线程数

读写锁 ReadWriteLock

package rw;

import jdk.nashorn.internal.ir.CallNode;

import javax.sound.midi.Track;
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 ReadWriteLockDemo {
    public static void main(String[] args) {
       // MyCache myCache = new MyCache();
        MyCacheLock myCache = new MyCacheLock();
        //写入
        for (int i = 1; i <= 5; i++) {
            final int temp=i;
            new Thread(()->{
            myCache.put(temp+"",temp+"");
            },String.valueOf(i)).start();
        }
        //读取
        for (int i = 1; i <= 5; i++) {
            final int temp=i;
            new Thread(()->{
                myCache.get(temp+"");
            },String.valueOf(i)).start();
        }

    }
}
//加锁
class MyCacheLock{
    private volatile Map<String,Object> map=new HashMap<>();
    //读写锁，更加细粒度的控制
    private ReadWriteLock readWriteLock=  new ReentrantReadWriteLock();
    //存，写入的时候，只希望同时只有一个线程写
    public void put(String key,Object value){
        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"写入"+key);
            map.put(key,value);
            System.out.println(Thread.currentThread().getName()+"写入OK");
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            readWriteLock.writeLock().unlock();
        }

    }
    //取，读，所有人读
    public void get(String key){
        readWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"读取"+key);
            Object o = map.get(key);
            System.out.println(Thread.currentThread().getName()+"读取OK");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }

    }
}

/**
 * 自定义缓存
 */
class MyCache{
    private volatile Map<String,Object> map=new HashMap<>();
    //存，写
    public void put(String key,Object value){
        System.out.println(Thread.currentThread().getName()+"写入"+key);
        map.put(key,value);
        System.out.println(Thread.currentThread().getName()+"写入OK");
    }
    //取，读
    public void get(String key){
        System.out.println(Thread.currentThread().getName()+"读取"+key);
        Object o = map.get(key);
        System.out.println(Thread.currentThread().getName()+"读取OK");
    }
}

阻塞队列

阻塞队列：

BlockingQueue不是新的东西

什么情况会使用多线程：多线程并发处理，线程池

四组API

package bq;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;

public class Test {
    public static void main(String[] args) throws InterruptedException {
        //test1();
        test3();

    }

    /**
     * 抛出异常
     */
    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"));

        //java.lang.IllegalStateException: Queue full 抛出异常
        //System.out.println(arrayBlockingQueue.add("d"));
        System.out.println(arrayBlockingQueue.element());//查看队首元素
        System.out.println("=====================");

        System.out.println(arrayBlockingQueue.remove());
        System.out.println(arrayBlockingQueue.remove());
        System.out.println(arrayBlockingQueue.remove());
        // java.util.NoSuchElementException 抛出异常
        //System.out.println(arrayBlockingQueue.remove());

    }

    /**
     * 不抛出异常
     */
    public static void test2(){
        //队列的大小
        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(3);
        System.out.println(arrayBlockingQueue.offer("a"));
        System.out.println(arrayBlockingQueue.offer("b"));
        System.out.println(arrayBlockingQueue.offer("c"));
        //System.out.println(arrayBlockingQueue.offer("d"));//false，不抛出异常
        System.out.println(arrayBlockingQueue.peek());//检测队首元素
        System.out.println("===================");
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());
        //System.out.println(arrayBlockingQueue.poll());//null不抛出异常
    }

    /**
     * 等待、阻塞
     * @throws InterruptedException
     */
    public static void test3() throws InterruptedException {
        //队列的大小
        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(3);
        //一直阻塞
        arrayBlockingQueue.put("a");
        arrayBlockingQueue.put("b");
        arrayBlockingQueue.put("c");
        //arrayBlockingQueue.put("d");//队列没有位置，一直阻塞
        System.out.println(arrayBlockingQueue.take());
        System.out.println(arrayBlockingQueue.take());
        System.out.println(arrayBlockingQueue.take());
        //System.out.println(arrayBlockingQueue.take());没有这个元素，一直阻塞

    }

    /**
     * 等待，阻塞（等待超时）
     */
    public static void test4() throws InterruptedException {
//队列的大小
        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(3);
        arrayBlockingQueue.offer("a");
        arrayBlockingQueue.offer("b");
        arrayBlockingQueue.offer("c");
        arrayBlockingQueue.offer("d",2, TimeUnit.SECONDS);//等待超过两秒，退出
        System.out.println("==================");
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());

        arrayBlockingQueue.poll(2,TimeUnit.SECONDS);//等待超过两秒，退出
    }
}

synchronousQueue同步队列
没有容量，进去一个元素，必须等待取出来之后，才能再往里面放一个元素
put、take

package bq;

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

/**
* 同步队列
* 和其他的 BlockingQueue 不一样，SynchronousQueue不存储元素
* put了一个元素，必须从里面先take取出来，否则不能在put进去值
*/
public class synchronousQueueDemo {
  public static void main(String[] args) {
     BlockingQueue<String> synchronousQueue= new SynchronousQueue<>();//同步队列
      new Thread(()->{

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

      new Thread(()->{
          try {
              TimeUnit.SECONDS.sleep(3);
              System.out.println(Thread.currentThread().getName()+"=>"+synchronousQueue.take());
              TimeUnit.SECONDS.sleep(3);
              System.out.println(Thread.currentThread().getName()+"=>"+synchronousQueue.take());
              TimeUnit.SECONDS.sleep(3);
              System.out.println(Thread.currentThread().getName()+"=>"+synchronousQueue.take());
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
      },"T2").start();
  }
}

线程池

线程池：三大方法、7大参数、4种拒绝策略
池化技术：程序的运行，本质是占用系统的资源！优化资源的使用==>池化技术
线程池、连接池、内存池、对象池… 创建和销毁十分浪费资源
池化技术：事先准备好一些资源，有人要用，就来我这里来拿，用完之后还给我
线程池好处：

降低资源的消耗
提高响应的速度
方便管理
线程复用、可以控制最大并发数，管理线程

三大方法

package pool;

import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TransferQueue;
// Executors 工具类 3大方法

public class Demo01 {
    public static void main(String[] args) {
        //ExecutorService executorService = Executors.newSingleThreadExecutor();//单个线程
        //ExecutorService executorService = Executors.newFixedThreadPool(5);//创建一个固定的线程池大小
        ExecutorService executorService = Executors.newCachedThreadPool();//可伸缩的线程池

        try {
            for (int i = 0; i < 10; i++) {
                //使用了线程池过后，使用线程池来创建线程
                executorService.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" OK");
                });
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //线程池用完，程序结束，关闭线程池
            executorService.shutdown();
        }
    }

}

7大参数
源码分析

 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,//21亿 OOM
                                      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;
    }

手动创建线程池

package pool;

import java.util.concurrent.*;
// Executors 工具类 3大方法
//AbortPolicy()//银行满了，还有人进来，不处理这个人的，抛出异常
//CallerRunsPolicy()//哪来的去哪里
//DiscardPolicy()//队列满了，丢掉任务，不抛出异常
//DiscardOldestPolicy()队列满了，尝试去和最早的竞争，不会抛出异常
public class Demo01 {
    public static void main(String[] args) {
        //自定义线程池
        ExecutorService executorService =new ThreadPoolExecutor(
                                        2,
                                    5,
                                       3,
                                       TimeUnit.SECONDS,
                                        new LinkedBlockingDeque<>(3),
                                        Executors.defaultThreadFactory(),
                                        new ThreadPoolExecutor.DiscardOldestPolicy());

        try {
            //最大承载：Deque+max
            //超过则抛出RejectedExecutionException:
            for (int i = 0; i < 8; i++) {
                //使用了线程池过后，使用线程池来创建线程
                executorService.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" OK");
                });
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //线程池用完，程序结束，关闭线程池
            executorService.shutdown();
        }
    }

}

四种拒绝策略

AbortPolicy()//银行满了，还有人进来，不处理这个人的，抛出异常
CallerRunsPolicy()//哪来的去哪里
DiscardPolicy()//队列满了，丢掉任务，不抛出异常
DiscardOldestPolicy()队列满了，尝试去和最早的竞争，不会抛出异常
IO密集型，cpu密集型（调优）
最大线程到底该如何定义
1、cpu密集型几核，就是几，可以保证cpu的效率最高
2、IO 密集型 >判断你程序中十分占用io的线程
程序，15个大型任务，io十分占用资源

四大函数型接口

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

函数式接口：只有一个方法的接口。简化编程模型，在新版本的框架底层大量应用。foreach（消费者类的函数式接口）

function函数式接口

package function;

import java.util.function.Function;

/**
 * Function函数型接口,有一个输入参数，忧郁哥输出
 * 只要是 函数型接口，可以用lambda表达式简化
 */
public class Demo01 {
    public static void main(String[] args) {

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

断定型接口

package function;

import java.util.function.Predicate;

/**
 * 断定型接口，有一个输入参数，返回值只能是布尔值
 */
public class Demo02 {
    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("123"));


    }
}

consumer消费性接口

package function;

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

supplier供给性接口

package function;

import java.util.function.Supplier;

public class Demo04 {
    public static void main(String[] args) {
      /*  Supplier<String> supplier = new Supplier<String>() {
            @Override
            public String get() {
                System.out.println("get");
                return "1024";
            }
        };*/
        Supplier<String> supplier =()->{  System.out.println("get");return "1024";};
        System.out.println(supplier.get());
    }
}

Stream流式计算

package stream;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
  private int id;
  private String name;
  private int age;
}

package stream;

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

/**
 * 现在有5个用户，筛选：一行代码实现
 * 1.ID必须是偶数
 * 2.年龄必须大于23岁
 * 3.用户名转为大写字母
 * 4.用户字母倒着排序
 * 5.只输出一个用户
 */
public class Test {
    public static void main(String[] args) {
        User user1 = new User(1,"a",21);
        User user2 = new User(2,"b",22);
        User user3 = new User(3,"c",23);
        User user4 = new User(4,"d",24);
        User user5 = new User(6,"e",25);
        //集合就是存储
        List<User> list = Arrays.asList(user1, user2, user3, user4, user5);
        //计算交给Stream流
        //lambda表达式、链式编程、函数接口、Stream流式计算
        list.stream()
                .filter(user -> {return user.getId()%2==0;})
                .filter(user -> {return user.getAge()>23;})
                .map(user -> {return user.getName().toUpperCase();})
                .sorted((uu1,uu2)->{return uu2.compareTo(uu1);})
                .limit(1)
                .forEach(System.out::println);

    }
}

ForkJoin

主要并行执行任务，提高效率，大数据量

ForkJoin特点：工作窃取
这个里面维护的都是双端队列

package forkjoin;

import java.util.concurrent.RecursiveTask;

/**
 * 求和计算的任务
 * 如何使用forkjoin?
 * 1.forkjoinPool 通过它来执行
 * 2.计算任务 forkjoinPool.excute(ForkJoinTask task)
 * 3.计算类要继承ForkJoinTask
 */
public class ForkJoinDemo extends RecursiveTask<Long> {
    private Long start;
    private Long end;
    //临界值
    private Long temp=10000L;

    public ForkJoinDemo(Long start, Long end) {
        this.start = start;
        this.end = end;
    }
    //计算方法
    @Override
    protected Long compute() {
        if((end-start)<temp){
            Long sum=0L;
            for (Long i = start; i <=end; i++) {
                sum+=i;
            }
            return sum;
        }else {//forkjoin 递归
            long middle = (start + end) / 2;//中间值
            ForkJoinDemo task1 = new ForkJoinDemo(start, middle);
            task1.fork();//拆分任务，把任务压入线程队列
            ForkJoinDemo task2 = new ForkJoinDemo(middle+1, end);
            task2.fork();
            return task1.join()+task2.join();

        }
    }
}

package forkjoin;

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

public class Test {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //test1();9731
        //test2();10709
        test3();//543

    }
    //普通方法
    public static void test1(){
        Long sum=0L;
        long start=System.currentTimeMillis();
        for (Long i=1L;i<1000000000;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 forkJoinPool=new ForkJoinPool();
        ForkJoinTask<Long> task = new ForkJoinDemo(0L, 1000000000L);
        //forkJoinPool.execute(task);//执行任务
        ForkJoinTask<Long> submit = forkJoinPool.submit(task);//提交任务
        Long sum = submit.get();

        long end=System.currentTimeMillis();
        System.out.println("sum="+sum+"时间:"+(end-start));
    }
    public static void test3(){
        long start=System.currentTimeMillis();
        //Stream并行流
       long sum= LongStream.rangeClosed(0L,1000000000L).parallel().reduce(0,Long::sum);
        long end=System.currentTimeMillis();
        System.out.println("sum="+"时间:"+(end-start));
    }
}

异步回调

初衷：对将来的某个事件的结果进行建模

package future;

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

/**
 * 异步调用:CompletableFuture
 * 异步执行
 * 成功回调
 * 失败回调
 */
public class Demo1 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //发起一个请求 没有返回值的runAsync异步回调
      /*  CompletableFuture<Void> objectCompletableFuture = CompletableFuture.runAsync(()->{
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"runAsync=>void");
        });
        System.out.println("111111");
        objectCompletableFuture.get();//获取阻塞执行结果*/
      //有返回值的异步回调
        CompletableFuture<Integer> objectCompletableFuture = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread().getName()+"supplyAsync=>Integer");
            return 1024;
        });
        System.out.println(objectCompletableFuture.whenComplete((t, u) -> {
            System.out.println("t--->" + t);//正常的返回结果
            System.out.println("u--->" + u);//错误信息
        }).exceptionally((e) -> {
            e.printStackTrace();
            System.out.println(e.getMessage());
            return 233;//可以获取到错误的返回结果
        }).get());
    }
}

JMM

volatile是虚拟机提供的轻量级的同步机制

保证可见性
不保证原子性
禁止指令重排

关于JMM的一些同步约定

线程解锁前，必须把共享变量刷立刻回主存
线程加锁前，必须读取主存中的最新值到内存中
加锁和解锁是同一把锁

线程工作内存、主内存
8种操作

问题：程序不知道主内存的值已经被修改过了

Volatile

1.保证可见性

package tvolatile;

import java.util.concurrent.TimeUnit;

public class JMMDemo {
    //不加volatile 程序就会死循环
    //加volatile可以保证可见性
    private volatile static int num=0;
    public static void main(String[] args) {
        new Thread(()->{//线程1 对主内存的变化不知道
            while (num==0){

            }
        }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        num=1;
        System.out.println(num);
    }
}

2.不保证原子性
原子性：不可分割
线程A在执行任务的时候，不能被打扰，也不能被分割，要么同时成功，要么同时失败

package tvolatile;
//volatile不保证原子性
public class VDemo2 {
    private volatile static int num=0;
    public static void add(){
        num++;
    }

    public static void main(String[] args) {
        //理论上num的结果应该为2万
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                for (int i1 = 0; i1 < 1000; i1++) {
                    add();
                }
            }).start();
        }
        while (Thread.activeCount()>2){//main gc
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+" "+num);
    }
}

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

package tvolatile;

import java.util.concurrent.atomic.AtomicInteger;

//volatile不保证原子性
public class VDemo2 {
    //原子类的Integer
    private volatile static AtomicInteger num=new AtomicInteger();
    public static void add(){
       // num++;//不是原子性操作
        num.getAndIncrement();//AtomicInteger+1  方法  CAS
    }

    public static void main(String[] args) {
        //理论上num的结果应该为2万
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                for (int i1 = 0; i1 < 1000; i1++) {
                    add();
                }
            }).start();
        }
        while (Thread.activeCount()>2){//main gc
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+" "+num);
    }
}

这些类的底层都直接和操作系统挂钩！在内存中修改值！Unsafe类是一个很特殊的存在

指令重排：你写的程序，计算机并不是按照你写的那样去执行的
源代码—>编译器优化的重排–>指令并行也可能会重排–>内存系统也会重排–>执行
处理器在进行指令重排的时候，考虑：数据之间的依赖性
volatile可以避免指令重排

内存屏障，CPU指令，作用：
1.保证特定的操作的执行顺序！
2.可以保证某些变量的内存可见性（利用这些特性volatile实现了可见性）

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

单例模式

饿汉式、DCL懒汉式

饿汉式

package single;

/**
 * 饿汉式
 */
public class Hungry {
    //可能会浪费空间
    private byte[] data1=new byte[1024*1024];
    private byte[] data2=new byte[1024*1024];
    private byte[] data3=new byte[1024*1024];
    private byte[] data4=new byte[1024*1024];
    
    private Hungry(){

    }
    private final static Hungry HUNGRY=new Hungry();
    public static Hungry getInstance(){
        return HUNGRY;
    }
}

DCL懒汉式

package single;

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

/**
 * 懒汉式
 *
 */
public class LazyMan {
    private static boolean flag=false;
    private LazyMan(){
        synchronized (LazyMan.class){
            if (flag==false){
                flag=true;
            }else {
                throw new RuntimeException("不要试图用反射破坏异常");
            }
        }

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

   //反射
    public static void main(String[] args) throws Exception {
       //LazyMan instance = LazyMan.getInstance();
        Field flag = LazyMan.class.getDeclaredField("flag");
        flag.setAccessible(true);

        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        LazyMan  instance = declaredConstructor.newInstance();

        flag.set(instance,false);

        LazyMan  instance2 = declaredConstructor.newInstance();
        System.out.println(instance);
        System.out.println( instance2);



    }
}

静态内部类

package single;
//静态内部类
public class Holder {
    private Holder(){

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

单例不安全，因为反射

枚举

package single;

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

/**
 *
 */
public enum  EnumSingle {
    INSTANCE;
    public EnumSingle getInstance(){
        return INSTANCE;
    }
}
class Test{
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        EnumSingle instance = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);//用有参，不能用无参
        declaredConstructor.setAccessible(true);
        EnumSingle instance2= declaredConstructor.newInstance();
        //java.lang.NoSuchMethodException: single.EnumSingle.<init>()
        System.out.println(instance);
        System.out.println(instance2);


    }
}

深入理解CAS

package cas;

import jdk.nashorn.internal.ir.CallNode;

import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo {

    //CAS compareAndSet():比较并交换
    public static void main(String[] args) {
        AtomicInteger atomicInteger=new AtomicInteger(2020);
        //如果我期望的值达到了，那么就更新，否则不更新
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());

    }
}

unsafe类：

CAS:比较当前工作内存中的值和主内存中的值，如果这个值是期望的，那么则执行操作！如果不是就一直循环。
缺点：1.循环浪费时间。2.一次性只能保证一个共享变量的原子性。3.ABA问题

ABA问题：

package cas;

import jdk.nashorn.internal.ir.CallNode;

import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo {

    //CAS compareAndSet():比较并交换
    public static void main(String[] args) {
        AtomicInteger atomicInteger=new AtomicInteger(2020);
        //============捣乱的线程=============
        //如果我期望的值达到了，那么就更新，否则不更新
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());
        System.out.println(atomicInteger.compareAndSet(2021, 2020));
        System.out.println(atomicInteger.get());
        //============期望的线程==============
        System.out.println(atomicInteger.compareAndSet(2020, 6666));
        System.out.println(atomicInteger.get());

    }
}

原子引用

解决ABA问题，引入原子引用

带版本号的原子操作！

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

package cas;

import jdk.nashorn.internal.ir.CallNode;

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

public class CASDemo {
    //AtomicStampedReference 注意，如果泛型是一个包装类，注意对象的引用问题
    //正常在业务操作中，这里面比较的是一个对象
    static AtomicStampedReference<Integer> atomicInteger = new AtomicStampedReference<>(1, 1);
    //CAS compareAndSet():比较并交换
    public static void main(String[] args) {

        new Thread(()->{
            int stamp = atomicInteger.getStamp();//获得版本号
            System.out.println("A1=>"+stamp);

            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(atomicInteger.compareAndSet(1, 2, atomicInteger.getStamp(), atomicInteger.getStamp() + 1));
            System.out.println("A2=>"+atomicInteger.getStamp());
            System.out.println(atomicInteger.compareAndSet(2, 1, atomicInteger.getStamp(), atomicInteger.getStamp() + 1));
            System.out.println("A3=>"+atomicInteger.getStamp());
        },"A").start();
        //乐观锁的原理相同
        new Thread(()->{
            int stamp = atomicInteger.getStamp();//获得版本号
            System.out.println("B1=>"+stamp);
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(atomicInteger.compareAndSet(1, 6, stamp, stamp + 1));
            System.out.println("B2=>"+atomicInteger.getStamp());
        },"B").start();
    }
}

可重入锁（递归锁）

synchronized

package lock;

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{
    public synchronized void sms(){
        System.out.println(Thread.currentThread().getName()+"->sms");
        call();//这里有一把锁
    }
    public synchronized void call(){
        System.out.println(Thread.currentThread().getName()+"->call");
    }
}

lock

package lock;

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

public class Demo02 {
    public static void main(String[] args) {
        Phone2 phone = new Phone2();
        new Thread(()->{
            phone.sms();
        },"A").start();

        new Thread(()->{
            phone.sms();
        },"B").start();
    }
}
class Phone2{
    Lock lock=new ReentrantLock();
    public void sms(){
        lock.lock();//lock锁，必须配对，否则就会死在里面
        try {
            System.out.println(Thread.currentThread().getName()+"->sms");
            call();//这里有一把锁
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
    public  void call(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName()+"->call");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
}

自旋锁（spinlock）

package lock;

import jdk.nashorn.internal.ir.CallNode;

import java.util.concurrent.atomic.AtomicReference;

/**
 * 自旋锁
 */
public class SpinLock {
    AtomicReference<Thread> atomicReference=new AtomicReference<>();
    //加锁
    public void myLock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"==> mylock");
        //自旋锁
        while (!atomicReference.compareAndSet(null,thread)){

        }

    }

    //解锁
    public void myUnLock(){
        Thread thread = Thread.currentThread();
        System.out.println(Thread.currentThread().getName()+"==> myUnlock");
        atomicReference.compareAndSet(thread,null);
    }

}

测试

package lock;

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

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

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

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

    }
}

死锁

死锁测试

package lock;

import java.util.concurrent.TimeUnit;

public class DeadLockDemo {
    public static void main(String[] args) {
        String lockA="lockA";
        String lockB="lockB";


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

    }
}
class MyThread implements Runnable{
    private String lockA;
    private String lockB;

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

    @Override
    public void run() {
        synchronized (lockA){
            System.out.println(Thread.currentThread().getName()+"lock:"+lockA+"=>get"+lockB);

            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (lockB){
                System.out.println(Thread.currentThread().getName()+"lock:"+lockB+"=>get"+lockA);
            }
        }
    }
}

解决问题:
1.使用 jps -l 定位进程号

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

码农公寓

JUC