【狂神Java笔记】JUC并发（附代码）（更新中……）

-Blue.

已于 2022-03-04 22:50:36 修改

阅读量571

点赞数 2

分类专栏： Java笔记文章标签： java 开发语言后端

于 2022-02-26 15:50:22 首次发布

本文链接：https://blog.csdn.net/qq_47540091/article/details/123150908

版权

Java笔记专栏收录该内容

26 篇文章 3 订阅

订阅专栏

JUC并发

在这里插入图片描述

1、什么是JUC？

java.util 工具包、包、分类

业务：普通的线程代码 Thread

Runnable 没有返回值、效率相比入 Callable 相对较低 !

在这里插入图片描述

2、线程和进程

**进程：**一个程序， QQ.exe Music.exe程序的集合

一个进程往往可以包含多个线程，至少包含一个!

Java 默认有几个线程？2个 main、GC

**线程：**开了一个进程 Typora,写字,自动保存(线程负责的)

对于Java而言Thread、 Runnable、 Callable

Java真的可以开启线程吗？

开不了

public synchronized void start() {
    /**
     * This method is not invoked for the main method thread or "system"
     * group threads created/set up by the VM. Any new functionality added
     * to this method in the future may have to also be added to the VM.
     *
     * A zero status value corresponds to state "NEW".
     */
    if (threadStatus != 0)
        throw new IllegalThreadStateException();

    /* Notify the group that this thread is about to be started
     * so that it can be added to the group's list of threads
     * and the group's unstarted count can be decremented. */
    group.add(this);

    boolean started = false;
    try {
        start0();
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
            /* do nothing. If start0 threw a Throwable then
              it will be passed up the call stack */
        }
    }
}

并发、并行

并发编程：并发、并行

并发(多线程操作同一个资源)

CPU一核，模拟出来多条线程，天下武功，唯快不破，快速交替

并行(多个人一起行走)

CPU多核，多个线程可以同时执行；线程池

package main.com.blue.Demo01;

public class Text01 {
    public static void main(String[] args) {
        //获取cpu的核数
        //CPU密集型,I0密集型
        System.out.println(Runtime.getRuntime().availableProcessors());

    }

}

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

所有的公司都很看重!

线程有几个状态：

6个

public enum State {
    
    //新生
    NEW,

    /*运行
     */
    RUNNABLE,

    /* 阻塞*/
    BLOCKED,

    /*等待死死的等*/
    WAITING,

    /*超时等待*/
    TIMED_WAITING,

    //终止
    TERMINATED;
}

wait / sleep区别

1、来自不同的类

wait => Obiect

sleep => Thread

2、关于锁的释放

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

3、使用的范围是不同的

wait 必须在同步代码块中

seep可以再任何地方睡

4、是否需要捕获异常

wait不需要捕获异常

sleep必须要插沃异常

3、Lock锁(重点)

传统 Synchronized

package main.com.blue.Demo01;

//基本的卖票例子
/**
 * 真正的多线程开发, 公司中的开发
 * 线程就是一个单热的资源类,没有任何附属的操作!
 * 1、属性、方法
 */

public class SaleTicketDemo01 {
    public static void main(String[] args) {
        //并发:多线程操作同一个资源类,把资源类丢入线程
        Ticket ticket = new Ticket();

        //FunctionalInterface函数式接口,jdk1.8 Lambda表达式 (参数)->{代码}

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

    }

}

//资源类 00P
class Ticket{
    //属性、方法
    private int number = 50;

    // 卖票的方式
    //synchronized本质:队列 锁
    public synchronized void sale(){
        if (number>0){
            System.out.println(Thread.currentThread().getName()+"卖出了第"+(number--)+"票，剩余："+number);

        }
    }

}

Lock锁

在这里插入图片描述

公平锁：十分公平、可以先来后到
非公平锁：十分不公平、可以插队(默认)

package main.com.blue.Demo01;

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

public class SaleTicketDemo02 {
    public static void main(String[] args) {
        //并发:多线程操作同一个资源类,把资源类丢入线程
//        Ticket2 ticket2 = new Ticket2();
        Ticket2 ticket2 = new Ticket2();

        new Thread(()->{for (int i = 0; i < 30; i++) ticket2.sale();},"A").start();

    }

}

//Lock三部曲
//1, new ReentrantLocko;
//2、Lock.Lock();//加
//3、finally=>
//Lock锁
class Ticket2{
    //属性、方法
    private int number = 50;
    Lock lock = new ReentrantLock();

