JUC学习入门

最新推荐文章于 2023-08-08 20:13:50 发布
最新推荐文章于 2023-08-08 20:13:50 发布
阅读量405 收藏
点赞数 1
分类专栏： Java 文章标签： 学习 java 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30556283/article/details/122745860
版权

目录

本教程内容来自「遇到狂神说」：视频地址

一、什么是JUC

业务：普通的线程代码Thread
Runnable没有返回值，效率相比入Callable相对较低！
“JUC是java.util.concurrent的简写。在jdk官方手册中可以看到juc相关的jar包有三个。专门用于多线程的开发。”

二、线程与进程

线程、进程，如果不能使用一句话说出来的技术 ，不扎实！

进程： 一个程序，qq.exe Music.exe 程序的集合；
一个进程往往可以包含多个线程，至少包含一个！
java默认有几个线程？2个 main、GC
线程： 比如打开一个Typort，开启了一个自动保存，你在写的时候他会创建一个线程专门去保存数据。
java中创建线程的方法：Thread、runnable、callable
Java是否可以直接开启线程？
当然不行，java是无法直接操控硬件都。

public synchronized void start() {
     if (threadStatus != 0)
         throw new IllegalThreadStateException();
     group.add(this);

     boolean started = false;
     try {
         start0();
         started = true;
     } finally {
         try {
             if (!started) {
                 group.threadStartFailed(this);
             }
         } catch (Throwable ignore) {
         }
     }
 }
 //本地方法。底层都是c++和c，java无法直接操作硬件
private native void start0();

并发和并行

并发编程：并发、并行
并发（多线程操作同一个资源）

  • CPU一核，模拟出来多条线程，天下武功唯快不破，快速交替
    并行（多个任务同时进行）
  • CPU多核，多条线程可以同时执行；线程池
//获取CPU密集型，IO密集型
System.out.println(Runtime.getRuntime().availableProcessors());

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

三、多线程

线程有几个状态

public enum State {
    //新生
    NEW,
    //运行
    RUNNABLE,
    //阻塞
    BLOCKED,
    //等待
    WAITING,
    //超时等待
    TIMED_WAITING,
    //终止
    TERMINATED;
}

wait/sleep区别

1、来自不同的类
wait=>Object
sleep=>Thread
2、关于锁的释放
wait会释放锁，sleep睡觉了，抱着锁睡觉，不会释放
3、使用范围不同的

  • wait 必须在同步代码块中
  • sleep 可以在任何地方睡
    4、释放需要捕获异常
  • wait 不需要捕获异常
  • sleep 必须捕获异常

四、传统Synchronized锁

package cn.qileyun;
/**
 * 真正的多线程开发，公式的开发，降低耦合性
 * 线程就是单独的资源类，没有任何附属操作！
 * 1、属性、方法
 */
public class SaleTicketDemo01 {
    public static void main(String[] args) {
        //并发：多线程操作同一个资源类lambok表达式 (次数)->{代码}
        Ticket ticket = new Ticket();
        //@FunctionlInterface 函数式接口
        new Thread(() -> {
            for (int i = 1; i < 60; i++) {
                ticket.sale();
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 1; i < 60; i++) {
                ticket.sale();
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 1; i < 60; i++) {
                ticket.sale();
            }
        }, "C").start();

    }
}

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

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

五、Lock锁

在这里插入图片描述

公平锁：十分公平：可以先来后到
非公平锁：十分不公平：可以插队（默认）

  1. new ReentrantLock();
  2. lock 加锁
  3. unlock 释放锁
public class SaleTicketDemo02 {
    public static void main(String[] args) {
        //并发：多线程操作同一个资源类lambok表达式 (次数)->{代码}
        Ticket2 ticket = new Ticket2();
        //@FunctionlInterface 函数式接口
        new Thread(() -> {
            for (int i = 1; i < 60; i++) {
                ticket.sale();
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 1; i < 60; i++) {
                ticket.sale();
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 1; i < 60; i++) {
                ticket.sale();
            }
        }, "C").start();

    }
}

