多线程--JUC并发编程

(illusion)

已于 2024-02-19 09:31:01 修改

阅读量327

点赞数 1

分类专栏： java笔记文章标签： java

于 2022-08-26 12:53:34 首次发布

本文链接：https://blog.csdn.net/dis_1illusion/article/details/126540814

版权

java笔记专栏收录该内容

20 篇文章 0 订阅

订阅专栏

全部测试代码

什么是JUC

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

线程和进程

进程

一个在内存中运行的应用程序。每个进程都有自己独立的一块内存空间，一个进程可以有多个线程，比如在Windows系统中，一个运行的xx.exe就是一个进程。

线程

进程中的一个执行任务（控制单元），负责当前进程中程序的执行。一个进程至少有一个线程，一个进程可以运行多个线程，多个线程可共享数据。

java默认有2个线程 mian线程 gc线程

并行和并发有什么区别？

并发：多个任务在同一个 CPU 核上，按细分的时间片轮流(交替)执行，从逻辑上来看那些任务是同时执行。
并行：单位时间内，多个处理器或多核处理器同时处理多个任务，是真正意义上的“同时进行”。
串行：有n个任务，由一个线程按顺序执行。由于任务、方法都在一个线程执行所以不存在线程不安全情况，也就不存在临界区的问题。

做一个形象的比喻：

并发 = 两个队列和一台咖啡机。

并行 = 两个队列和两台咖啡机。

串行 = 一个队列和一台咖啡机。

并发变成的本质: 充分利用CPU资源

线程的状态

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

wait/sleep的区别 ?

来自不同的类
1. wait --> Object
2. sleep --> Thread
锁的释放
1. wait 会释放锁
2. sleep 抱着锁睡觉,不会释放锁
使用的范围不同
1. wait 必须在同步代码块
2. sleep 可以在任何地方睡
是否需要捕获异常
1. wait 需要捕获异常wait需要被唤醒，
2. sleep 须捕获异常 ,sleep不需要被唤醒

Lock锁

传统synchronized

公平锁: 十分公平 , 可以先来后到

非公平锁: 不公平 , 可以插队 (默认使用)

package com.juc;

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

//买票
public class SaleTickDemo2 {
    public static void main(String[] args) {
//        多线程操作
        Ticket2 ticket = new Ticket2();

//        Runnable ; @FunctionalInterface 函数式接口    lambda   (参数) - > {代码}
        new Thread( ()-> {
            for (int i = 0; i < 60 ; i++) {
                ticket.sale();
            }
        },"A").start();
        new Thread( ()-> {
            for (int i = 0; i < 60 ; i++) {
                ticket.sale();
            }
        },"B").start();
        new Thread( ()-> {
            for (int i = 0; i < 60 ; i++) {
                ticket.sale();
            }
        },"C").start();
    }
}
/*
*  1. new ReentrantLock()
*  2. lock.lock(); 加锁
*  3.finally  lock.unlock();解锁
* */
class Ticket2 {
    private int num = 50;

    Lock lock = new ReentrantLock();

//    买票的方法
    public void sale(){
        lock.lock(); //加锁
        try {
//            业务代码
            if (num > 0) {
                System.out.println(Thread.currentThread().getName() + "第几张" + (num--) + "剩余" + num + "张");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
//            解锁
            lock.unlock();
        }
    }
}

Synchronized 与 lock 区别

Synchronized 内置java关键字, lock是java的一个类
Synchronized 无法判断获取锁的状态, lock可以判断是否获取到了锁
Synchronized 会自动释放锁 , lock必须手动释放锁, 不释放锁会导致死锁
Synchronized 线程1 获得锁线程2 等待线程1阻塞线程2 会死等; lock 不一定会等待 lock.tryLock(); 尝试获取锁
Synchronized 可重入锁,不可中断,非公平. lock 可重入锁,可以判断锁 ,锁的公平(可以自定义)
Synchronized 适合少量代码同步问题, lock 适合大量代码同步

生产者消费者问题

package com.pc; 
/*
* 线程之间的通信问题,生产者和消费者问题   等待唤醒   通知唤醒
* 线程交替执行 A  B  操作同一变量*/
public class A {
    public static void main(String[] args) {

        Data date = new Data();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    date.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    date.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
    }


}
// 等待  业务  通知
class Data{
    private int number = 0;