    public void sale(){
        lock.lock();  //加锁

        try {
            //业务代码
            if (number>0){
                System.out.println(Thread.currentThread().getName()+"卖出了第"+(number--)+"票，剩余："+number);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }

}

Synchronized和Lock区别

1、 Synchronized内置的ava关键字,Lock是一个av类

2、 Synchronized无法判断获取锁的状态,Lock可以判断是否获取到了锁

3、 Synchronized会自动释放锁,lock必须要手动释放锁!如果不释放锳,死锁

4、 Synchronized线程1(获得锁,阻塞)、线程2(等待,傻傻的等);Lock锁就不一定会等待下去

5、 Synchronized可重入锁,不可以中断的,非公平;Lock,可重入锁,可以判断锁,非公平(可以自己设置)

6、 Synchronized适合锁少量的代码同步问题,Lock酒合锁大量的同步代码!

锁是什么,如何判断锁得是谁！

4、生产者和消费者问题

面试的：单例模式、排序算法、生产者和消费者、死锁

Synchronized版

package main.com.blue.pc;

/**
 * 线程之间的通信问题:生产者和消费者问题!等待唤醒,通知唤醒
 * 线程交替执行AB操作同一个变量num=6
 * 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();
    }

}

问题存在, ABCD 4个线程 !

虚假唤醒

在这里插入图片描述

if 改成 while

package main.com.blue.pc;

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

}

JUC版

通过Lock找到 Condition

在这里插入图片描述

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

    }
}

任何一个新的技术,绝对不是仅仅只是覆盖了原来的技术,优势和补充

Condition 精准的通知和唤醒线程

在这里插入图片描述

代码测试：

package main.com.blue.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{//资源类Lock
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();//同步监视器
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
    private int number = 1; //1A 2B 3C

    public void printA(){
        lock.lock();
        try {
            // 业务，判断--执行--通知
            while (number!=1){
                //等待
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>AAAAAAA");
            //唤醒
            number = 2;
            condition2.signal();

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }

    }
    public void printB(){
        lock.lock();
        try {
            // 业务，判断--执行--通知
            while (number!=2){
                //等待
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName()+"=>BBBBBB");
            //唤醒
            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()+"=>CCCCCC");
            //唤醒
            number = 1;
            condition1.signal();

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    
    //生产线：  下单--支付--交易--物流

}

5、8锁现象

如何判断锁的是谁!永远的知道什么锁,锁到底锁的是谁

对象、 Class

代码

Text 1

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

1、标准情况下,两个线程先打印发短信还是打电话? 1/发短信 2/打电话
2、sendsms延14秒,两个线程先打印发短信还是打电话? 1/发短信 2/打电话

package main.com.blue.lock8;

import java.util.concurrent.TimeUnit;

/**
 *  8锁,就是关于锁的8个问题
 * 1、标准情况下,两个线程先打印发短信还是打电话?   1/发短信  2/打电话
 * 2、sendsms延14秒,两个线程先打印发短信还是打电话?  1/发短信   2/打电话
 */

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

        // 锁的存在
        new Thread(()->{
            phone.sendSms();
        },"A").start();

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

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

    }

}

class Phone{
    //synchronized 锁的对象是方法的调用者!
    //两个方法用的是同一个锁,谁先拿到谁执行

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

}

Text 2

3、发短信还是 hello hello 普通方法

4、两个对亲,两个同步方法,发短信还是打电话? 打电话

package main.com.blue.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 3、发短信 还是 hello  hello   普通方法
 * 4、两个对亲,两个同步方法,发短信还是打电话?    打电话
 */

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

        // 锁的存在
        new Thread(()->{
            phone1.sendSms();
        },"A").start();

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

        new Thread(()->{
            phone2.call();
        },"B").start();

    }

}

class Phone2{
    //synchronized 锁的对象是方法的调用者!
    //两个方法用的是同一个锁,谁先拿到谁执行

    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
    //这里没有锁！ 不是同步方法  不受锁的影响
    public void hello(){
        System.out.println("helllo");
    }

}

Text 3

5、增加两个静态的同步方法,只有一个对象,先打印 1发短信? 2打电话?

6、两个对象!增加两个静态的同步方法,先打印 1发短信? 2打电话?

package main.com.blue.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 5、增加两个静态的同步方法,只有一个对象,先打印  1发短信?  2打电话?
 * 6、两个对象!增加两个静态的同步方法,先打印 1发短信?  2打电话?
 */

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

        // 锁的存在
        new Thread(()->{
            phone1.sendSms();
        },"A").start();

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

        new Thread(()->{
            phone2.call();
        },"B").start();

    }

}

// Phone3唯一的一个 CLass对象
class Phone3{
    //synchronized 锁的对象是方法的调用者!
    //static  静态方法
    //类一加载就有了!锁的是 Class

    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public static synchronized void call(){
        System.out.println("打电话");
    }
    //这里没有锁！ 不是同步方法  不受锁的影响
    public void hello(){
        System.out.println("hello");
    }

}

Text 4

6、1个静态的问同步方法,1个普通的同步方法,一个对象,先打印 2发短信? 1打电话?