//Lock 三部曲
//1、 new ReentrantLock();
//2、lock 加锁
//3、unlock 释放锁
class Ticket2 {
    //属性、方法
    private int number = 50;

    Lock lock = new ReentrantLock();

    //卖票的方式
    //synchronized 本质：队列，锁
    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 内置的java关键字，Lock是一个java类
  2. Synchronized 无法判断获取锁的状态，Lock可以判断获取到了锁
  3. Synchronized 会自动释放锁，lock必须手动释放锁！如果不释放锁，死锁
  4. Synchronized 线程1（获取锁,阻塞）、线程2（等待，傻傻的等）；Lock锁就不一定会等待下去
  5. Synchronized 可重入锁，不可以中断，非公平；Lock，可重入锁，可以判断锁，非公平（可以自己设置）；
  6. Synchronized 适合锁少量的代码同步问题，Lock适合大量的同步代码

锁是什么，如何判断锁的是谁？

七、传统的生产者消费者问题、防止虚假唤醒

面试题：单列模式、排序算法、生成者和消费者、死锁

生产者和消费者问题Synchronized

/**
 * 线程之间的腾讯问题，生产者和消费者问题！ 等待唤醒，通知唤醒
 * 线程交替执行 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=>1
B=>0
A=>1
...
B=>0
A=>1
B=>0
A=>1
B=>0
A=>1
B=>0

问题存在，A、B、C、D四个线程同时执行
就需要把if改成while 去循环判断

在这里插入图片描述

/**
 * 线程之间的腾讯问题，生产者和消费者问题！ 等待唤醒，通知唤醒
 * 线程交替执行 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();
        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

传统的和JUC的区别
在这里插入图片描述
代码：

class  Data{//数字 资源类
    private int number = 0;
    Lock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    //+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实现精准通知唤醒

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

Condition精准的通知和唤醒线程

# 我们可以看到以下执行的顺序是随机的
A=>1
B=>0
A=>1
B=>0
C=>1
B=>0
C=>1
B=>0
C=>1
B=>0
C=>1
B=>0
C=>1
B=>0
C=>1
B=>0
C=>1
B=>0
C=>1
B=>0
C=>1
D=>0
C=>1
D=>0
A=>1
D=>0
A=>1
D=>0
A=>1
D=>0
A=>1
D=>0
A=>1
D=>0
A=>1
D=>0
A=>1
D=>0
A=>1
D=>0

代码测试：

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

    }
}

//等待，业务，通知
/**
 * A 执行完调用B，B执行完调用C，C执行完执行A
 */
public class C {
    public static void main(String[] args) {
        DataC data = new DataC();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.printA();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "A").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.printB();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "B").start();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    data.printC();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "C").start();

    }
}

//等待，业务，通知
class DataC {//数字 资源类
    private int number = 1;// 通过为1 A执行 2 B执行 3 C执行
    Lock lock = new ReentrantLock();
    Condition condition1 = lock.newCondition();
    Condition condition2 = lock.newCondition();
    Condition condition3 = lock.newCondition();