    public synchronized void increment() throws InterruptedException {
//        +1
        if (number != 0) {
// 等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"  "+number);
//        通知其他线程  我 +1 完毕了
        this.notifyAll();
    }
    public synchronized void decrement() throws InterruptedException {
//        -1
        if (number == 0) {
//等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"  "+number);
//        通知其他线程 我-1  完毕了
        this.notifyAll();
    }
}

如果有 ABCD四个线程, 会出现虚假唤醒的情况此时, 将if判断改为while 判断

package com.pc;
/*
* 线程之间的通信问题,生产者和消费者问题   等待唤醒   通知唤醒
* 线程交替执行 A  B  操作同一变量*/
public class A {
    public static void main(String[] args) {

        Data date = new Data();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    date.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    date.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    date.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    date.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();
    }

}

// 等待  业务  通知
class Data{
    private int number = 0;

    public synchronized void increment() throws InterruptedException {
//        +1
        while (number != 0) {
// 等待
            this.wait();
        }
        number++;
        System.out.println(Thread.currentThread().getName()+"  "+number);
//        通知其他线程  我 +1 完毕了
        this.notifyAll();
    }
    public synchronized void decrement() throws InterruptedException {
//        -1
        while (number == 0) {
//等待
            this.wait();
        }
        number--;
        System.out.println(Thread.currentThread().getName()+"  "+number);
//        通知其他线程 我-1  完毕了
        this.notifyAll();
    }
}

JUC版的生产者消费者

通过Lock 找到 Condition

package com.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 date = new Data2();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    date.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    date.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    date.increment();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                try {
                    date.decrement();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();

    }
}

// 等待  业务  通知
class Data2{
    private int number = 0;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();
//            condition.wait(); // 等待
//            condition.signalAll(); // 唤醒

    public  void increment() throws InterruptedException {
        lock.lock();
        try {
//            业务代码
//        +1
            while (number != 0) {
                condition.await(); // 等待
            }
            number++;
            System.out.println(Thread.currentThread().getName()+"-->"+number);
//        通知其他线程  我 +1 完毕了
            condition.signalAll(); // 唤醒
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public  void decrement() throws InterruptedException {
        lock.lock();
        try {
            //        -1
            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 com.pc;

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

/*
* A执行完调用B
* B执行完调用C
* C执行完调用A
* */
public class C {
    public static void main(String[] args) {
        Data3 data3 = new Data3();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data3.printA();
            }
        },"A").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data3.printB();
            }
        },"B").start();
        new Thread(()->{
            for (int i = 0; i < 10; i++) {
                data3.printC();
            }
        },"C").start();
    }
}

class Data3{
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();