7、1个静态的同步方法,1个普通的同步方法,两个对象,先打印 2发短信? 1打电话?

package main.com.blue.lock8;

import java.util.concurrent.TimeUnit;

// 6、1个静态的问同步方法,1个普通的同步方法,一个对象,先打印  2发短信?  1打电话?
// 7、1个静态的同步方法,1个普通的同步方法,两个对象,先打印   2发短信?   1打电话?
public class Text4 {
    public static void main(String[] args) {
        Phone4 phone1 = new Phone4();


        // 锁的存在
        new Thread(()->{
            phone1.sendSms();
        },"A").start();

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

        new Thread(()->{
            phone1.call();
        },"B").start();

    }

}

// Phone3唯一的一个 CLass对象
class Phone4{
    //synchronized 锁的对象是方法的调用者!
    //static  静态方法
    //类一加载就有了!锁的是 Class

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

}

小结

相同的锁看先后

不同的锁看时间

6、集合类不安全

单线程的代码永远安全

并发的代码都有问题

list 不安全

package main.com.blue.unsafe;

import java.util.Arrays;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArrayList;

public class ListTest {
    public static void main(String[] args) {
//        List<String> list = Arrays.asList("1", "2", "3");
//        list.forEach(System.out::println);
        // 并发下 Arraylist不安全的吗, Synchronized
        /**
         * 1, List<string> List = new Vector<>();
         * 2, List<string> List = Collections synchronizedList (new ArrayList<>()));
         * 3, List<string> List = new CopyOnwriteArrayList<>();
         */
        /**
         * Copyonwrlte写入时复制cow计算机程序设计领域的一种优化策略;
         * 多个线程调用的时候,1ist,读取的时候,固定的,写入(覆盖)
         * 在写入的时侯避免覆盖,造成数据问题
         * 读写分离
         * CopyonwriteArrayList 比 vector Nb 在哪里?
         */
        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();
        }

    }
}

小狂神的学习方法推荐:1、先会用、2、货比3家,寻找其他解决方案,3、分析源码!

set 不安全

package main.com.blue.unsafe;

import java.util.*;
import java.util.concurrent.CopyOnWriteArraySet;

/**
 * 第1种多线程会报错
 * Set<Object> set1 = Collections.synchronizedSet(new HashSet<>()); 工具类写法
 */
public class SetTest {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();//1
//        Set<Object> set = Collections.synchronizedSet(new HashSet<>());
//        CopyOnWriteArraySet<Object> set = new CopyOnWriteArraySet<>();

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

    }

}

HashSet 的底层是什么？

public HashSet(){
	map= new HashMap<>();
}
//add set本质就是 map key是无法重复的!
public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}

map 不安全

回顾Map基本操作

在这里插入图片描述

ConcurrentHashMap不能接受null的key和null的value,会抛出空指针异常

package main.com.blue.unsafe;

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

public class MapTest {
    public static void main(String[] args) {
        //map是这样用的吗?不是,工作中不用 HashMap
        //默认等价于什么? new HashMap>(16,0,75)
        Map<String, Object> map = new HashMap<>();
        Map<String,String> map1 = 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();
        }

    }

}

7、callable （简单）

在这里插入图片描述

1、可以有返回值

2、可以抛出异常

3、方法不同,run/call

在这里插入图片描述

细节：

1、有缓存

2、结果可能需要等待，会阻塞

8、常用的辅助类

在这里插入图片描述

8.1、CountDownLatch

加法计数器

package main.com.blue.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 = 0; 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（）就会被唤醒，继续执行！

8.2、CyclicBarrier

减法计数器
在这里插入图片描述

package main.com.blue.add;

import java.util.concurrent.BrokenBarrierException;

public class CyclicBarrier {
    public static void main(String[] args) {
        /**
         * 集齐7颜龙殊召唤神龙
         */
        //召唤龙珠的线程
        java.util.concurrent.CyclicBarrier cyclicBarrier = new java.util.concurrent.CyclicBarrier(7,()->{
            System.out.println("召唤神龙成功！");
        });

        for (int i = 0; i < 7; i++) {
            final int temp = i;
            //Lambda能操作到i吗
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"收集"+temp+"个龙珠");

                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }

            }).start();
        }

    }

}

8.3、Semaphore

-Blue.

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
【狂神Java笔记】JUC并发（附代码）（更新中……）

目录JUC并发1、什么是JUC？2、线程和进程并发、并行线程有几个状态：wait / sleep区别3、Lock锁(重点)传统 SynchronizedLock锁Synchronized和Lock区别锁是什么,如何判断锁得是谁！4、生产者和消费者问题Synchronized版JUC版5、8锁现象代码Text 1Text 2Text 3Text 4小结6、集合类不安全list 不安全set 不安全map 不安全7、callable （简单）JUC并发1、什么是JUC？java.util 工具包、
复制链接

扫一扫