    public void printA() throws InterruptedException {
        lock.lock();
        try {
            while (number != 1) {
                //业务，判断->执行->通知
                condition1.await();
            }
            System.out.println(Thread.currentThread().getName() + "=>AAAAAA" );
            //唤醒指定的人 B
            number=2;
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

    public void printB() throws InterruptedException {
        lock.lock();
        try {
            while (number != 2) {
                //业务，判断->执行->通知
                condition2.await();
            }
            System.out.println(Thread.currentThread().getName() + "=>BBBBBB" );
            //唤醒C
            number=3;
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }

    public void printC() throws InterruptedException {
        lock.lock();
        try {
            while (number != 3) {
                //业务，判断->执行->通知
                condition3.await();
            }
            System.out.println(Thread.currentThread().getName() + "=>CCCCCC" );
            //唤醒A
            number=1;
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }
    //生产线：下单->支付->交易->物流
}

在这里插入图片描述

八、八锁现象彻底理解锁

package cn.qileyun.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 7、一个静态的同步方法，1个普通方法，一个对象，先打印还是先打电话？打电话
 * 8、一个静态的同步方法，1个普通方法的同步方法，两个对象，先打印还是先打电话？打电话
 */
public class Test4 {
    public static void main(String[] args) {
        //两个对象的Class类模版只有一个，static
        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();
        //锁的存在
        new Thread(() -> {
            phone1.sendSms();
        }, "A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            phone2.call();
        }, "B").start();
    }

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

}

package cn.qileyun.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 3、增加两一个普通方法！是先发短信还是hello？ 普通方法
 * 4、两个对象。两个同步方法，发短信还是打电话？
 */
public class Test2 {
    public static void main(String[] args) {
        //两个对象，两个调用者，两把锁互不干扰
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();
        //锁的存在
        new Thread(() -> {
            phone1.sendSms();
        }, "A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            phone2.call();
        }, "B").start();
    }

}

class Phone2{
    //Synchronized 锁的对象是方法的调用者！
    public synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call() {
        System.out.println("打电话");
    }

    //这里没有锁 ！不是同步方法
    public void hello(){
        System.out.println("hello");
    }
}


package cn.qileyun.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 5、增加两个静态的同步方法,只有一个对象，先打电话还是先发短信？发短信
 * 6、两个对象！增加两个静态的同步方法，先打印 发短信还是先打电话？发短信
 */
public class Test3 {
    public static void main(String[] args) {
        //两个对象的Class类模版只有一个，static 锁的是class
        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();
        //锁的存在
        new Thread(() -> {
            phone1.sendSms();
        }, "A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            phone2.call();
        }, "B").start();
    }

}
//Phone3唯一的一个class对象
class Phone3{
    //Synchronized 锁的对象是方法的调用者！
    //static 静态方法
    //类一加载就有了！Class 模版  相当于锁的是Phone3.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("打电话");
    }

}


package cn.qileyun.lock8;

import java.util.concurrent.TimeUnit;

/**
 * 7、一个静态的同步方法，1个普通方法，一个对象，先打印还是先打电话？打电话
 * 8、一个静态的同步方法，1个普通方法的同步方法，两个对象，先打印还是先打电话？打电话
 */
public class Test4 {
    public static void main(String[] args) {
        //两个对象的Class类模版只有一个，static
        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();
        //锁的存在
        new Thread(() -> {
            phone1.sendSms();
        }, "A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            phone2.call();
        }, "B").start();
    }

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

}

小结：

  • new this 具体的一个手机
  • static Class 唯一的一个模版

九、集合类不安全

List（不安全）

解决方法：

  • 1、List list = new Vector<>();
  • 2、List list = Collections.synchronizedList(new ArrayList<>());
  • 3、List list = new CopyOnWriteArrayList<>();
public static void main(String[] args) {
     /** 并发下Arraylist 不安全的
      * List<String> list = new ArrayList<>();
      * 1、List<String> list = new Vector<>();
      * 2、List<String> list = Collections.synchronizedList(new ArrayList<>());
      * 3、List<String> list = new CopyOnWriteArrayList<>();
      */
     //CopyOnWrite 写入时复制 COW 计算机程序设计领域的一种优化策略；
     // 多个线程调用的时候，list，读取的时候固定的，写入（覆盖）
     // 写入的时候避免覆盖，造成数据问题
     //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();
     }
     list.forEach(System.out::println);
 }

CopyOnWriteArrayList添加原理
拷贝一份数组 去修改不会去影响读的操作