    private int number = 1;
    public void printA(){
        lock.lock();
        try {
            while (number != 1) {
//                等待
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName() + "--->A");
//            唤醒指定的人
//            业务代码 判断是否等待  执行   通知
            number = number+1;
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printB(){
        lock.lock();
        try {
//            业务代码 判断是否等待  执行   通知
            while (number != 2) {
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName() + "--->B");
            number = 3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void printC(){
        lock.lock();
        try {
            while (number != 3) {
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName() + "--->C");
            number = 1;
            condition1.signal();
//            业务代码 判断是否等待  执行   通知
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

8锁现象

怎么判断锁的是谁

8锁测试代码

new this 具体的都关系

static 锁的是Class

集合类不安全

List - CopyOnWriteArrayList

package com.unsafe;

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

/*
* java.util.ConcurrentModificationException 并发修改异常
* */
public class ListTest {
    public static void main(String[] args) {
//        List<String> list = Arrays.asList("1", "12", "13");
//        list.forEach(System.out::println);

//        并发下 ArrayList 不安全
        /*
        * 解决方法：
        * 1. List<String> list = new Vector<>();
        * 2. List<String> list = Collections.synchronizedList(new ArrayList<>());
        * 3. List<String> list = new CopyOnWriteArrayList<>();
        * */
//        CopyOnWrite写入是复制  多个线程调用的时候 读取的是固定的，写入避免覆盖，写入的时候先copyof一份 ，最后在set回去
//        CopyOnWriteArrayList 比 Vector 厉害在哪
        List<String> list = new CopyOnWriteArrayList<>();
        for (int i = 1; i <= 10; i++) {
            new Thread(() -> {
                list.add(UUID.randomUUID().toString().substring(0, 5));
                System.out.println(list);
            }, String.valueOf(i)).start();
        }
    }
}

set - ConcurrentSkipListSet

package com.unsafe;

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

/*
*解决方案:
* 1.Set<String> set = Collections.synchronizedSet(new HashSet<>());
* 2.Set<String> set = new ConcurrentSkipListSet<>();
* */
public class SetTest {
    public static void main(String[] args) {
//        Set<String> set = new ConcurrentSkipListSet<>();
        HashSet<Object> set = new HashSet<>();
        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();
        }
    }
}

hashSet底层是啥??

hashSet底层new 了一个HashMap

add方法也是map.put()

map - ConcurrentHashMap

package com.unsafe;

import java.util.Collections;
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<Object, Object> map = Collections.synchronizedMap(new HashMap<>());
//        ConcurrentHashMap不能接受null的key和null的value,会抛出空指针异常
//        Map<String, String> map = new ConcurrentHashMap<>();
        for (int i = 1; i <= 30; i++) {
            new Thread(()->{
                map.put(Thread.currentThread().getName(), UUID.randomUUID().toString().substring(0, 5));
                System.out.println(map);
            },String.valueOf(i)).start();
        }
    }
}

Callable

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

package com.callable;

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

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

        MyThread myThread = new MyThread();
        FutureTask futureTask = new FutureTask(myThread);//        适配类

        new Thread(futureTask,"A").start();
        new Thread(futureTask,"B").start();
        // 两个线程，但只打印了一份  由于JVM第二次再调用FutrueTask对象所持有的线程， 此时FutrueTask的state此时已非NEW状态
//        则此时会直接结束对应线程，就会导致任务也不执行,只是在第一次调用时返回结果保存了
//        只执行一次，判断不是第一次就直接return了
        String o = (String)futureTask.get(); //获取Callable返回结果    get 方法可能会产生阻塞 或者使用异步通信处理
        System.out.println(o);
    }
}
class MyThread implements Callable<String>{  // Callable的泛型是啥返回值就是啥

    @Override
    public String call()  {
        System.out.println("call");
        return "999";
    }
}

常用的辅助类

CountDownLatch

package com.add;

import java.util.concurrent.CountDownLatch;

//计数器
public class CoundDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
//        倒计时,总数是6
        CountDownLatch countDownLatch = new CountDownLatch(6);
        for (int i = 0; i < 6; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName() + "走了");
                countDownLatch.countDown(); // 数量减一
            },String.valueOf(i)).start();
        }
        countDownLatch.await();//等待计数器归零,然后向下执行
        System.out.println("关门");
    }
}

原理:

countDownLatch.countDown(); // 数量减一

countDownLatch.await();//等待计数器归零

每次调用countDown() 数量减一 , 假设计数器变为0 countDownLatch.await() 就会被唤醒 ,继续执行

CyclicBarrier

package com.add;

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

//CyclicBarrier   执行达到指定线程数再执行操作
//集齐7个葫芦娃合体
public class CyclicBarrierDemo {
    public static void main(String[] args) {

//        呼叫葫芦娃的线程
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7, () -> {
            System.out.println("葫芦娃合体");
        });
        for (int i = 1; i <= 7; i++) {
//            lambda拿不到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();
        }
    }
}

Semaphore

package com.add;

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

//CyclicBarrier : 指定个数线程执行完毕再执行操作
//CyclicBarrier   执行达到指定线程数再执行操作
public class SemaohoreDemo {
    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() + " 得到车位");
                    TimeUnit.SECONDS.sleep(2);
                    System.out.println(Thread.currentThread().getName() + " 离开车位");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release(); // 释放
                }
            },String.valueOf(i)).start();

        }
    }
}

semaphore.acquire(); 获得 ,假设已经满了,等待, 知道被释放为止

semaphore.release(); 释放会将当前信号量释放 +1 , 然后唤醒等待的线程

作业 : 多个共享资源互斥使用 ; 并发限流(控制最大线程数)

读写锁

ReadWriteLock

package com.rw;

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

/*
* ReadWriteLock
* 独占锁(写锁) 一次只能被一个线程占有
* 共享锁(读锁) 多个线程可以同时操作
* 读 - 读  可以共存
* 读 - 写 不能共存
* 写 - 学 不能共存
* */
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        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();
        }
    }
}

//自定义缓存
// 会出现 写操作的时候被别的线程插队 , 所以引出ReadWriteLock 
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() + "写入完成");
    }
    //    读  取
    public void get(String key) {
        System.out.println(Thread.currentThread().getName() + "读取" + key);
        Object o = map.get(key);
        System.out.println(Thread.currentThread().getName() + "读取完成");
    }
}

//加锁
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() + "写入完成");
        } 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() + "读取完成");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }
    }
}

阻塞队列

阻塞

队列

四组API

方式	抛出异常	有返回值,不抛出异常	阻塞等待	超时等待
添加	add	offer	put()	offer( , ,)
移除	remove	poll	take()	pool( , )
判断队列首	element	peek	-	-

package com.bq;

import java.util.concurrent.ArrayBlockingQueue;

public class test {
    public static void main(String[] args) {
        test1();
    }
    /*
    * 抛出异常
    * */
    public static void test1(){
//        队列的大小
        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue<>(3);
        System.out.println(arrayBlockingQueue.add("a"));
        System.out.println(arrayBlockingQueue.add("c"));
        System.out.println(arrayBlockingQueue.add("v"));
        System.out.println("---------------");
//        java.lang.IllegalStateException: Queue full
//        System.out.println(arrayBlockingQueue.add("f"));


//        System.out.println(arrayBlockingQueue.element()); // 查看队首元素
        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(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll()); // 返回 null  不抛出异常
    }

    /*
    * 等待 阻塞  (一直阻塞)
    * */
    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);

        System.out.println(arrayBlockingQueue.offer("a"));
        System.out.println(arrayBlockingQueue.offer("b"));
        System.out.println(arrayBlockingQueue.offer("c"));
        System.out.println(arrayBlockingQueue.offer("c",2, TimeUnit.SECONDS));  //等待超过两秒直接退出

        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll(2,TimeUnit.SECONDS));  //等待超过两秒直接退出
    }

SynchronizedQueue 同步队列

没有容量

存进去一个元素后,必须等到取出来后才可以存入下一个元素

package com.blockingQueue;

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

/*同步队列
* 和其他的BlockingQueue 不一样 ,SynchronousQueue 不存储元素
* put 一个元素,必须先取出来  否则不能再put进去值 */
public class SynchronizedQueueDemo {
    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();
            }
        },"A").start();

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

线程池

线程池三大方法 ; 七大参数 ; 四种拒绝策略

线程池的好处：

降低资源消耗
提高响应速度
方便管理

线程复用，可以控制最大并发，管理线程

池化技术

事先准备好一些资源，有人要用就来拿，用完之后归还

三大方法

package com.pool;

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