public boolean add(E e) {
    final ReentrantLock lock = this.lock;
    //使用lock锁 
    lock.lock();
    try {
        Object[] elements = getArray();//获取数组
        int len = elements.length;//获取成都
        Object[] newElements = Arrays.copyOf(elements, len + 1);//数组长度+1 并且拷贝原有的数据
        newElements[len] = e;//把新数据添加到最后一个下标
        setArray(newElements);//设置成新的数组地址
        return true;
    } finally {
        lock.unlock();
    }
}

Set（不安全）

解决方法：

  • 1、Collections.synchronizedSet(new HashSet<>());
  • 2、new CopyOnWriteArraySet<>();
/**
 * 1、Collections.synchronizedSet(new HashSet<>());
 * 2、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);//java.util.ConcurrentModificationException
            },String.valueOf(i)).start();
        }
    }
}

hashSet的本质就是一个HashMap

public HashSet() {
     map = new HashMap<>();
}
//add set本质就是map key是无法重复的！ 相当于就是拿map的key做set的值，而且可以做到去重的效果
public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}
private static final Object PRESENT = new Object();//不变的值

Map（不安全）

在这里插入图片描述

/**
 * 1、Collections.synchronizedMap(new HashMap<String, String>())
 * 2、new ConcurrentHashMap<>()
 */
public class MapTest {
    public static void main(String[] args) {
        //map 是这样用的吗？ 不是，工作中不用HashMap
        //默认等价是什么？map = new HashMap<String, String>(16,0.75f) 初始化容量，加载因子
        //Map<String, String> map = new HashMap<>();//并发不安全
//        Map<String, String> map = Collections.synchronizedMap(new HashMap<String, String>());
        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);//java.util.ConcurrentModificationException
            }, String.valueOf(i)).start();
        }
    }
}

ConcurrentHashMap原理（等待更新）

十、Callable（多线程创建的第三种方式）

  1. 可以有返回值
  2. 可以抛出异常
  3. 方法不同，run()/ call()
public class CallableTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //new Thread(new MyThread()).start(); 传统创建线程方法

        MyThread myThread = new MyThread();
        //适配类
        FutureTask futureTask = new FutureTask(myThread);
        new Thread(futureTask,"A").start();
        new Thread(futureTask,"B").start();//结果会被缓存

        //获取collable返回的结果
        String o = (String) futureTask.get();//这个get可能会造成堵塞，因为他需要等待线程执行完毕，可以竟可能的放在方法最后一行执行
        System.out.println(o);
    }
}

/**
 * Callable<需要返回的值类型>
 */
class MyThread implements Callable<String> {
    @Override
    public String call() {
        System.out.println("call()");//结果只会打印一边
        return "45678";
    }
}

十一、常用的辅助类

11.1、CountDownLatch

在这里插入图片描述

  • countDownLatch.countDown() 计数器-1
  • countDownLatch.await() 等待计数器归零，然后在向下执行
    每次线程调用countDown()数量-1.加入计数器变为-，await()就会被唤醒，继续执行
//计数器
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");
    }
}

11.2、CyclicBarrier

加法计数器

  public static void main(String[] args) {
      /**
       * 集齐七棵龙珠召唤神龙
       */
      //召唤龙珠的线程
      CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
          System.out.println("召唤神龙成功！");
      });
		//必须执行完8条线程才能执行召唤神龙
      for (int i = 0; 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();
      }
  }

结果：

Thread-2收集2个龙珠
Thread-0收集0个龙珠
Thread-1收集1个龙珠
Thread-3收集3个龙珠
Thread-6收集6个龙珠
Thread-5收集5个龙珠
Thread-4收集4个龙珠
召唤神龙成功！

11.3、Semaphore

Semaphore：信号量
在这里插入图片描述
抢车位！
6车—3个停车位置
123
456

  • semaphore.acquire() 获得，假设如果已经满 了，等待被释放为止！
  • semaphore.release() 会将当前的信号量释放 +1，然后唤醒等待的线程
    作用：多个资源互斥的使用！并发限流，控制最大并发量！