/*
* Executors 工具类 3大方法
* 使用线程池创建线程
* */
public class Demo1 {
    public static void main(String[] args) {
//        ExecutorService threadPoolExecutor= Executors.newSingleThreadExecutor();//当个线程
//        ExecutorService threadPoolExecutor = Executors.newFixedThreadPool(5); //创建一个固定的线程池大小
        ExecutorService threadPoolExecutor = Executors.newCachedThreadPool(); //;可伸缩的 最大创建线程

        try {
            for (int i = 0; i < 10; i++) {
//                使用线程池来创建线程
                threadPoolExecutor.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "   ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
//            线程池使用完毕,程序结束,关闭线程池
            threadPoolExecutor.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;
    }

四种拒绝策略

package com.pool;

import java.util.concurrent.*;
/*
* java.util.concurrent.RejectedExecutionException 超出最大线程, 抛出异常
* ThreadPoolExecutor.CallerRunsPolicy() 哪里来会那里去
* ThreadPoolExecutor.DiscardPolicy() // 队列满了不会抛出异常
* ThreadPoolExecutor.DiscardOldestPolicy()  队列满了尝试和 最早的竞争
* */
public class Demo2 {
    public static void main(String[] args) {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2,
                5,
                3,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(3),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.DiscardOldestPolicy()); // 队列满了尝试和 最早的竞争

        try {
//            最大线程数量=  max + LinkedBlockingDeque
            for (int i = 1; i <= 9; i++) {
//                使用线程池来创建线程
                threadPoolExecutor.execute(() -> {
                    System.out.println(Thread.currentThread().getName() + "   ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
//            线程池使用完毕,程序结束,关闭线程池
            threadPoolExecutor.shutdown();
        }
    }
}

IO密集型 CPU密集型

问题： 线程池最大线程怎么设置

//        最大线程如何定义
//        1.CPU 密集型  几核就是几, 可以保持CPU的效率最高
        System.out.println(Runtime.getRuntime().availableProcessors());  // 获取CPU核数
//        2. IO 密集型  判断程序中消耗IO的线程,只要大于这些线程即可 
//        例 ; 程序中有15个大型任务, io特别占用资源  至少留15个线程处理这些任务

四大函数式接口

lambda表达式；链式编程；函数式接口；Stream流

函数时接口 : 只有一个方法的接口

// 简化编程模型，新版本框架大量使用
// foreach(消费者类的函数式接口)
@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

Function函数式接口

package com.Function;

import java.util.function.Function;
/*
* Function 函数式接口, 一个入参 一个输出
* 是要是函数时接口 就可以用lambda表达式简化
* */
public class Demo {
    public static void main(String[] args) {
//        输出输入的值
//        Function function = new Function<String, String>() {
//            @Override
//            public String apply(String s) {
//                return s;
//            }
//
//        };
        Function<String, String> function = (str) -> {return   str; };
        System.out.println(function.apply("123asd"));
    }
}

Predicate断定型接口

有一个入参返回值式布尔值

package com.Function;

import java.util.function.Predicate;

/*
 * 断定型接口 有一个入参 返回值式布尔值
 * */
public class Demo2 {
    public static void main(String[] args) {
//        判断字符是否为空
//        Predicate<String> predicate = new Predicate<String>(){
//            @Override
//            public boolean test(String s) {
//                return s.isEmpty();
//            }
//        };
        Predicate<String> predicate = (srt) -> { return srt.isEmpty(); };
        System.out.println(predicate.test(""));
    }
}

Consumer消费型接口

只有入参没有返回值

package com.Function;

import java.util.function.Consumer;

/*
* Consumer 消费型接口 只有输入 ，没有返回值
* */
public class Demo3 {
    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<String> consumer = System.out::println;
        consumer.accept("123qwe");
    }
}

Supplier供给型接口

package com.Function;

import java.util.function.Supplier;

/*
* Supplier 没有参数 只有返回值
* */
public class Demo4 {
    public static void main(String[] args) {
//        Supplier<String> supplier = new Supplier<String>() {
//            @Override
//            public String get() {
//                return "123";
//            }
//        };
        Supplier<String> supplier = ()->{ return "123";};
        System.out.println(supplier.get());
    }
}

Stream流式计算

集合 MySQL 存储的东西交给Stream流来计算

package com.stream;

import java.util.Arrays;
import java.util.List;
/*
* 要求筛选：
*  id必须式偶数
* age 大于23
* name 转换为大写
* name 倒着排序
* 只输出一个用户
* */
public class Test {
    public static void main(String[] args) {
        User u1 = new User(1,"a",21);
        User u2 = new User(2,"b",22);
        User u3 = new User(3,"c",23);
        User u4 = new User(4,"d",24);
        User u5 = new User(6,"e",25);

        List<User> list =  Arrays.asList(u1, u2, u3, u4, u5);

        list.stream()
                .filter(u -> {
                    return u.getId() % 2 == 0;
                }).
                filter(u -> {
                    return u.getAge() > 23;
                })
                .map(u -> {
                    return u.getNamen().toUpperCase();
                }).sorted((uu1,uu2)->{
            return uu1.compareTo(uu2);})
                .limit(1)
                .forEach(System.out::println);
    }
}

ForkJoin

ForkJoin 再jDK1.7之后出的，并行执行任务，提高效率处理大数据量时使用

ForkJoin 特点任务窃取

里面维护的都是双端队列

代码测试

package com.forkJoin;


import java.util.concurrent.RecursiveTask;

/*
* 使用ForkJoin
* 1. 通过ForkJoinPool执行
* 2. 计算任务 forkJoinPool,execute(ForkJoinTxask task)
* 3. 计算类继承  ForkJoinTxask
* */
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 {
            long midden = (start + end) / 2; // 中间值
            ForkJoinDemo task1 = new ForkJoinDemo(start, midden);
            task1.fork(); //拆分任务 ，任务压入队列
            ForkJoinDemo task2 = new ForkJoinDemo(midden + 1 , end);
            task2.fork();//拆分任务 ，任务压入队列

            return task1.join() + task2.join();
        }
    }
}

测试类

package com.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(); //3820  239
//        test2(); //1996  121
//        test3(); //137  131
    }

//    普通计算
    public static void test1() {
        long sum = 0;
        long start = System.currentTimeMillis();
        for (long i = 1; i <10_0000_0000 ; i++) {
            sum += sum;
        }
        long end = System.currentTimeMillis();
        System.out.println("时间：" + (end - start));
    }
//    使用ForkJoin
    public static void test2() throws ExecutionException, InterruptedException {
        long start = System.currentTimeMillis();

        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Long> joinDemo1 = new ForkJoinDemo(0,10_0000_0000);
        ForkJoinTask<Long> submit = forkJoinPool.submit(joinDemo1);//提交任务
        Long sum = submit.get();

        long end = System.currentTimeMillis();
        System.out.println("sum:" + sum + "时间：" + (end - start));
    }

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

异步回调

对未来的某个事件结果进行建模

package com.future;

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

/*
* 异步调用
* 异步执行
* 成功回调
* 失败回调
* */
public class Demo1 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
//        没有返回值的 runAsync 异步回调
      /*  CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> {
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"runAsync--->Void");
        });
        System.out.println("1111");
        completableFuture.get();//阻塞获取执行结果
*/
//      有返回值的异步回调
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(()->{
            System.out.println(Thread.currentThread().getName() + "---->supplyAsync");
            int i = 10 / 0;
            return 111;
        });

        System.out.println(completableFuture.whenComplete((u1, u2) -> {
            System.out.println("t: " + u1); // 正常返回结果java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero            java.lang.ArithmeticException: / by zero
            System.out.println("u: " + u2);
        }).exceptionally((e) -> {
            System.out.println(e.getMessage());
            return 999; //可以获取到错误的返回结果
        }).get());
    }
}

JMM

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

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

Volatile 可见性怎么保证？？那就要说JMM了

JMM： java内存模型，是不存在的东西，是一种约定

关于JMM的约定：

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

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

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

线程：工作内存主内存

内存交互操作有8种，虚拟机实现必须保证每一个操作都是原子的，不可在分的（对于double和long类型的变量来说，load、store、read和write操作在某些平台上允许例外）

- 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操作之前，必须把此变量同步回主内存

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

Volatile

1.Volatile保证可见性

package com.testVolatile;

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(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        num = 1;
        System.out.println(num);

    }
}

2.Volatile不保证原子性

原子性：不可分割

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

package com.testVolatile;

//不保证原子性
public class VolatileDemo {
//    volatile 不保证原子性
    private volatile static int num = 0;
    public static void add(){
        num++;
    }
    public static void main(String[] args) {
//        理论上num结果为20000
        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);
    }
}

如果不加 lock和synchronized 怎么保证原子性

使用原子类保证原子性

package com.testVolatile;

import java.util.concurrent.atomic.AtomicInteger;

//不保证原子性
public class VolatileDemo {
//    volatile 不保证原子性
//    原子类的Integer
    private volatile static  AtomicInteger num = new AtomicInteger();
    public static void add(){
//        num++;  // 不是原子性操作
        num.getAndIncrement(); //  CAS操作
    }
    public static void main(String[] args) {
//        理论上num结果为20000
        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指令作用：

保证特定的操作的执行顺序

可以保证某些变量的内存可见性（利用这些特性 Volatile实现了可见性）

单例模式

饿汉式 DCL懒汉式

饿汉式：

package com.signal;

//饿汉式
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;
    }
}