public static void main(String[] args) {
    //线程数量： 停车位！限流！
    Semaphore semaphore = new Semaphore(3);
    for(int i =1;i<=6;i++){
        new Thread(()->{
            //acquice() 得到
            //release() 释放
            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();
    }
}

结果：

1抢到车位
3抢到车位
2抢到车位
3离开车位
1离开车位
4抢到车位
2离开车位
5抢到车位
6抢到车位
4离开车位
6离开车位
5离开车位
不太懂编程
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【学习笔记】JUC基础基础程序
02-24
【学习笔记】JUC基础基础程序
【JUC基础】01. 初步认识JUC
有一只柴犬的专栏
05-01 987
前段时间，有朋友跟我说，能否写一些关于JUC的教程文章。本来呢，JUC也有在我的专栏计划之内，只是一直都还没空轮到他，那么既然有这样的一个契机，那就把JUC计划提前吧。那么今天就重点来初步认识一下什么是JUC，以及一些基本的JUC相关基础知识。
JUC-多线程（12. AQS-周阳）学习笔记
圆的博客
04-22 853
可重入锁，又叫递归锁同一个线程，在外层方法获取锁的时候，再进入该线程内层方法会自动获取锁（前提，锁对象必须是同一个对象），不会因为之前获取还没释放而阻塞。Java 中的 ReentrantLock 和 Synchronized 都是可重入锁可重入锁的优点就是避免死锁第一个考点：我相信你应该看过源码了，那么AQS里面有个变量叫State，它的值有几种？答：3个状态：没占用是0，占用了是1，大于1是可重入锁第二个考点：如果锁正在被占用，AB两个线程进来了以后，请问这个总共有多少个Node节点。
java--JUC快速入门（彻底搞懂JUC）
qq_53808097的博客
08-08 1535
线程池：一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。
JUC学习
lycheewsh的博客
06-09 96
1、什么是JUC面试高频问java.util工具包、包、分类业务：普通的线程代码 ThreadRunnable 没有返回值、效率相比Callable低。
JUC学习记录（基础篇）
m0_53077601的博客
02-09 457
1.什么是JUC 1.1 进程与线程 进程：指在系统中正在运行的一个应用程序；程序一旦运行就是进程；进程是资源分配的最小单位。 线程：系统分配处理器时间资源的最小单元，或者说进程之内独立执行的一个单元执行流。线程是程序执行的最小单位。 1.2线程的状态 线程状态枚举类Thread.State 中有5个状态 NEW，RUNNABLE，BLOCKED，WAITING，TIMED_WAITING，TERMINATED 1.3wati和sleep 区别： （1）sleep方法是Thread的静
Java-JUC学习PPT
05-31
Java基础之JUC学习!!!
个人学习JUC代码笔记总集
07-27
个人学习的时候对JUC做的笔记，包括所有代码，学习视频是尚硅谷周阳老师的JUC，需要有一定的基础才能看懂，这是个人笔记，不一定适用于所有人，谢谢！
leetcode下载-JavaLearn:算法、JVM、JUC、设计模式学习记录（Java语言实现）
06-29
这个repo是个人学习算法、JVM、JUC、设计模式的一些代码记录 algorithm是各个类别的题目，book文件夹下是一些算法书（《剑指Offer》、《程序员代码面试指南》）上的题目 jvm包下目前只包含了关于类加载的一些代码 ...
JUC(一)-AQS源码分析
01-21
为了学习JUC，AQS是基础中的基础，所以我们首先深入了解下AQS。 一、锁的介绍 为了了解AQS的源码，我们需要先大概下锁中的一些功能 1.1 乐观锁/悲观锁 乐观锁与悲观锁是一种广义上的概念，体现了看待线程同步的不同...
JUC基础知识(个人总结)
hellosrc的博客
03-04 8542
    声明: 1. 本文为我的个人复习总结, 并非那种从零基础开始普及知识 内容详细全面, 言辞官方的文章               2. 由于是个人总结, 所以用最精简的话语来写文章            
JUC学习笔记及实操（一）
weixin_44826010的博客
03-06 172
进程线程、Lock锁、生产者和消费者问题
JUC多线程学习笔记--狂神说
qq_42760375的博客
07-02 1068
JDK11又把synchronized优化了，然后又让CopyOnWrite用上了synchronized。Vector用的是synchronized来同步，而CopyOnWrite用的lock来同步。5、Vector是1.0版发布的，ArrayList是1.2版本发布的。
JUC（一）- JUC学习概览 - 对JUC有一个整体的认识
hiliang521的博客
08-01 818
JUC学习概览
JUC学习（一）
一条游向寒江的鱼
05-22 565
首先我们来分析，由于是同一个线程，并且B是一个赋值操作且读取了A，那么按照程序次序规则，A happens-before B，接着在B之后，马上执行了C，按照线程启动规则，在新的线程启动之前，当前线程之前的所有操作对新的线程是可见的，所以 B happens-before C，最后根据传递性规则，由于A happens-before B，B happens-before C，所以A happens-before C，因此在新的线程中会输出a修改后的结果10。那么它是怎么解决的重排序问题呢？
JUC 常用并发工具类教程（包括可重入锁ReentrantLock、CountDownLatch、读写锁ReadWriteLock、信号量Semaphore、常见队列等）
tttalk的博客
09-28 905
juc 多线程 重入锁ReentrantLock、CountDownLatch、读写锁ReadWriteLock、信号量Semaphore、常见队列
【并发编程】JUC并发编程（彻底搞懂JUC）
DreamSun的博客
03-29 5841
JUC实际上就是我们对于jdk中java.util .concurrent 工具包的简称，其结构如下：这个包下都是Java处理线程相关的类，自jdk1.5后出现。目的就是为了更好的支持高并发任务。让开发者进行多线程编程时减少竞争条件和死锁的问题！JUC主要是指JDK8中java.util.concurrent里提供的一系列线程并发工具，但是线程并发的问题远不止几个工具这么简单。要学习工具使用，更要能深入理解工具的原理以及处理线程并发问题的思路。
【JUC基础学习笔记】
sixteen_16的博客
03-24 1078
JUC基础学习笔记一、JUC概述1. JUC是什么2. 进程与线程3. 并发与并行4. sleep() 和 wait()等方法二、Lock1. Synchronized2. Lock接口与方法3. 两者异同4. Lock接口重要实现类三、线程通信 / 线程同步1. Synchronized同步块2. Lock锁四、线程安全1. 阻塞同步2. 非阻塞同步3. 非同步五、集合的线程安全1. 并发集合 ArrayList2. Vector3. Collections4. JUC.CopyOnWriteList..
java juc面试
最新发布
10-06
Java JUC（Java Util Concurrent）是Java并发编程中的一个重要模块，提供了一系列的工具类和API，用于实现高效的并发编程。 Java JUC包括了以下几个核心组件： 1. 锁：Java提供了多种锁机制来实现并发编程，例如ReentrantLock、Condition等。这些锁机制可以帮助开发人员实现线程安全的访问共享资源。 2. 并发集合：Java提供了一些并发安全的集合类，例如ConcurrentHashMap、ConcurrentLinkedQueue等。这些集合类在多线程环境中可以安全地进行并发操作。 3. 原子类：Java提供了一些原子类，例如AtomicInteger、AtomicLong等。这些原子类可以保证在多线程环境中对共享变量的操作是原子性的，从而避免了线程安全问题。 4. 线程池：Java提供了线程池来管理和调度线程的执行。通过使用线程池，可以有效地控制并发线程的数量，提高系统的性能和资源利用率。 5. 并发工具类：Java提供了一些其他的并发工具类，例如Semaphore、CountDownLatch等。这些工具类可以帮助开发人员实现更复杂的并发编程逻辑。 通过使用Java JUC，开发人员可以更方便地实现并发编程，提高系统的性能和可伸缩性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值