懒汉式:

package com.signal;

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

//懒汉式单例
public class LazyMan {

    private static boolean aaaa = false;
    private LazyMan(){
        synchronized (LazyMan.class) {
            if (aaaa == false) {
                aaaa = true;
            } else {

                throw new RuntimeException("反射获取结果");
            }
        }
        System.out.println(Thread.currentThread().getName()+" o k ");
    }

//    加上volatile 避免 指令重排
    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;
    }

    多线程并发   加上volatile 后避免指令重排
//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 aaaa = LazyMan.class.getDeclaredField("aaaa");
    aaaa.setAccessible(true);

    Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
    declaredConstructor.setAccessible(true);
    LazyMan instance1 = declaredConstructor.newInstance();
    aaaa.set(instance1, false);

    LazyMan instance2= declaredConstructor.newInstance();

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

静态内部类：

package com.signal;

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

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

枚举

package com.signal;

import java.lang.reflect.Constructor;

//enum本身是一个Class类
public enum  EnumSingle {

    INSTANCE;
    public EnumSingle getInstamce() {
        return INSTANCE;
    }


}
class Test{
    public static void main(String[] args) throws Exception {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();
        System.out.println(instance1);
        System.out.println(instance2);
    }
}

深入理解CAS

cas: 比较当前工作内存中的值和主内存中的值,如果这个值是期望的,那么就执行操作,如果不是就一直循环

缺点：

1.由于底层是自旋锁，循环回浪费时间

由于是底层CPU操作，一次不保证一个共享变量的原子性

package com.cas;

import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo {
//    CompareAndSwap : 比较并交换
    public static void main(String[] args) {

        AtomicInteger atomicInteger = new AtomicInteger(2020);
//        如果期望值达到了 就更新，否则不更新   CAS是CPU的并发原语
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());
        atomicInteger.getAndIncrement();
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());
    }
}

unsafe 类

ABA问题:

package com.cas;

import java.util.concurrent.atomic.AtomicInteger;

public class CASDemo {
//    CompareAndSwap : 比较并交换
    public static void main(String[] args) {

        AtomicInteger atomicInteger = new AtomicInteger(2020);
//        如果期望值达到了 就更新，否则不更新   CAS是CPU的并发原语

//        捣乱线程
        System.out.println(atomicInteger.compareAndSet(2020, 2021));
        System.out.println(atomicInteger.get());
//        System.out.println(atomicInteger.getAndIncrement()+" 11111");
        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问题 ,引入原子引用对应的思想: 乐观锁

package com.cas;

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

/*integer默认缓存-128->127，超过这个范围就要new对象了，就会分配新的地址，我们看到源码是==，非数值类型，我们比较的是对象的地址

我想看怎么找到问题所在的片段
1. 看compareAndSet的源码，里面是使用 == 进行比较的。
2. 由于new的时候声明泛型肯定是装箱类，这个时候传入值类型将会自动装箱
3. 自动装箱的后果就是地址不一致，使用==判断的结果就为false\
4. 总结：最好不使用原子类型，使用原子类型得保证比较时候传入的为同一个装箱类
* */
public class CASDemo2 {
    //    CompareAndSwap : 比较并交换
    public static void main(String[] args) {

//        正常情况下泛型中写的都是对象
        AtomicStampedReference<Integer> atomicInteger = new AtomicStampedReference<>(1, 1);

        new Thread(() -> {
            int stamp = atomicInteger.getStamp(); //获得版本号
            System.out.println("A--->" + stamp);
            try {
                TimeUnit.SECONDS.sleep(2);
            } 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, 5, stamp, stamp + 1));

            System.out.println("B2--->" + atomicInteger.getStamp());
        }, "B").start();

    }
}

integer默认缓存-128->127，超过这个范围就要new对象了，就会分配新的地址，我们看到源码是==，非数值类型，我们比较的是对象的地址

1. 看compareAndSet的源码，里面是使用 == 进行比较的。
2. 由于new的时候声明泛型肯定是装箱类，这个时候传入值类型将会自动装箱
3. 自动装箱的后果就是地址不一致，使用==判断的结果就为false\
4. 总结：最好不使用原子类型，使用原子类型得保证比较时候传入的为同一个装箱类

锁

可重入锁

也叫递归锁

synchronized 锁

package com.lock;

//synchronized
public class Demo1 {
    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 com.lock;

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

public class Demo2 {
    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.lock() ,锁必须配对，否则回出现死锁
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "  sms");
            call();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
            lock.unlock();
        }
    }

    public  void call() {
        lock.lock();

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

自旋锁

自定义自旋锁

package com.lock;

import java.util.concurrent.atomic.AtomicReference;

/*
 * 自旋锁
 * */
public class SpinLockDemo {
    AtomicReference<Thread> atomicReference = new AtomicReference<>();


    //    加锁
    public void MyLock() {
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName() + "   MyLock");
//    自旋锁
        while (!atomicReference.compareAndSet(null, thread)) {

        }
    }

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

代码测试

package com.lock;

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

public class TestSpinLock {
    public static void main(String[] args) throws InterruptedException {
        ReentrantLock reentrantLock = new ReentrantLock();
        reentrantLock.lock();
        reentrantLock.unlock();

//        底层使用的自旋锁CAS
        SpinLockDemo lock = new SpinLockDemo();
        new Thread(() -> {
            lock.MyLock();
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.MyUnLock();
            }
        }, "T1").start();
        TimeUnit.SECONDS.sleep(2);

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

T1进来是拿到了锁, 然后期望值null, 变成了Thread, 此时T1没有自旋, 而是跳出了循环,T2此时在无限循环, 过了等待时间, T1解锁, 变回了null, T2才能跳出循环

死锁

多个线程各自占有一些共享资源，并且相互等待其他线程占有的资源才能运行，而导致两个或多个线程都在等待对方释放资源，都停止执行的场景，某一个同步块同时拥有“两个以上对象的锁”时，就可能发生“死锁”的问题。

package com.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),"A").start();
        new Thread(new MyThread(lockB,lockA),"B").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);
            }
        }

    }
}

死锁解决方案：

产生死锁的四个必要条件：

互斥条件：一个资源每次只能被一个进程使用
请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放
不剥夺条件：进程已获得的资源，在未使用之前，不能强行剥夺
循环等待条件：若干进程之间行程一种头尾相接的循环等待资源关系

破坏上述4个条件任意一个或多个条件就会避免死锁的发生

jps -l 使用 jps 定位进程号

如果命令不识别可以试试这个:

找到 C:\Users{用户名}\AppData\Local\Temp\hsperfdata_{用户名} 右键属性->安全->添加用户，添加自己用户名，并且打开所有权限

jstack 70680 对应进程号找问题

(illusion)

关注

1
点赞
踩
0

收藏

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

JUC并发编程;8锁现象 ;安全集合类 ; 常用的辅助类 ;读写锁 ReadWriteLock ; 阻塞队列 ; 同步队列 ; 线程池三大方法,7大参数,四种拒绝策略;四大函数式接口;Volatile ;JMM;单例模式 ;CAS ;可重入锁;自旋锁;死锁......
复制链接

扫一扫